# packages

pkgId: 011bb33805a226e3e5ee338c0da034d645ac79f4a9300e5d807fd91028976ebc
name: python-ai-models-graphcast-gfs
arch: src
version: 0.0.12
epoch: 0
release: 1
url: https://github.com/jacob-radford/ai-models-graphcast-gfs
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-models-graphcast-gfs-0.0.12-1.src.rpm
checksum_type: sha256
summary:
  Run graphcast ai weather models with capabilities for GFS and GDAS initial conditions and NetCDF output

description:
  `ai-models-graphcast-gfs` is an extension of the [ai-models-graphcast](https://github.com/ecmwf-lab/ai-models-graphcast) package, which itself is a plugin to run Google Deepmind's [GraphCast](https://github.com/deepmind/graphcast) with [ai-models](https://github.com/ecmwf-lab/ai-models).

  GraphCast: Learning skillful medium-range global weather forecasting, arXiv preprint: 2212.12794, 2022. https://arxiv.org/abs/2212.12794

  GraphCast was created by Remi Lam, Alvaro Sanchez-Gonzalez, Matthew Willson, Peter Wirnsberger, Meire Fortunato, Ferran Alet, Suman Ravuri, Timo Ewalds, Zach Eaton-Rosen, Weihua Hu, Alexander Merose, Stephan Hoyer, George Holland, Oriol Vinyals, Jacklynn Stott, Alexander Pritzel, Shakir Mohamed and Peter Battaglia.

  The model weights are made available for use under the terms of the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0). You may obtain a copy of the License at: https://creativecommons.org/licenses/by-nc-sa/4.0/.



  To install the package, run:

  ```bash
  pip install ai-models-graphcast-gfs
  ```

  This will install the package and most of its dependencies.

  Then to install graphcast dependencies (and Jax on GPU):




  Graphcast depends on Jax, which needs special installation instructions for your specific hardware.

  Please see the [installation guide](https://github.com/google/jax#installation) to follow the correct instructions.

  We have prepared two `requirements.txt` you can use. A CPU and a GPU version:

  For the preferred GPU usage:
  ```
  pip install -r requirements-gpu.txt -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
  ```

  For the slower CPU usage:
  ```
  pip install -r requirements.txt
  ```


pkgId: d1b64d366cb6ffcb94be7ea00e4a887ae91593149e53ec4b7639c4e09fc554f8
name: python-ai-powered
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: The easiest way to develop AI-Powered applications
url: https://github.com/luochen1990/ai_powered
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-powered-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/github/luochen1990/ai_powered/graph/badge.svg?token=OBG1BWIKC2)](https://codecov.io/github/luochen1990/ai_powered)


pkgId: 16f64e8b1daddb48069488df5cc50f2a226967ceb8f5e03d6106d44c2e232221
name: python-ai-project-setup
arch: src
version: 0.2.8
epoch: 0
release: 1
url: https://pypi.org/project/ai-project-setup/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-project-setup-0.2.8-1.src.rpm
checksum_type: sha256
summary:
  A versatile utility package designed to streamline the setup of AI project structures while seamlessly integrating with Git repositories and Google Colab, simplifying the process of building collaborative AI projects.

description:
  The AI Project Starter Pack is a meticulously structured directory and module framework designed for creating machine learning and data science projects. This starter pack aims to streamline the project setup process, helping data scientists and developers organize their code, data, and documentation efficiently.




  - **Project Structure Setup**: Quickly set up standardized project structures for AI projects.
  - **Git Integration**: Seamlessly integrate with Git repositories for version control and collaboration.
  - **Google Colab Integration**: Easily collaborate on projects using Google Colab notebooks.
  - **Streamlined Workflow**: Simplify the process of building and managing collaborative AI projects.
  - **Automation**: Automate repetitive tasks and streamline project management.


pkgId: 12df6a1d74760af83834bfabafdd3d166a77fd99f5dc9b50db77e763bfea45b6
name: python-ai-review-assistant
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: An AI-powered code review assistant
url: https://github.com/vandriichuk/ai_review_assistant
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-review-assistant-0.7.0-1.src.rpm
checksum_type: sha256
description:
  You can install the latest version of AI Review Assistant from [GitHub](https://github.com/vvandriichuk/ai-review-assistant):

  ```bash
  pip install git+https://github.com/vvandriichuk/ai-review-assistant.git
  ```


  ai_review_assistant --help


  ai_review_assistant --vendor openai --model gpt-4o --api-key your_api_key --program-language "Python,JavaScript,TypeScript" --result-output-language English --ignore-settings-files/--review-all-files review



  ```[tool.code_review_assistant]
  prompt_template = """
  You are an AI Code Review Assistant with expert knowledge of {program_language}. As a senior {program_language} developer, review the following code changes:

  Project Structure:
  {project_structure}

  File being reviewed: {file_path}

  Analyze the code changes considering these aspects:
  1. Code quality and readability
  2. Potential bugs or errors
  3. Performance implications
  4. Consistency with the overall project structure
  5. Suggestions for improvement
  6. Best practices specific to {program_language}

  Instructions for your response:
  - Provide a concise summary (about 4-6 points) of your overall findings.
  - Focus only on the most important or critical issues, if any.
  - Clearly state whether you found any critical issues that need immediate attention.
  - Include 1-2 key suggestions for improvement, if applicable.
  - If no significant issues were found, briefly mention that the changes look good, but still provide a suggestion for potential enhancement if possible.

  Your summary should be structured as follows:
  1. Overall assessment (1-2 points)
  2. Critical issues (if any) (1-2 points)
  3. Key suggestions for improvement (3-4 points)

  Provide your summary in {result_output_language}.
  """
  ```






  - Added ignore_settings_files option to ignore settings files (toml, lock, md, txt, in, ini and that start from dot in the name)



  - Added missed rich library to dependencies list



  - Fixed some minor bugs with versions and documentations



  - You can put your own prompt to pyproject.toml file using [tool.code_review_assistant] block. Example of such block:



  - You can check version of AI Review Assistant



  - Added splitting long context by batch size
  - Added support for multiple languages
  - Added support for multiple models
  - You can run AI Review Assistant in any directory


  - Updated version of main dependencies libs



  - Init library

  [Unreleased]: https://github.com/vvandriichuk/ai-review-assistant/compare/v0.7.0...HEAD
  [0.7.0]: https://github.com/vvandriichuk/ai-review-assistant/compare/v0.6.2...v0.7.0
  [0.6.2]: https://github.com/vvandriichuk/ai-review-assistant/compare/v0.6.1...v0.6.2
  [0.6.1]: https://github.com/vvandriichuk/ai-review-assistant/compare/v0.6.0...v0.6.1
  [0.6.0]: https://github.com/vvandriichuk/ai-review-assistant/compare/v0.5.0...v0.6.0
  [0.5.0]: https://github.com/vvandriichuk/ai-review-assistant/compare/v0.4.0...v0.5.0
  [0.4.0]: https://github.com/vvandriichuk/ai-review-assistant/compare/v0.1.0...v0.4.0
  [0.1.0]: https://github.com/vvandriichuk/ai-review-assistant/releases/tag/v0.1.0


pkgId: b75eb66c3b57ba197771f7b881e77271cfa0dce75a5b8ef643fe193d5bdd5418
name: python-ai-signal
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Terminal-based AI curator that turns information noise into meaningful signal
url: https://github.com/guglielmo/ai-signal
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-signal-0.1.7-1.src.rpm
checksum_type: sha256
description:
  ![AI Signal Terminal](https://raw.githubusercontent.com/guglielmo/ai-signal/main/docs/images/ai-signal-terminal.png)

  Terminal-based AI curator that turns information noise into meaningful signal.



  - 🤖 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 with poetry:

  ```bash
  poetry add ai-signal
  ```



  1. Create a configuration file:
  ```bash
  aisignal init
  ```

  2. Edit your `~/.config/aisignal/config.yaml` along these lines:
  ```yaml

  sources:
  - https://news.ycombinator.com
  - https://django-news.com

  prompts:
    content_extraction: |
      Please extract the top 10 news, articles, posts, whatever items compose this list.

      For each items, find or generate:
      * the title
      * the source (URL of the list source)
      * the original URL of the item, or _link_
      * the categories, among the available ones, listed below.

      Generate a list of items in markdown format, strictly following this syntax:

      

      1. **Title:** Announcing the 6.x Django Steering Council elections 🚀
         **Source:** https://django-news.com
         **Link:** https://cur.at/3TNDN81?m=web
         **Categories:** Django

      2. **Title:** Django Channels 4.2.0 Release Notes
         **Source:** https://django-news.com
         **Link:** https://cur.at/R9ZJhRV?m=web
         **Categories:** Django
      ...

      In particular, the Source should only contain the URL.

  categories:
  - AI/ML
  - Django
  - Programming
  - Security
  - DevOps
  - Docker
  - Modern Data Stack

  quality_threshold: 0.7
  sync_interval: 24
  obsidian:
    vault_path: '/~/Documents/Obsidian Vault'
    template_path: ''
  social:
    twitter_template: '{title}


      {url}


      
  api_keys:
    jinaai: -Your JinaAI key-
    openai: -Your OpenAI key
  ```

  3. Run AI Signal:
  ```bash
  aisignal
  ```




  - `q`: Quit application
  - `c`: Toggle configuration panel
  - `s`: Force sync content
  - `f`: Toggle filters


  - `↑`/`↓`: Navigate items
  - `enter`: Show item details
  - `o`: Open in browser
  - `t`: Share on Twitter
  - `l`: Share on LinkedIn
  - `e`: Export to Obsidian



  AI Signal can be configured via YAML file or through the TUI configuration panel. Main configuration options:

  - Content
    - Sources to monitor
    - Sync interval, in hours
    - Categories of interest
    - Prompt for content extraction

  - Filtering
    - Quality threshold
    - Category filters
    - Source filters

  - Integration
    - Obsidian vault path
    - Obsidian templates
    - Social media templates

  See the [configuration guide](docs/configuration.md) for detailed options.




  ![Main Interface](https://raw.githubusercontent.com/guglielmo/ai-signal/main/docs/images/main.png)




  Contributions are welcome! Please read our [Contributing Guide](CONTRIBUTING.md) to get started.



  ```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)
  - [ ] Implement custom AI models
  - [ ] Add content archiving
  - [ ] Enable custom prompts for sources
  - [ ] Enable custom filtering rules
  - [ ] Add data export/import



  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: 8f6f078196002c7a58741206de9a6ff67d0e84dd50af11b32709fe8878b16379
name: python-ai-signal
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Terminal-based AI curator that turns information noise into meaningful signal
url: https://github.com/guglielmo/ai-signal
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-signal-0.6.0-1.src.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: 1867e7e307c5a3de243c6fe64e26edb30c8705392811aa9417e705e2d10fd679
name: python-ai-stepper
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A flexible Python framework for creating step-by-step AI workflows
url: https://github.com/alfredwallace7/ai-stepper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-stepper-0.1.1-1.src.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.)
  - **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., `dynamic_team_task_management.yaml`):

  ```yaml
  generate_team_members:
    task: >
      Generate {team_size} team members with realistic names and roles.
      Each team member should have:
      - id (integer)
      - name (string)
      - role (string: developer, designer, manager, etc.)
      - skills (array of strings)
    inputs:
      team_size:
        type: integer
    outputs:
      team_members:
        type: array
        items:
          type: object
          properties:
            id:
              type: integer
            name:
              type: string
            role:
              type: string
            skills:
              type: array
              items:
                type: string

  generate_tasks:
    task: >
      Generate {task_count} tasks that need to be assigned to the team members {team_members}.
      Each task should have:
      - id (integer)
      - title (string)
      - description (string)
      - required_skills (array of strings)
      - estimated_hours (integer between 4-40)
    inputs:
      task_count:
        type: integer
      team_members:
        type: array
    outputs:
      tasks:
        type: array
        items:
          type: object
          properties:
            id:
              type: integer
            title:
              type: string
            description:
              type: string
            required_skills:
              type: array
              items:
                type: string
            estimated_hours:
              type: integer
  ```


  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 = [
              ("dynamic team task management", "yaml/dynamic_team_task_management.yaml", {
                  "team_size": 12,
                  "task_count": 10
              }),
          ]

          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. Generates a team of members with different roles and skills
  2. Creates tasks with specific requirements
  3. Uses structured validation to ensure the LLM outputs match the expected format

  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.



  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: be96c175a6ec5b3f6445b3836c85797a46cc4529e84f8157c3e6837cfac7ecb8
name: python-ai-stream-interact
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: An model agnostic extensible package that allows for AI & LLM interactions on a video stream
url: https://pypi.org/project/ai-stream-interact/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-stream-interact-0.0.9-1.src.rpm
checksum_type: sha256
description:
  This package can easily be extended to accommodate different LLMs, but for this first version interactions were implemented only for [Google's Gemini Pro & Vision Pro Models](https://ai.google.dev/tutorials)

  **Note: This is a basic Alpha version that's been written & tested in Ubuntu Linux only so it may have unexpected behavior with other operating systems.**

  <br>
  <br>


  - `pip install ai-stream-interact`

  Note that pip install might take a while as it will also install [coqui-ai](https://github.com/coqui-ai/TTS) for Text to Speech. Although TTS is partially implemented it is not turned on by default due to some glitchy behavior. (This will be fixed in future releases.)



  1. You need a Gemini API key. (if you don't already have one you can get one [here](https://ai.google.dev/tutorials/setup)).
  2. Have a USB camera connected.
  3. run `aisi --llm gemini` to enter the AI Stream Interact🧠🎞️ main menu. _(note that you can always go back to the main menu from the video stream by press "**m**" while having the video stream focused.)_
  4. Enter the API key or press enter if you've added it to .env.
  5. You will be asked to enter your camera index. Currently there is no straight forward way to identify the exact index for your camera's name due to how open-cv enumerates such indicies so you'll have to just try a few times till you get the right one if you have multiple camers connected. If you have one camera connected you can try passing "**-1**" as in most cases it'll just pick that one.

  Now you're in!. You have access to 3 types of interactions as of today.


  This fires up a window with your camera stream and whenever you press "**d**" will identify the object the camera is looking at. (Make sure to press "**d**" with the camera window focused and not your terminal).
  ![](https://github.com/The0mar/ai_stream_interact/blob/main/gifs/detect.gif)



  Use this to write up a custom prompt before showing the model an object for custom interactions beyond just identifying objects.
  ![](https://github.com/The0mar/ai_stream_interact/blob/main/gifs/detect_custom.gif)


  This just allows for back & forth chat with the model.





  - `google.api_core.exceptions.FailedPrecondition: 400 User location is not supported for the API use.`: **This is specific to Gemini as they currently do not provide general availability to all regions, so you need to make sure your region is supported [here](https://ai.google.dev/available_regions#available_regions)**


pkgId: 105747b70282cb5a7ae148086466a0ed670f02a479fcd628afb378a704ad6741
name: python-ai-term
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: A powerful CLI tool for AI interactions
url: https://github.com/ryaneggz/ai-term
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-term-0.0.0-1.src.rpm
checksum_type: sha256
description:
  LangGraph Bot is a Python-based chatbot application that utilizes the LangGraph and LangChain libraries to process and respond to user inputs. The bot is designed to handle conversational flows and can be configured to use different language models.



  - Stream processing of user inputs and bot responses.
  - Visualization of state graphs using Mermaid.
  - Configurable session management for chat history.
  - Integration with OpenAI's GPT-4o, or Claude 3.5 Sonnet model.



  - Python 3.10 or higher
  - Access to OpenAI API (for GPT-4o model) or Anthropic API (for Claude 3.5 Sonnet)



  1. **Clone the repository:**

     ```bash
     git clone https://github.com/ryaneggz/langgraph-template.git
     cd langgraph-template
     ```

  2. **Set up a virtual environment using `uv venv`:**

     ```bash
     python -m venv .venv
     source .venv/bin/activate  # On Windows use `.venv\Scripts\activate`
     ```

  3. **Install the dependencies:**

     ```bash
     pip install -r requirements.txt
     ```



  1. **Create a configuration directory:**

     ```bash
     ai --env
     ```



  **Run the application:**

     To start the chatbot, run the following command:

     ```bash
     source .env && python main.py
     ```

     The bot will start a chat loop where you can input messages. Type "quit", "exit", or "q" to end the session.



  This project includes tools for running shell commands and Docker container operations. For detailed information, please refer to the following documentation:

  - [Tools Documentation](./docs/tools.md)
  - [Docker Compose Configuration](./docs/docker-compose.md)
  - [Human-In-The-Loop](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-hitl/#usage)




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



  Distributed under the MIT License. See `LICENSE` for more information.


pkgId: 2d290fe7b5839469b80ab90a71cf8109074844891aa32ad568771d27803d4e35
name: python-ai-tqa
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: A text evaluation module using AI-TQA1 Basic
url: https://github.com/krozen-dev/AI_TextScan
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-tqa-1.1.4-1.src.rpm
checksum_type: sha256
description:
  TextEvaluator использует модель **AI-TQA1 Basic** для оценки текста и определения наличия в нем плохих слов или выражений.

  Алгоритм **автоматически** очищает текст от ненужных символов (например, заменяет "я-бло/ко" на "яблоко"), что **улучшает точность оценки**.



  Модуль может извлекать текст из фотографии для последующей обработки, используя бесплатный API ключ [Free OCR API](https://ocr.space/ocrapi)



  Модель продемонстрировала **87.46**% точности в оценках на основе результатов тестирования, проведенного на **500** предложениях.



  - **Украинский**
  - **Русский**



  `pip install ai-tqa`



  `pip install --upgrade ai-tqa`



  ```python
  from ai_tqa import TextEvaluator

  evaluator = TextEvaluator()

  text = "Привет, даун!" # Текст для оценки

  result_with_detail = evaluator.evaluate_text(text, detail=True) # Функция возвращает оценку со списком плохих слов
  result_without_detail = evaluator.evaluate_text(text, detail=False) # Функция возвращает оценку текста

  print(f"Результат с деталями: Оценка: {result_with_detail[0]}, Плохие слова: {result_with_detail[1]}") # Вывод результата оценки
  print(f"Результат без деталей: Оценка: {result_without_detail}") # Вывод результата оценки
  ```



  ```python
  from ai_tqa import TextEvaluator

  evaluator = TextEvaluator()

  image_path = "example.png" # Путь к фото
  api_key = "FREE_OCR_API" # API ключ Free OCR API
  language = "rus" # Язык для обнаружения
  extracted_text = evaluator.read_image(image_path, api_key=api_key, language=language) # Извлечение текста из фото

  print(f"Извлеченный текст: {extracted_text}") # Вывод извлечённого текста
  ```

  - [Получить ключ](https://ocr.space/ocrapi/freekey)
  - [Документация](https://ocr.space/ocrapi)



  - **`_KroZen_`**


pkgId: 24a81c40d8f58567e2f6ee51dd37e3bf97a57794ce47944f445f57416581d74a
name: python-ai-transformersx
arch: src
version: 0.6.17
epoch: 0
release: 1
summary: tools for using huggingface/transformers more easily
url: https://github.com/aicanhelp/ai-transformers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai-transformersx-0.6.17-1.src.rpm
checksum_type: sha256
description:
  [🤗 Transformers](https://github.com/huggingface/transformers) 是一个非常好用的专门针对基于Pytorch的Transformer相关NLP深度学习模型的工具库。
  它管理和归类了当前几乎所有的最好的基于的Transformer的自然语言模型以及公开的预训练模型，并都转换成了Pytorch。
  （1）使用它你可以很方便的做Bert/Albert/GPT2/XLNET等当前最好的自然语言预训练模型训练以及下游任务的模型开发和训练。
  （2）使用Pytorch实现的模型有更清晰的代码机构，对学习者来说，学习和理解这些自然语言更为容易。
  （3）提供了一个地方收集和存放公开的自然语言预训练模型，供研究人员使用。研究人员也可以把自己愿意公开的预训练模型放到Transformer上供别人研究使用。

  但是Transformers也有一些问题：
  （1）根据当前的Transformers的实现看，所有的公开的Transformer的预训练模型都是存放在AWS的S3上。对国外的研究人员那没有什么问题。中国的研究人员需要下载这些模型
  就有点费周折了。当前Transformers的模型下载方式有两种：（1）通过代码调用指定模型时，自动去相应的S3上下载。（2）直接到Transformers的网上流量相应的模型文件通过浏览器下载。
  反正不管那种方式，想顺利的下载下来，自己想办法吧～。不多说。
  （2）尽管Transformers已经提供了一种比较方便的方式来使用各种Transformer相关模型了。但是还是不够好。首先，从设计上，各种模型的实现很不错，但是因为模型的实现与模型的存储和下载深度绑定。
  这个设计应该是有问题的。从职责上说，模型的实现和模型的存储下载应该分离。
  （3）Transformers增加了一个Trainer以方便研究人员训练Transformer模型使用。同样，这个Trainer的设计和实现水平跟模型的设计和实现也一样有不少的差距。


  本项目的目的是想针对Transformers的一些问题，对Transformers做进一步的扩展，让研究人员使用Transformers更方便。当然也没有解决上面提到的所有问题。

  本项目的解决方法是，在docker目录中提供了几种用于Transformers相关模型的训练和运行环境的Docker定义，
  利用阿里云的Docker海外构建机器，在构建Docker是顺便把指定的预训练模型下载下来。当前主要是中文语言模型，包括bert、albert、robert、electra。可以直接从阿里云镜像库获取。
  相关模型放在镜像的/app/models目录下面。
  ```
  docker pull registry.cn-beijing.aliyuncs.com/modoso/transformersx-bert
  docker pull registry.cn-beijing.aliyuncs.com/modoso/transformersx-albert
  docker pull registry.cn-beijing.aliyuncs.com/modoso/transformersx-robert
  docker pull registry.cn-beijing.aliyuncs.com/modoso/transformersx-electra
  ```
  最好使用脚本download-models.sh 下载并从镜像中把模型copy出来的脚本。
  ```
  sh download-models.sh [指定模型存放目录]
  ```

  首先，你可以简单的像examples.task.sentiment.sentiment_task那样实现情感识别，只需要实现一个DataProcessor和一个Task

  ```python
  from ai_transformersx import DataProcessor,DataArguments,join_path,InputExample,log,TaskArguments
  from ai_transformersx.examples import ExampleTaskBase
  import pandas as pd
  class SentimentDataProcessor(DataProcessor):
      def __init__(self, config: DataArguments):
          self._config = config

      def _get_example(self, file_name, type):
          pd_all = pd.read_csv(join_path(self._config.data_dir, file_name))

          log.info("Read data from {}, length={}".format(join_path(self._config.data_dir, file_name), len(pd_all)))
          examples = []
          for i, d in enumerate(pd_all.values):
              examples.append(InputExample(guid=type + '_' + str(i),
                                           text_a=d[1],
                                           label=str(d[0])))

          return examples

      def get_train_examples(self):
          return self._get_example('train.csv', 'train')

      def get_dev_examples(self):
          return self._get_example('dev.csv', 'dev')

      def get_labels(self):
          return ['0', '1', '2', '3']

      def data_dir(self):
          return self._config.data_dir


  class SentimentTask(ExampleTaskBase):
      def __init__(self, taskArgs: TaskArguments = None):
          super().__init__('sentiment', taskArgs)
          self.task_args.model_args.num_labels = 4

      def _data_processor(self):
          return SentimentDataProcessor(self.task_args.data_args)
  ```
  然后，像examples.task.main那样实现启动方法：
  ```python
  from ai_transformersx.examples import ExampleManagement
  from ai_transformersx.examples.tasks import SentimentTask
  task_manager = ExampleManagement()
  task_manager.register_tasks([
      ('sentiment', SentimentTask)
  ])

  if __name__ == "__main__":
      task_manager.start_example_task()

  ```
  接着，你就可以训练你的情感识别的模型了。你应该在下载的镜像模型中进行。
  - 查看所有sentiment任务参数
  ```
      python main.py sentiment -h
  ```
  - 训练模型（可以参考上面的帮助列表设置相关的参数）
  ```
      python main.py sentiment
  ```




  - 使用 pytorchlightning和fastai来实现trainer
  - 增加更多的自然语言任务的例子


pkgId: 158716bbb6076135fca6568f040390a193ae9f0043b42e5af131b2edb980b470
name: python-ai.cdas
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Python interface to CDAS data via REST API
url: https://bitbucket.org/isavnin/ai.cdas
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai.cdas-1.2.3-1.src.rpm
checksum_type: sha256
description:
  This library provides access to CDAS database from python in a simple and fluid way through `CDAS REST api <http://cdaweb.gsfc.nasa.gov/WebServices/REST/>`_. It fetches the data either in `CDF (Common Data Format) <http://cdf.gsfc.nasa.gov/>`_ or ASCII format and returns it in the form of dictionaries of numpy arrays.
  The full documentation is available at `aicdas.rtfd.io <http://aicdas.rtfd.io>`_.


pkgId: 0239bf2a21318f337ec864272c9a7a8f85bca264d1c8cb989e879a179b573f2e
name: python-ai2-kit
arch: src
version: 0.21.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ai2-kit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2-kit-0.21.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ai2-kit.svg)](https://badge.fury.io/py/ai2-kit)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/ai2-kit)](https://pypi.org/project/ai2-kit/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ai2-kit)](https://pypi.org/project/ai2-kit/)


  A toolkit featured _**a**rtificial **i**ntelligence × **a**b **i**nitio_ for computational chemistry research.

  *Please be advised that `ai2-kit` is still under heavy development and you should expect things to change often. We encourage people to play and explore with `ai2-kit`, and stay tuned with us for more features to come.*



  * Collection of tools to facilitate the development of automated workflows for computational chemistry research.
  * Utilities to execute and manage jobs in local or remote HPC job scheduler.
  * Utilities to simplified automated workflows development with reusable components.



  You can use the following command to install `ai2-kit`:

  ```bash

  pip install ai2-kit


  pip install ai2-kit[all]
  ```

  If you want to run `ai2-kit` from source, you can run the following commands in the project folder:

  ```bash
  pip install poetry
  poetry install

  ./ai2-kit --help
  ```
  Note that instead of running global `ai2-kit` command, you should run `./ai2-kit` to run the command from source on Linux/MacOS or `.\ai2-kit.ps1` on Windows.



  * [ai2-cat](doc/manual/ai2cat.md): A toolkit for dynamic catalysis researching.


  * [CLL MLP Training Workflow](doc/manual/cll-workflow.md) ([zh](doc/manual/cll-workflow.zh.md))


  * [Proton Transfer Analysis Toolkit](doc/manual/proton-transfer.md)
  * [Amorphous Oxides Structure Analysis Toolkit](doc/manual/aos-analysis.md)


  * [Tips](doc/manual/tips.md): useful tips for using `ai2-kit`
  * [Batch Toolkit](doc/manual/batch.md): a toolkit to generate batch scripts from files or directories
  * [ASE Toolkit](doc/manual/ase.md): commands to process trajectory files with [ASE](https://wiki.fysik.dtu.dk/ase/)
  * [dpdata Toolkit](doc/manual/dpdata.md): commands to process system data with [dpdata](https://github.com/deepmodeling/dpdata/)


  * [ai2cat](notebook/ai2cat.ipynb)


  * [HPC Executor Introduction](doc/manual//hpc-executor.md) ([zh](doc/manual/hpc-executor.zh.md)): a simple HPC executor for job submission and management
  * [Checkpoint Mechanism](doc/manual/checkpoint.md)



  This project is inspired by and built upon the following projects:
  * [dpgen](https://github.com/deepmodeling/dpgen/tree/master/dpgen): A concurrent learning platform for the generation of reliable deep learning based potential energy models.
  * [ase](https://wiki.fysik.dtu.dk/ase/): Atomic Simulation Environment.


pkgId: 367bceac417125c2c07ca81ebd17911d48b2fa5a2ddb40fcf973c2f62a5fa7cb
name: python-ai2-kit
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ai2-kit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2-kit-0.22.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ai2-kit.svg)](https://badge.fury.io/py/ai2-kit)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/ai2-kit)](https://pypi.org/project/ai2-kit/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ai2-kit)](https://pypi.org/project/ai2-kit/)


  A toolkit featured _**a**rtificial **i**ntelligence × **a**b **i**nitio_ for computational chemistry research.

  *Please be advised that `ai2-kit` is still under heavy development and you should expect things to change often. We encourage people to play and explore with `ai2-kit`, and stay tuned with us for more features to come.*



  * Collection of tools to facilitate the development of automated workflows for computational chemistry research.
  * Utilities to execute and manage jobs in local or remote HPC job scheduler.
  * Utilities to simplified automated workflows development with reusable components.



  You can use the following command to install `ai2-kit`:

  ```bash

  pip install ai2-kit


  pip install ai2-kit[all]
  ```

  If you want to run `ai2-kit` from source, you can run the following commands in the project folder:

  ```bash
  pip install poetry


  poetry install

  ./ai2-kit --help
  ```
  Note that instead of running global `ai2-kit` command, you should run `./ai2-kit` to run the command from source on Linux/MacOS or `.\ai2-kit.ps1` on Windows.



  * [ai2-cat](doc/manual/ai2cat.md): A toolkit for dynamic catalysis researching.


  * [CLL MLP Training Workflow](doc/manual/cll-workflow.md) ([zh](doc/manual/cll-workflow.zh.md))


  * [Proton Transfer Analysis Toolkit](doc/manual/proton-transfer.md)
  * [Amorphous Oxides Structure Analysis Toolkit](doc/manual/aos-analysis.md)


  * [Tips](doc/manual/tips.md): useful tips for using `ai2-kit`
  * [Batch Toolkit](doc/manual/batch.md): a toolkit to generate batch scripts from files or directories
  * [ASE Toolkit](doc/manual/ase.md): commands to process trajectory files with [ASE](https://wiki.fysik.dtu.dk/ase/)
  * [dpdata Toolkit](doc/manual/dpdata.md): commands to process system data with [dpdata](https://github.com/deepmodeling/dpdata/)


  * [ai2cat](notebook/ai2cat.ipynb)


  * [HPC Executor Introduction](doc/manual//hpc-executor.md) ([zh](doc/manual/hpc-executor.zh.md)): a simple HPC executor for job submission and management
  * [Checkpoint Mechanism](doc/manual/checkpoint.md)



  This project is inspired by and built upon the following projects:
  * [dpgen](https://github.com/deepmodeling/dpgen/tree/master/dpgen): A concurrent learning platform for the generation of reliable deep learning based potential energy models.
  * [ase](https://wiki.fysik.dtu.dk/ase/): Atomic Simulation Environment.


pkgId: 205574d1c64166c31f0e37cdb57933fcbff39fe26cac5f28ee52ba67bc927211
name: python-ai2-kit
arch: src
version: 0.22.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ai2-kit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2-kit-0.22.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ai2-kit.svg)](https://badge.fury.io/py/ai2-kit)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/ai2-kit)](https://pypi.org/project/ai2-kit/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ai2-kit)](https://pypi.org/project/ai2-kit/)


  A toolkit featured _**a**rtificial **i**ntelligence × **a**b **i**nitio_ for computational chemistry research.

  *Please be advised that `ai2-kit` is still under heavy development and you should expect things to change often. We encourage people to play and explore with `ai2-kit`, and stay tuned with us for more features to come.*



  * Collection of tools to facilitate the development of automated workflows for computational chemistry research.
  * Utilities to execute and manage jobs in local or remote HPC job scheduler.
  * Utilities to simplified automated workflows development with reusable components.



  You can use the following command to install `ai2-kit`:

  ```bash

  pip install ai2-kit


  pip install ai2-kit[all]
  ```

  If you want to run `ai2-kit` from source, you can run the following commands in the project folder:

  ```bash
  pip install poetry


  poetry install

  ./ai2-kit --help
  ```
  Note that instead of running global `ai2-kit` command, you should run `./ai2-kit` to run the command from source on Linux/MacOS or `.\ai2-kit.ps1` on Windows.



  * [ai2-cat](doc/manual/ai2cat.md): A toolkit for dynamic catalysis researching.


  * [CLL MLP Training Workflow](doc/manual/cll-workflow.md) ([zh](doc/manual/cll-workflow.zh.md))


  * [Proton Transfer Analysis Toolkit](doc/manual/proton-transfer.md)
  * [Amorphous Oxides Structure Analysis Toolkit](doc/manual/aos-analysis.md)


  * [Tips](doc/manual/tips.md): useful tips for using `ai2-kit`
  * [Batch Toolkit](doc/manual/batch.md): a toolkit to generate batch scripts from files or directories
  * [ASE Toolkit](doc/manual/ase.md): commands to process trajectory files with [ASE](https://wiki.fysik.dtu.dk/ase/)
  * [DPData Toolkit](doc/manual/dpdata.md): commands to process system data with [dpdata](https://github.com/deepmodeling/dpdata/)
  * [Model Deviation Toolkit](doc/manual/model-deviation.md): a toolkit to filter structures by model deviation


  * [ai2cat](notebook/ai2cat.ipynb)


  * [HPC Executor Introduction](doc/manual//hpc-executor.md) ([zh](doc/manual/hpc-executor.zh.md)): a simple HPC executor for job submission and management
  * [Checkpoint Mechanism](doc/manual/checkpoint.md)



  This project is inspired by and built upon the following projects:
  * [dpgen](https://github.com/deepmodeling/dpgen/tree/master/dpgen): A concurrent learning platform for the generation of reliable deep learning based potential energy models.
  * [ase](https://wiki.fysik.dtu.dk/ase/): Atomic Simulation Environment.


pkgId: 69e0d98d49be245ddafa897207ec93d606a14df965958033bea68765d3d6d94c
name: python-ai2-olmo
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Open Language Model (OLMo)
url: https://github.com/allenai/OLMo
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2-olmo-0.5.0-1.src.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 built by scientists, for scientists.



  First install [PyTorch](https://pytorch.org) according to the instructions specific to your operating system.

  To install from source (recommended for training/fine-tuning) run:

  ```bash
  git clone https://github.com/allenai/OLMo.git
  cd OLMo
  pip install -e .[all]
  ```

  Otherwise you can install the model code by itself directly from PyPI with:

  ```bash
  pip install ai2-olmo
  ```





  The core models in the OLMo family released so far are (all trained on the [Dolma dataset](https://huggingface.co/datasets/allenai/dolma)):
  | Model | Training Tokens | Context Length | Training Config | W&B Logs | Data Order File(s) ☨ |
  |-------|-----------------|:--------------:|-----------------|----------|--------------------|
  | [OLMo 1B](https://huggingface.co/allenai/OLMo-1B) | 3 Trillion | 2048 | [configs/official/OLMo-1B.yaml](https://github.com/allenai/OLMo/blob/main/configs/official/OLMo-1B.yaml) | [wandb.ai/…/OLMo-1B](https://wandb.ai/ai2-llm/OLMo-1B/reports/OLMo-1B--Vmlldzo2NzY1Njk1) | [epoch 1](https://olmo-checkpoints.org/ai2-llm/olmo-small/46zc5fly/train_data/global_indices.npy) |
  | [OLMo 7B](https://huggingface.co/allenai/OLMo-7B) | 2.5 Trillion | 2048 | [configs/official/OLMo-7B.yaml](https://github.com/allenai/OLMo/blob/main/configs/official/OLMo-7B.yaml) | [wandb.ai/…/OLMo-7B](https://wandb.ai/ai2-llm/OLMo-7B/reports/OLMo-7B--Vmlldzo2NzQyMzk5) | [epoch 1](https://olmo-checkpoints.org/ai2-llm/olmo-medium/wvc30anm/train_data/global_indices.npy), [epoch 2](https://olmo-checkpoints.org/ai2-llm/olmo-medium/wd2gxrza/train_data/global_indices.npy) |
  | [OLMo 7B Twin 2T](https://huggingface.co/allenai/OLMo-7B-Twin-2T) | 2 Trillion  | 2048 | [configs/official/OLMo-7B.yaml](https://github.com/allenai/OLMo/blob/main/configs/official/OLMo-7B.yaml) | [wandb.ai/…/OLMo-7B-Twin-2T](https://wandb.ai/ai2-llm/OLMo-7B/reports/OLMo-7B-Twin-2T--Vmlldzo2NzU0NTIz) | [epoch 1](https://olmo-checkpoints.org/ai2-llm/olmo-medium/wvc30anm/train_data/global_indices.npy) |
  | [OLMo 7B April 2024](https://huggingface.co/allenai/OLMo-7B-0424-hf) | 2.05 Trillion  | 4096 | [configs/official/OLMo-7B-0424.yaml](https://github.com/allenai/OLMo/blob/main/configs/official/OLMo-7B-0424.yaml) | *Coming soon* | *Coming soon* |
  | [OLMo 7B July 2024](https://huggingface.co/allenai/OLMo-7B-0724-hf) | 2.75 Trillion  | 4096 | [configs/official/OLMo-7B-0724.yaml](https://github.com/allenai/OLMo/blob/main/configs/official/OLMo-7B-0724.yaml) | *Coming soon* | *Coming soon* |

  > ☨ *See [Inspecting training data](#inspecting-training-data) below for usage.*



  URLs to checkpoints at intermediate steps of the models' trainings can be found in the csv files under [`checkpoints/official/`](https://github.com/allenai/OLMo/blob/main/checkpoints/official). These 'directory' URLs cannot currently be directly accessed, but files within the directory are publicly accessible. These URLs can also be provided to the training script to resume training from the checkpoint (see [Training](#training)). Each checkpoint directory consists of:

  - `config.yaml`: the config at that training step.
  - `model.pt`, `optim.pt`, `train.pt`: model, optimizer and training state at that training step.

  Details about the other types of OLMo checkpoints (including OLMo HF Transformers checkpoints) can be found in [Checkpoints.md](https://github.com/allenai/OLMo/blob/main/docs/Checkpoints.md).



  You can utilize our Hugging Face integration to run inference on the OLMo Transformers checkpoints:

  ```python
  from transformers import AutoModelForCausalLM, AutoTokenizer

  olmo = AutoModelForCausalLM.from_pretrained("allenai/OLMo-7B-0724-hf")
  tokenizer = AutoTokenizer.from_pretrained("allenai/OLMo-7B-0724-hf")

  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-7B-0724-hf")
  print(olmo_pipe("Language modeling is"))
  ```



  If you finetune the model using the code in [Fine-tuning](#fine-tuning), you can use the conversion script to convert a native OLMo checkpoint to a Hugging Face-compatible checkpoint.

  ```bash
  python scripts/convert_olmo_to_hf_new.py --input_dir /path/to/olmo/checkpoint --output_dir /path/to/hf/checkpoint/ --tokenizer_json_path tokenizers/allenai_gpt-neox-olmo-dolma-v1_5.json
  ```



  ```python
  olmo = AutoModelForCausalLM.from_pretrained("allenai/OLMo-7B-0724-hf", torch_dtype=torch.float16, load_in_8bit=True)  # requires bitsandbytes
  ```

  The quantized model is more sensitive to typing / cuda, so it is recommended to pass the inputs as inputs.input_ids.to('cuda') to avoid potential issues.





  The configs used to train the official OLMo models are provided in the [`configs/official/`](https://github.com/allenai/OLMo/blob/main/configs/official) directory.

  Note that while the training and validation data is public and free to download, the paths to the data within those configs are pointed at a CloudFlare R2 bucket, which requires an API key for programmatic access.
  So in order to use any of these configs to reproduce a training run you'll first have to download the corresponding data to a location of your choosing and then update the paths in the config accordingly.

  You can derive the public HTTP URL from an R2 URL by replacing `r2://olmo-data` with `https://olmo-data.org`.
  For example, if the R2 data URL is:

  `r2://olmo-data/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-000-00000.npy`

  then the corresponding public URL is:

  `https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-000-00000.npy`

  Once you've updated the data paths in the config you can launch a training run via `torchrun`. For example, to launch the 1B model training on a single 8x GPU node, you would run:

  ```bash
  torchrun --nproc_per_node=8 scripts/train.py configs/official/OLMo-1B.yaml
  ```

  You can use the same method to launch multi-node jobs as well. See [the documentation](https://pytorch.org/docs/stable/elastic/run.html) for `torchrun` to understand the additional arguments you'll need to configure the rendezvous backend / endpoint.

  To resume training from a checkpoint, you can pass its path (local or URL)
  to `scripts/train.py` with the `--load_path` arguments. For example, to resume training from step 1000 of the OLMo 1B run:

  ```bash
  torchrun --nproc_per_node=8 scripts/train.py configs/official/OLMo-1B.yaml --load_path=https://olmo-checkpoints.org/ai2-llm/olmo-small/w1r5xfzt/step1000-unsharded
  ```



  You may be interested in inspecting the exact tokens that composed a particular batch during the training of one of the OLMo models.
  We provide tools to do this, but first you'll need to download the data as above (unless you have an R2 API key) and update the corresponding config accordingly.

  Then take note of the URL of the data order file you want, which can be found in the [Models Overview](#models-overview) table. For example, the data order file for the first epoch of the OLMo-7B model is [https://olmo-checkpoints.org/ai2-llm/olmo-medium/wvc30anm/train_data/global_indices.npy](https://olmo-checkpoints.org/ai2-llm/olmo-small/46zc5fly/train_data/global_indices.npy).

  Once you have that you can use this snippet to inspect the data within a particular batch:

  ```python
  import numpy as np
  from cached_path import cached_path

  from olmo.config import TrainConfig
  from olmo.data import build_memmap_dataset


  data_order_file_path = cached_path("https://olmo-checkpoints.org/ai2-llm/olmo-medium/wvc30anm/train_data/global_indices.npy")
  train_config_path = "configs/official/OLMo-7B.yaml"


  cfg = TrainConfig.load(train_config_path)
  dataset = build_memmap_dataset(cfg, cfg.data)
  batch_size = cfg.global_train_batch_size
  global_indices = np.memmap(data_order_file_path, mode="r+", dtype=np.uint32)


  def get_batch_instances(batch_idx: int) -> list[list[int]]:
      batch_start = batch_idx * batch_size
      batch_end = (batch_idx + 1) * batch_size
      batch_indices = global_indices[batch_start:batch_end]
      batch_instances = []
      for index in batch_indices:
          token_ids = dataset[index]["input_ids"].tolist()
          batch_instances.append(token_ids)
      return batch_instances



  get_batch_instances(0)
  ```




  To fine-tune an OLMo model using our trainer you'll first need to prepare your dataset by tokenizing it and saving the tokens IDs to a flat numpy memory-mapped array. See [`scripts/prepare_tulu_data.py`](./scripts/prepare_tulu_data.py) for an example with the Tulu V2 dataset, which can be easily modified for other datasets.

  Next, prepare your training config. There are many examples in the [`configs/`](https://github.com/allenai/OLMo/blob/main/configs) directory that you can use as a starting point. The most important thing is to make sure the model parameters (the `model` field in the config) match up with the checkpoint you're starting from. To be safe you can always start from the config that comes with the model checkpoint. At a minimum you'll need to make the following changes to the config or provide the corresponding overrides from the command line:

  - Update `load_path` to point to the checkpoint you want to start from.
  - Set `reset_trainer_state` to `true`.
  - Update `data.paths` to point to the `token_ids.npy` file you generated.
  - Optionally update `data.label_mask_paths` to point to the `label_mask.npy` file you generated, unless you don't need special masking for the loss.
  - Update `evaluators` to add/remove in-loop evaluations.

  Once you're satisfied with your training config, you can launch the training job via `torchrun`. For example:

  ```
  torchrun --nproc_per_node=8 scripts/train.py {path_to_train_config} \
      --data.paths=[{path_to_data}/input_ids.npy] \
      --data.label_mask_paths=[{path_to_data}/label_mask.npy] \
      --load_path={path_to_checkpoint} \
      --reset_trainer_state
  ```

  Note: passing CLI overrides like `--reset_trainer_state` is only necessary if you didn't update those fields in your config.



  Additional tools for evaluating OLMo models are available at the [OLMo Eval](https://github.com/allenai/ai2-olmo-eval) repo.



  See [Debugging](https://github.com/allenai/OLMo/blob/main/docs/NOTES.md#debugging).



  ```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: 1c3142fa7e524318f39542775a3ff8acd8e8db715f5217ddc967be20afff88b5
name: python-ai2-olmo-core
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Core training module for the Open Language Model (OLMo)
url: https://github.com/allenai/OLMo-core
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2-olmo-core-1.4.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1>OLMo-core</h1>
    <p>Building blocks for OLMo modeling and training</p>
  </div>
  <p align="center">
    <a href="https://github.com/allenai/OLMo-core/tree/main/src/examples">Examples</a> ||
    <a href="https://olmo-core.readthedocs.io/en/latest/">Docs</a> ||
    <a href="https://pypi.org/project/ai2-olmo-core/">PyPI</a> ||
    <a href="https://beaker.org/ws/ai2/OLMo-core/images">Beaker Images</a> ||
    <a href="https://github.com/allenai/OLMo-core/blob/main/LICENSE">License</a> ||
    <a href="https://github.com/allenai/OLMo-core/blob/main/CHANGELOG.md">Changelog</a>
  </p>



  First install [PyTorch](https://pytorch.org) according to the instructions specific to your operating system. Then you can install from PyPI with:

  ```bash
  pip install ai2-olmo-core
  ```



  Official training scripts for various model sizes can be found in [`src/scripts/train/`](https://github.com/allenai/OLMo-core/tree/main/src/scripts/train).
  To see the exact usage for each script, run the script without any arguments.

  Throughput numbers from these scripts with various different configuration settings are reported below, measured on a cluster with NVIDIA H100 GPUs.

  | Model&nbsp;size | Context&nbsp;length | Precision | Throughput[^1] | Training&nbsp;script | Commandline&nbsp;overrides&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; |
  | :--------: | :------------: | :-------: | -----------: | :----------- | :-------- |
  | **1B**  | 4096 | BF16 | 44,000 TPS | `OLMo-1B.py` | |
  | | 256-8192[^2] | BF16 | 49,000 TPS | `OLMo-1B.py` | `--dataset.name=vsl` |
  | | 4096 | FP8 | 51,000 TPS | `OLMo-1B.py` | `--model.float8_config.enabled=true` |
  | **7B**  | 4096 | BF16 | 10,000 TPS | `OLMo-7B.py` | |
  | | | FP8 | 13,000 TPS | `OLMo-7B.py` | `--model.float8_config.enabled=true` |
  | **13B** | 4096 | BF16 | 4,600 TPS | `OLMo-13B.py` | |

  [^1]: Throughput reported in tokens per second per device.
  [^2]: Denotes variable sequence length (VSL) with the Grow-P2 curriculum from [Dataset Decomposition: Faster LLM Training with Variable Sequence Length Curriculum](https://arxiv.org/abs/2405.13226).



  After cloning OLMo-core and setting up a Python virtual environment, install the codebase from source with:

  ```bash
  pip install -e .[all]
  ```

  The Python library source code is located in `src/olmo_core`. The corresponding tests are located in `src/test`. The library docs are located in `docs`. You can build the docs locally with `make docs`.

  Code checks:
  - We use `pytest` to run tests. You can run all tests with `pytest -v src/test`. You can also point `pytest` at a specific test file to run it individually.
  - We use `isort` and `black` for code formatting. Ideally you should integrate these into your editor, but you can also run them manually or configure them with a pre-commit hook. To validate that all files are formatted correctly, run `make style-check`.
  - We use `ruff` as our primary linter. You can run it with `make lint-check`.
  - We use `mypy` as our type checker. You can run it with `make type-check`.



  ```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: a5535e4ed69b66433273bb1683721954c73a5d7d22ce1a406fe1b58d7abf4fdc
name: python-ai2-olmo-core
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: Core training module for the Open Language Model (OLMo)
url: https://github.com/allenai/OLMo-core
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2-olmo-core-1.6.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1>OLMo-core</h1>
    <p>Building blocks for OLMo modeling and training</p>
  </div>
  <p align="center">
    <a href="https://github.com/allenai/OLMo-core/tree/main/src/examples">Examples</a> ||
    <a href="https://olmo-core.readthedocs.io/en/latest/">Docs</a> ||
    <a href="https://pypi.org/project/ai2-olmo-core/">PyPI</a> ||
    <a href="https://beaker.org/ws/ai2/OLMo-core/images">Beaker Images</a> ||
    <a href="https://github.com/allenai/OLMo-core/blob/main/LICENSE">License</a> ||
    <a href="https://github.com/allenai/OLMo-core/blob/main/CHANGELOG.md">Changelog</a>
  </p>



  First install [PyTorch](https://pytorch.org) according to the instructions specific to your operating system and hardware. Then you can install from PyPI with:

  ```bash
  pip install ai2-olmo-core
  ```

  There are a number of optional dependencies that must be installed to use certain functionality as well, including:
  - [flash-attn](https://github.com/Dao-AILab/flash-attention) for flash attention and certain other fused operations.
  - [torchao](https://github.com/pytorch/ao) for float8 training.
  - [megablocks](https://github.com/databricks/megablocks) for mixture-of-experts (MoE) models.



  Even though this library is under rapid development we are trying hard to adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) with every release except for features that are explicitly marked as beta features. Those features will be tagged like this in the [API docs](https://olmo-core.readthedocs.io/en/latest/):

  ![image](https://github.com/user-attachments/assets/c666686d-3ae6-4c88-8381-befd698d3fd0)



  Official training scripts for various model sizes can be found in [`src/scripts/train/`](https://github.com/allenai/OLMo-core/tree/main/src/scripts/train).
  To see the exact usage for each script, run the script without any arguments.

  Throughput numbers from these scripts with various different configuration settings are reported below, measured on a cluster with NVIDIA H100 GPUs.

  | Model&nbsp;size | Model&nbsp;arch | Context&nbsp;length | Precision | Throughput[^1] | Training&nbsp;script | Commandline&nbsp;overrides&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; |
  | :--------: | :--------: | :------------: | :-------: | -----------: | :----------- | :-------- |
  | **1B**  | OLMo-1124 | 4096 | BF16 | 55,000 TPS | `OLMo-1B.py` | |
  | | | 4096 | BF16/FP8[^2] | 65,000 TPS | `OLMo-1B.py` | `--model.float8_config.enabled=true` |
  | **7B**  | OLMo-1124 | 4096 | BF16 | 10,000 TPS | `OLMo-7B.py` | |
  | | | 4096 | BF16/FP8 | 13,000 TPS | `OLMo-7B.py` | `--model.float8_config.enabled=true` |
  | **8B**  | Llama | 4096 | BF16 | 9,500 TPS | `Llama-8B.py` | |
  | | | 4096 | BF16/FP8 | 12,500 TPS | `Llama-8B.py` | `--model.float8_config.enabled=true` |
  | **13B** | OLMo-1124 | 4096 | BF16 | 4,600 TPS | `OLMo-13B.py` | |
  | | | 4096 | BF16/FP8 | 5,500 TPS | `OLMo-13B.py` | `--model.float8_config.enabled=true` |

  [^1]: Throughput reported in tokens per second per device.
  [^2]: In this setup most matrix multiplications are computed in `float8`, everything else is in `bfloat16`.



  After cloning OLMo-core and setting up a Python virtual environment, install the codebase from source with:

  ```bash
  pip install -e .[all]
  ```

  The Python library source code is located in `src/olmo_core`. The corresponding tests are located in `src/test`. The library docs are located in `docs`. You can build the docs locally with `make docs`.

  Code checks:
  - We use `pytest` to run tests. You can run all tests with `pytest -v src/test`. You can also point `pytest` at a specific test file to run it individually.
  - We use `isort` and `black` for code formatting. Ideally you should integrate these into your editor, but you can also run them manually or configure them with a pre-commit hook. To validate that all files are formatted correctly, run `make style-check`.
  - We use `ruff` as our primary linter. You can run it with `make lint-check`.
  - We use `mypy` as our type checker. You can run it with `make type-check`.



  ```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:
[cell repeats an earlier one in this file: 10256 characters]


pkgId: 6b6f72c4b6348e75df2c74eb3b66b945e2ae1891cf1bfbecfccefa748eeeb5d1
name: python-ai2-olmo-core
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Core training module for the Open Language Model (OLMo)
url: https://github.com/allenai/OLMo-core
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2-olmo-core-1.7.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1>OLMo-core</h1>
    <p>Building blocks for OLMo modeling and training</p>
  </div>
  <p align="center">
    <a href="https://github.com/allenai/OLMo-core/tree/main/src/examples">Examples</a> ||
    <a href="https://olmo-core.readthedocs.io/en/latest/">Docs</a> ||
    <a href="https://pypi.org/project/ai2-olmo-core/">PyPI</a> ||
    <a href="https://beaker.org/ws/ai2/OLMo-core/images">Beaker Images</a> ||
    <a href="https://github.com/allenai/OLMo-core/blob/main/LICENSE">License</a> ||
    <a href="https://github.com/allenai/OLMo-core/blob/main/CHANGELOG.md">Changelog</a>
  </p>



  First install [PyTorch](https://pytorch.org) according to the instructions specific to your operating system and hardware. Then you can install from PyPI with:

  ```bash
  pip install ai2-olmo-core
  ```

  There are a number of optional dependencies that must be installed to use certain functionality as well, including:
  - [flash-attn](https://github.com/Dao-AILab/flash-attention) for flash attention and certain other fused operations.
  - [torchao](https://github.com/pytorch/ao) for float8 training.
  - [megablocks](https://github.com/databricks/megablocks) for mixture-of-experts (MoE) models.



  Even though this library is under rapid development we are trying hard to adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) with every release except for features that are explicitly marked as beta features. Those features will be tagged like this in the [API docs](https://olmo-core.readthedocs.io/en/latest/):

  ![image](https://github.com/user-attachments/assets/c666686d-3ae6-4c88-8381-befd698d3fd0)



  Official training scripts for various model sizes can be found in [`src/scripts/train/`](https://github.com/allenai/OLMo-core/tree/main/src/scripts/train).
  To see the exact usage for each script, run the script without any arguments.

  Throughput numbers from these scripts with various different configuration settings are reported below, measured on a cluster with NVIDIA H100 GPUs.

  | Model&nbsp;size | Model&nbsp;arch.&nbsp;&nbsp; | Context&nbsp;length | Precision | Throughput[^1] | Training&nbsp;script | Commandline&nbsp;overrides&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; |
  | :--------: | :--------: | :------------: | :-------: | -----------: | :----------- | :-------- |
  | **1B**  | OLMo-1124 | 4096 | BF16 | 55,000 TPS | `OLMo2-1B.py` | |
  | | | 4096 | BF16/FP8[^2] | 65,000 TPS | `OLMo2-1B.py` | `--model.float8_config.enabled=true` |
  | **7B**  | OLMo-1124 | 4096 | BF16 | 10,000 TPS | `OLMo2-7B.py` | |
  | | | 4096 | BF16/FP8 | 13,000 TPS | `OLMo2-7B.py` | `--model.float8_config.enabled=true` |
  | **8B**  | Llama | 4096 | BF16 | 9,500 TPS | `Llama3-8B.py` | |
  | | | 4096 | BF16/FP8 | 12,500 TPS | `Llama3-8B.py` | `--model.float8_config.enabled=true` |
  | **13B** | OLMo-1124 | 4096 | BF16 | 4,600 TPS | `OLMo2-13B.py` | |
  | | | 4096 | BF16/FP8 | 5,500 TPS | `OLMo2-13B.py` | `--model.float8_config.enabled=true` |

  [^1]: Throughput reported in tokens per second per device.
  [^2]: In this setup most matrix multiplications are computed in `float8`, everything else is in `bfloat16`.



  After cloning OLMo-core and setting up a Python virtual environment, install the codebase from source with:

  ```bash
  pip install -e .[all]
  ```

  The Python library source code is located in `src/olmo_core`. The corresponding tests are located in `src/test`. The library docs are located in `docs`. You can build the docs locally with `make docs`.

  Code checks:
  - We use `pytest` to run tests. You can run all tests with `pytest -v src/test`. You can also point `pytest` at a specific test file to run it individually.
  - We use `isort` and `black` for code formatting. Ideally you should integrate these into your editor, but you can also run them manually or configure them with a pre-commit hook. To validate that all files are formatted correctly, run `make style-check`.
  - We use `ruff` as our primary linter. You can run it with `make lint-check`.
  - We use `mypy` as our type checker. You can run it with `make type-check`.



  ```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:
[cell repeats an earlier one in this file: 10256 characters]


pkgId: 6f2e307d57fe10506ce494496e4afa23fa0fcfe223efeb20469581bb7e92e433
name: python-ai2-tango
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: A library for choreographing your machine learning research.
url: https://pypi.org/project/ai2-tango/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2-tango-1.3.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <br>
  <img src="https://raw.githubusercontent.com/allenai/tango/main/docs/source/_static/tango_final_horizontal.png" width="600"/>
  <br>
  <br>
  <p>
  <!-- start tagline -->
  AI2 Tango replaces messy directories and spreadsheets full of file versions by organizing experiments into discrete steps that can be cached and reused throughout the lifetime of a research project.
  <!-- end tagline -->
  </p>
  <hr/>
  <a href="https://github.com/allenai/tango/actions">
      <img alt="CI" src="https://github.com/allenai/tango/workflows/CI/badge.svg?event=push&branch=main">
  </a>
  <a href="https://pypi.org/project/ai2-tango/">
      <img alt="PyPI" src="https://img.shields.io/pypi/v/ai2-tango">
  </a>
  <a href="https://ai2-tango.readthedocs.io/en/latest/?badge=latest">
      <img src="https://readthedocs.org/projects/ai2-tango/badge/?version=latest" alt="Documentation Status" />
  </a>
  <a href="https://github.com/allenai/tango/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/allenai/tango.svg?color=blue&cachedrop">
  </a>
  <br/>
  </div>



  - [Documentation](https://ai2-tango.readthedocs.io/)
  - [PyPI Package](https://pypi.org/project/ai2-tango/)
  - [Contributing](https://github.com/allenai/tango/blob/main/CONTRIBUTING.md)
  - [License](https://github.com/allenai/tango/blob/main/LICENSE)



  - [Quick start](#quick-start)
  - [Installation](#installation)
    - [Installing with PIP](#installing-with-pip)
    - [Installing with Conda](#installing-with-conda)
    - [Installing from source](#installing-from-source)
    - [Checking your installation](#checking-your-installation)
    - [Docker image](#docker-image)
  - [FAQ](#faq)
  - [Team](#team)
  - [License](#license)



  Create a Tango step:

  ```python


  from tango import step

  @step()
  def hello(name: str) -> str:
      message = f"Hello, {name}!"
      print(message)
      return message
  ```

  And create a corresponding experiment configuration file:

  ```jsonnet
  // hello.jsonnet

  {
    steps: {
      hello: {
        type: "hello",
        name: "World",
      }
    }
  }
  ```

  Then run the experiment using a local workspace to cache the result:

  ```bash
  tango run hello.jsonnet -w /tmp/workspace
  ```

  You'll see something like this in the output:

  ```
  Starting new run expert-llama
  ● Starting step "hello"...
  Hello, World!
  ✓ Finished step "hello"
  ✓ Finished run expert-llama
  ```

  If you run this a second time the output will now look like this:

  ```
  Starting new run open-crab
  ✓ Found output for step "hello" in cache...
  ✓ Finished run open-crab
  ```

  You won't see "Hello, World!" this time because the result of the step was found in the cache, so it wasn't run again.

  For a more detailed introduction check out the [First Steps](https://ai2-tango.readthedocs.io/en/latest/first_steps.html) walk-through.



  <!-- start install -->

  **ai2-tango** requires Python 3.8 or later.



  **ai2-tango** is available [on PyPI](https://pypi.org/project/ai2-tango/). Just run

  ```bash
  pip install ai2-tango
  ```

  To install with a specific integration, such as `torch` for example, run

  ```bash
  pip install 'ai2-tango[torch]'
  ```

  To install with all integrations, run

  ```bash
  pip install 'ai2-tango[all]'
  ```



  **ai2-tango** is available on conda-forge. You can install just the base package with

  ```bash
  conda install tango -c conda-forge
  ```

  You can pick and choose from the integrations with one of these:

  ```bash
  conda install tango-datasets -c conda-forge
  conda install tango-torch -c conda-forge
  conda install tango-wandb -c conda-forge
  ```

  You can also install everything:

  ```bash
  conda install tango-all -c conda-forge
  ```

  Even though **ai2-tango** itself is quite small, installing everything will pull in a lot of dependencies.
  Don't be surprised if this takes a while!



  To install **ai2-tango** from source, first clone [the repository](https://github.com/allenai/tango):

  ```bash
  git clone https://github.com/allenai/tango.git
  cd tango
  ```

  Then run

  ```bash
  pip install -e '.[all]'
  ```

  To install with only a specific integration, such as `torch` for example, run

  ```bash
  pip install -e '.[torch]'
  ```

  Or to install just the base tango library, you can run

  ```bash
  pip install -e .
  ```



  Run

  ```bash
  tango info
  ```

  to check your installation.



  You can build a Docker image suitable for tango projects by using [the official Dockerfile](https://github.com/allenai/tango/blob/main/Dockerfile) as a starting point for your own Dockerfile, or you can simply use one of our [prebuilt images](https://github.com/allenai/tango/pkgs/container/tango) as a base image in your Dockerfile. For example:

  ```Dockerfile



  FROM ghcr.io/allenai/tango:cuda11.3


  COPY requirements.txt .
  RUN /opt/conda/bin/pip install --no-cache-dir -r requirements.txt





  COPY . .
  ```

  Make sure to choose the right base image for your use case depending on the version of tango you're using and the CUDA version that your host machine supports.
  You can see a list of all available image tags [on GitHub](https://github.com/allenai/tango/pkgs/container/tango/versions).

  <!-- end install -->



  <!-- start faq -->



  The motivation behind this library is that we can make research easier by composing it into well-defined steps.  What happens when you choreograph a number of steps together?  Well, you get a dance.  And since our [team's leader](https://nasmith.github.io/) is part of a tango band, "AI2 Tango" was an obvious choice!



  You can run the `tango` command through [pdb](https://docs.python.org/3/library/pdb.html). For example:

  ```bash
  python -m pdb -m tango run config.jsonnet
  ```



  We've found that existing DAG execution engines like these tools are great for production workflows but not as well suited for messy, collaborative research projects
  where code is changing constantly. AI2 Tango was built *specifically* for these kinds of research projects.



  AI2 Tango caches the results of steps based on the `unique_id` of the step. The `unique_id` is essentially a hash of all of the inputs to the step along with:

  1. the step class's fully qualified name, and
  2. the step class's `VERSION` class variable (an arbitrary string).

  Unlike other workflow engines like [redun](https://github.com/insitro/redun), Tango does *not* take into account the source code of the class itself (other than its fully qualified name) because we've found that using a hash of the source code bytes is way too sensitive and less transparent for users.
  When you change the source code of your step in a meaningful way you can just manually change the `VERSION` class variable to indicate to Tango
  that the step has been updated.

  <!-- end faq -->



  <!-- start team -->

  **ai2-tango** is developed and maintained by the AllenNLP team, backed by [the Allen Institute for Artificial Intelligence (AI2)](https://allenai.org/).
  AI2 is a non-profit institute with the mission to contribute to humanity through high-impact AI research and engineering.
  To learn more about who specifically contributed to this codebase, see [our contributors](https://github.com/allenai/tango/graphs/contributors) page.

  <!-- end team -->



  <!-- start license -->

  **ai2-tango** is licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0).
  A full copy of the license can be found [on GitHub](https://github.com/allenai/tango/blob/main/LICENSE).

  <!-- end license -->

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


pkgId: 8025dd3c8a8413ca6f2659af5e022cc63ed5216e25e04aa4286cce8b9b3074d7
name: python-ai21
arch: src
version: 2.15.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ai21/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai21-2.15.2-1.src.rpm
checksum_type: sha256
description:
  - [Examples](#examples-tldr) 🗂️
  - [Migration from v1.3.4 and below](#migration-from-v134-and-below)
  - [AI21 Official Documentation](#Documentation)
  - [Installation](#Installation) 💿
  - [Usage - Chat Completions](#Usage)
  - [Conversational RAG (Beta)](#Conversational-RAG-Beta)
  - [Older Models Support Usage](#Older-Models-Support-Usage)
  - [More Models](#More-Models)
    - [Streaming](#Streaming)
    - [TSMs](#TSMs)
  - [Token Counting](#Token-Counting)
  - [Environment Variables](#Environment-Variables)
  - [Error Handling](#Error-Handling)
  - [Cloud Providers](#Cloud-Providers) ☁️
    - [AWS](#AWS)
      - [Bedrock](#Bedrock)
      - [SageMaker](#SageMaker)
    - [Azure](#Azure)
    - [Vertex](#Vertex)

  If you want to quickly get a glance how to use the AI21 Python SDK and jump straight to business, you can check out the examples. Take a look at our models and see them in action! Several examples and demonstrations have been put together to show our models' functionality and capabilities.

  Feel free to dive in, experiment, and adapt these examples to suit your needs. We believe they'll help you get up and running quickly.

  In `v2.0.0` we introduced a new SDK that is not backwards compatible with the previous version.
  This version allows for non-static instances of the client, defined parameters to each resource, modelized responses and
  more.
  <details>
  <summary>Migration Examples</summary>

  ```python
  from ai21 import AI21Client
  client = AI21Client(api_key='my_api_key')

  client = AI21Client()
  ```
  We No longer support static methods for each resource, instead we have a client instance that has a method for each
  allowing for more flexibility and better control.

  ```diff
  prompt = "some prompt"
  - import ai21
  - response = ai21.Completion.execute(model="j2-light", prompt=prompt, maxTokens=2)
  + from ai21 import AI21Client
  + client = ai21.AI21Client()
  + response = client.completion.create(model="j2-light", prompt=prompt, max_tokens=2)
  ```
  This applies to all resources. You would now need to create a client instance and use it to call the resource method.

  ```diff
  - response = ai21.Tokenization.execute(text=prompt)
  - print(len(response)) # number of tokens
  + from ai21 import AI21Client
  + client = AI21Client()
  + token_count = client.count_tokens(text=prompt)
  ```

  It is no longer possible to access the response object as a dictionary. Instead, you can access the response object as an object with attributes.
  ```diff
  - import ai21
  - response = ai21.Summarize.execute(source="some text", sourceType="TEXT")
  - response["summary"]
  + from ai21 import AI21Client
  + from ai21.models import DocumentType
  + client = AI21Client()
  + response = client.summarize.create(source="some text", source_type=DocumentType.TEXT)
  + response.summary


pkgId: 5ca8050c2c82f56e5911e0d6aec604921ff3c5ee92e263dae1e3c892eeed3e99
name: python-ai21-tokenizer
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ai21-tokenizer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai21-tokenizer-0.12.0-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install ai21-tokenizer
  ```

  ```bash
  poetry add ai21-tokenizer
  ```



  ```python
  from ai21_tokenizer import Tokenizer, PreTrainedTokenizers
  tokenizer = Tokenizer.get_tokenizer(PreTrainedTokenizers.JAMBA_1_5_MINI_TOKENIZER)

  ```
  Another way would be to use our Jamba 1.5 Mini tokenizer directly:
  ```python
  from ai21_tokenizer import Jamba1_5Tokenizer
  model_path = "<Path to your vocabs file>"
  tokenizer = Jamba1_5Tokenizer(model_path=model_path)

  ```

  ```python
  from ai21_tokenizer import Tokenizer, PreTrainedTokenizers
  tokenizer = await Tokenizer.get_async_tokenizer(PreTrainedTokenizers.JAMBA_1_5_MINI_TOKENIZER)

  ```

  ```python
  from ai21_tokenizer import Tokenizer, PreTrainedTokenizers
  tokenizer = Tokenizer.get_tokenizer(PreTrainedTokenizers.JAMBA_1_5_LARGE_TOKENIZER)

  ```
  Another way would be to use our Jamba 1.5 Large tokenizer directly:
  ```python
  from ai21_tokenizer import Jamba1_5Tokenizer
  model_path = "<Path to your vocabs file>"
  tokenizer = Jamba1_5Tokenizer(model_path=model_path)

  ```

  ```python
  from ai21_tokenizer import Tokenizer, PreTrainedTokenizers
  tokenizer = await Tokenizer.get_async_tokenizer(PreTrainedTokenizers.JAMBA_1_5_LARGE_TOKENIZER)

  ```

  ```python
  from ai21_tokenizer import Tokenizer, PreTrainedTokenizers
  tokenizer = Tokenizer.get_tokenizer(PreTrainedTokenizers.JAMBA_INSTRUCT_TOKENIZER)

  ```
  Another way would be to use our Jamba tokenizer directly:
  ```python
  from ai21_tokenizer import JambaInstructTokenizer
  model_path = "<Path to your vocabs file>"
  tokenizer = JambaInstructTokenizer(model_path=model_path)

  ```

  ```python
  from ai21_tokenizer import Tokenizer, PreTrainedTokenizers
  tokenizer = await Tokenizer.get_async_tokenizer(PreTrainedTokenizers.JAMBA_INSTRUCT_TOKENIZER)

  ```
  Another way would be to use our async Jamba tokenizer class method create:
  ```python
  from ai21_tokenizer import AsyncJambaInstructTokenizer
  model_path = "<Path to your vocabs file>"
  tokenizer = AsyncJambaInstructTokenizer.create(model_path=model_path)

  ```

  ```python
  from ai21_tokenizer import Tokenizer
  tokenizer = Tokenizer.get_tokenizer()

  ```
  Another way would be to use our Jurassic model directly:
  ```python
  from ai21_tokenizer import JurassicTokenizer
  model_path = "<Path to your vocabs file. This is usually a binary file that end with .model>"
  config = {} # "dictionary object of your config.json file"
  tokenizer = JurassicTokenizer(model_path=model_path, config=config)
  ```

  ```python
  from ai21_tokenizer import Tokenizer
  tokenizer = await Tokenizer.get_async_tokenizer()

  ```
  Another way would be to use our async Jamba tokenizer class method create:
  ```python
  from ai21_tokenizer import AsyncJurassicTokenizer
  model_path = "<Path to your vocabs file. This is usually a binary file that end with .model>"
  config = {} # "dictionary object of your config.json file"
  tokenizer = AsyncJurassicTokenizer.create(model_path=model_path, config=config)

  ```


  These functions allow you to encode your text to a list of token ids and back to plaintext
  ```python
  text_to_encode = "apple orange banana"
  encoded_text = tokenizer.encode(text_to_encode)
  print(f"Encoded text: {encoded_text}")
  decoded_text = tokenizer.decode(encoded_text)
  print(f"Decoded text: {decoded_text}")
  ```

  ```python

  text_to_encode = "apple orange banana"
  encoded_text = await tokenizer.encode(text_to_encode)
  print(f"Encoded text: {encoded_text}")
  decoded_text = await tokenizer.decode(encoded_text)
  print(f"Decoded text: {decoded_text}")
  ```

  ```python
  tokens = tokenizer.convert_ids_to_tokens(encoded_text)
  print(f"IDs corresponds to Tokens: {tokens}")
  ids = tokenizer.convert_tokens_to_ids(tokens)
  ```

  ```python

  tokens = await tokenizer.convert_ids_to_tokens(encoded_text)
  print(f"IDs corresponds to Tokens: {tokens}")
  ids = tokenizer.convert_tokens_to_ids(tokens)
  ```
  **For more examples, please see our [examples](examples) folder.**


pkgId: f11ca47a2c1c0267732f100dc8cfb432526f622c44f45825acbaf9c9d5254cc3
name: python-ai2thor
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: AI2-THOR: A Near Photo-Realistic Interactable Framework for Embodied AI Agents
url: https://github.com/allenai/ai2thor
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2thor-5.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img width="50%" src="https://raw.githubusercontent.com/allenai/ai2thor/main/doc/static/logo.svg" /></p>
  <h3 align="center"><i>A Near Photo-Realistic Interactable Framework for Embodied AI Agents</i></h3>

  <p align="center">
      <a href="//travis-ci.org/allenai/ai2thor" target="_blank">
          <img src="https://travis-ci.org/allenai/ai2thor.svg?branch=main">
      </a>
      <a href="//github.com/allenai/ai2thor/releases">
          <img alt="GitHub release" src="https://img.shields.io/github/release/allenai/ai2thor.svg">
      </a>
      <a href="//ai2thor.allenai.org/" target="_blank">
          <img alt="Documentation" src="https://img.shields.io/website/https/ai2thor.allenai.org?down_color=red&down_message=offline&up_message=online">
      </a>
      <a href="//github.com/allenai/ai2thor/blob/main/LICENSE">
          <img alt="License" src="https://img.shields.io/github/license/allenai/ai2thor.svg?color=blue">
      </a>
      <a href="//arxiv.org/abs/1712.05474" target="_blank">
          <img src="https://img.shields.io/badge/arXiv-1712.05474-<COLOR>">
      </a>
      <a href="//www.youtube.com/watch?v=KcELPpdN770" target="_blank">
          <img src="https://img.shields.io/badge/video-YouTube-red">
      </a>
      <a href="//pepy.tech/project/ai2thor" target="_blank">
          <img alt="Downloads" src="https://pepy.tech/badge/ai2thor">
      </a>
  </p>



  <table>
      <tr>
          <td width="33%">
              <img src="https://user-images.githubusercontent.com/28768645/115940549-d0134a80-a456-11eb-8737-d89ad75a0f14.jpg" width="100%" />
          </td>
          <td width="33%">
              <img src="https://user-images.githubusercontent.com/28768645/115940534-c689e280-a456-11eb-985a-ca28e63715c7.jpg" width="100%" />
          </td>
          <td width="33%">
              <img src="https://user-images.githubusercontent.com/28768645/115940466-8b87af00-a456-11eb-92e5-25a9f28e7f6b.jpg" width="100%" />
          </td>
      </tr>
      <tr>
          <td align="center" width="33%">
              <code>iTHOR</code>
          </td>
          <td align="center" width="33%">
              <code>ManipulaTHOR</code>
          </td>
          <td align="center" width="33%">
              <code>RoboTHOR</code>
          </td>
      </tr>
      <tr>
          <td width="33%">
              A high-level interaction framework that facilitates research in embodied common sense reasoning.
          </td>
          <td width="33%">
              A mid-level interaction framework that facilitates visual manipulation of objects using a robotic arm.
          </td>
          <td width="33%">
              A framework that facilitates Sim2Real research with a collection of simlated scene counterparts in the physical world.
          </td>
      </tr>
  </table>



  **🏡 Scenes.** 200+ custom built high-quality scenes. The scenes can be explored on our [demo](//ai2thor.allenai.org/demo) page. We are working on rapidly expanding the number of available scenes and domain randomization within each scene.

  **🪑 Objects.** 2600+ custom designed household objects across 100+ object types. Each object is heavily annotated, which allows for near-realistic physics interaction.

  **🤖 Agent Types.** Multi-agent support, a custom built LoCoBot agent, a Kinova 3 inspired robotic manipulation agent, and a drone agent.

  **🦾 Actions.** 200+ actions that facilitate research in a wide range of interaction and navigation based embodied AI tasks.

  **🖼 Images.** First-class support for many image modalities and camera adjustments. Some modalities include ego-centric RGB images, instance segmentation, semantic segmentation, depth frames, normals frames, top-down frames, orthographic projections, and third-person camera frames. User's can also easily change camera properties, such as the size of the images and field of view.

  **🗺 Metadata.** After each step in the environment, there is a large amount of sensory data available about the state of the environment. This information can be used to build highly complex custom reward functions.



  <table>
      <tr>
          <td align="center" width="80">
              Date
          </td>
          <td align="center" colspan="2">
              Announcement
          </td>
      </tr>
      <tr>
          <td align="center">
              5/2021
          </td>
          <td width="50%">
              <video src="https://user-images.githubusercontent.com/28768645/118589971-58cf8e80-b756-11eb-82ea-a94f84f57353.mp4"/>
          </td>
          <td>
              <code>RandomizeMaterials</code> is now supported! It enables a massive amount of realistic looking domain randomization within each scene. Try it out on the <a href="https://ai2thor.allenai.org/demo">demo</a>
          </td>
      </tr>
      <tr>
          <td align="center">
              4/2021
          </td>
          <td colspan="2">
              We are excited to release <a href="https://ai2thor.allenai.org/manipulathor/">ManipulaTHOR</a>, an environment within the AI2-THOR framework that facilitates visual manipulation of objects using a robotic arm. Please see the <a href="https://github.com/allenai/ai2thor/blob/main/doc/static/ReleaseNotes/ReleaseNotes_3.0.md">full 3.0.0 release notes here</a>.
          </td>
      </tr>
      <tr>
          <td align="center">
              4/2021
          </td>
          <td width="50%">
              <video src="https://user-images.githubusercontent.com/28768645/118590040-7a307a80-b756-11eb-9b4c-c43373bea528.mp4"></video>
              <video src="https://user-images.githubusercontent.com/28768645/118589727-d1821b00-b755-11eb-9dff-9eda97fe0998.mp4"></video>
          </td>
          <td>
              <code>RandomizeLighting</code> is now supported! It includes many tunable parameters to allow for vast control over its effects. Try it out on the <a href="https://ai2thor.allenai.org">demo</a>!<br/><br/>
          </td>
      </tr>
      <tr>
          <td align="center">
              2/2021
          </td>
          <td colspan="2">
              We are excited to host the <a href="https://ai2thor.allenai.org/rearrangement/">AI2-THOR Rearrangement Challenge</a>, <a href="https://ai2thor.allenai.org/robothor/cvpr-2021-challenge/">RoboTHOR ObjectNav Challenge</a>, and <a href="https://askforalfred.com/EAI21/">ALFRED Challenge</a>, held in conjunction with the <a href="https://embodied-ai.org/">Embodied AI Workshop</a> at CVPR 2021.
          </td>
      </tr>
      <tr>
          <td align="center">
              2/2021
          </td>
          <td colspan="2">
              AI2-THOR v2.7.0 announces several massive speedups to AI2-THOR! Read more about it <a href="https://medium.com/ai2-blog/speed-up-your-training-with-ai2-thor-2-7-0-12a650b6ab5e">here</a>.
          </td>
      </tr>
      <tr>
          <td align="center">
              6/2020
          </td>
          <td colspan="2">
              We've released <a href="https://github.com/allenai/ai2thor-docker">🐳 AI2-THOR Docker</a> a mini-framework to simplify running AI2-THOR in Docker.
          </td>
      </tr>
      <tr>
          <td align="center">
              4/2020
          </td>
          <td colspan="2">
              Version 2.4.0 update of the framework is here. All sim objects that aren't explicitly part of the environmental structure are now moveable with physics interactions. New object types have been added, and many new actions have been added. Please see the <a href="https://github.com/allenai/ai2thor/blob/main/doc/static/ReleaseNotes/ReleaseNotes_2.4.md">full 2.4.0 release notes here</a>.
          </td>
      </tr>
      <tr>
          <td align="center">
              2/2020
          </td>
          <td colspan="2">
              AI2-THOR now includes two frameworks: <a href="https://ai2thor.allenai.org/ithor/">iTHOR</a> and <a href="https://ai2thor.allenai.org/robothor/">RoboTHOR</a>. iTHOR includes interactive objects and scenes and RoboTHOR consists of simulated scenes and their corresponding real world counterparts.
          </td>
      </tr>
      <tr>
          <td align="center">
              9/2019
          </td>
          <td colspan="2">
              Version 2.1.0 update of the framework has been added. New object types have been added. New Initialization actions have been added. Segmentation image generation has been improved in all scenes.
          </td>
      </tr>
      <tr>
          <td align="center">
              6/2019
          </td>
          <td colspan="2">
              Version 2.0 update of the AI2-THOR framework is now live! We have over quadrupled our action and object states, adding new actions that allow visually distinct state changes such as broken screens on electronics, shattered windows, breakable dishware, liquid fillable containers, cleanable dishware, messy and made beds and more! Along with these new state changes, objects have more physical properties like Temperature, Mass, and Salient Materials that are all reported back in object metadata. To combine all of these new properties and actions, new context sensitive interactions can now automatically change object states. This includes interactions like placing a dirty bowl under running sink water to clean it, placing a mug in a coffee machine to automatically fill it with coffee, putting out a lit candle by placing it in water, or placing an object over an active stove burner or in the fridge to change its temperature. Please see the <a href="https://github.com/allenai/ai2thor/blob/main/doc/static/ReleaseNotes/ReleaseNotes_2.0.md">full 2.0 release notes here</a> to view details on all the changes and new features.
          </td>
      </tr>
  </table>





  [AI2-THOR Colab](https://github.com/allenai/ai2thor-colab) can be used to run AI2-THOR freely in the cloud with Google Colab. Running AI2-THOR in Google Colab makes it extremely easy to explore functionality without having to set AI2-THOR up locally.



  ```bash
  pip install ai2thor
  ```



  ```bash
  conda install -c conda-forge ai2thor
  ```



  [🐳 AI2-THOR Docker](https://github.com/allenai/ai2thor-docker) can be used, which adds the configuration for running a X server to be used by Unity 3D to render scenes.



  Once you've installed AI2-THOR, you can verify that everything is working correctly by running the following minimal example:

  ```python
  from ai2thor.controller import Controller
  controller = Controller(scene="FloorPlan10")
  event = controller.step(action="RotateRight")
  metadata = event.metadata
  print(event, event.metadata.keys())
  ```



  | Component | Requirement |
  | :-- | :-- |
  | OS | Mac OS X 10.9+, Ubuntu 14.04+ |
  | Graphics Card | DX9 (shader model 3.0) or DX11 with feature level 9.3 capabilities. |
  | CPU | SSE2 instruction set support. |
  | Python | Versions 3.5+ |
  | Linux | X server with GLX module enabled |



  **Questions.** If you have any questions on AI2-THOR, please ask them on our [GitHub Discussions Page](https://github.com/allenai/ai2thor/discussions).

  **Issues.** If you encounter any issues while using AI2-THOR, please open an [Issue on GitHub](https://github.com/allenai/ai2thor/issues).



  | Section | Description |
  | :-- | :-- |
  | [Demo](https://ai2thor.allenai.org/demo/) | Interact and play with AI2-THOR live in the browser. |
  | [iTHOR Documentation](https://ai2thor.allenai.org/ithor/documentation/) | Documentation for the iTHOR environment. |
  | [ManipulaTHOR Documentation](https://ai2thor.allenai.org/manipulathor/documentation/) | Documentation for the ManipulaTHOR environment. |
  | [RoboTHOR Documentation](https://ai2thor.allenai.org/robothor/documentation/) | Documentation for the RoboTHOR environment. |
  | [AI2-THOR Colab](https://github.com/allenai/ai2thor-colab) | A way to run AI2-THOR freely on the cloud using Google Colab. |
  | [AllenAct](https://allenact.org/) | An Embodied AI Framework build at AI2 that provides first-class support for AI2-THOR. |
  | [AI2-THOR Unity Development](https://github.com/allenai/ai2thor/tree/main/unity#readme) | A (sparse) collection of notes that may be useful if editing on the AI2-THOR backend. |
  | [AI2-THOR WebGL Development](https://github.com/allenai/ai2thor/blob/main/WEBGL.md) | Documentation on packaging AI2-THOR for the web, which might be useful for annotation based tasks. |



  If you use AI2-THOR or iTHOR scenes, please cite the original AI2-THOR paper:

  ```bibtex
  @article{ai2thor,
    author={Eric Kolve and Roozbeh Mottaghi and Winson Han and
            Eli VanderBilt and Luca Weihs and Alvaro Herrasti and
            Daniel Gordon and Yuke Zhu and Abhinav Gupta and
            Ali Farhadi},
    title={{AI2-THOR: An Interactive 3D Environment for Visual AI}},
    journal={arXiv},
    year={2017}
  }
  ```

  If you use 🏘️ ProcTHOR or procedurally generated scenes, please cite the following paper:

  ```bibtex
  @inproceedings{procthor,
    author={Matt Deitke and Eli VanderBilt and Alvaro Herrasti and
            Luca Weihs and Jordi Salvador and Kiana Ehsani and
            Winson Han and Eric Kolve and Ali Farhadi and
            Aniruddha Kembhavi and Roozbeh Mottaghi},
    title={{ProcTHOR: Large-Scale Embodied AI Using Procedural Generation}},
    booktitle={NeurIPS},
    year={2022},
    note={Outstanding Paper Award}
  }
  ```

  If you use ManipulaTHOR agent, please cite the following paper:

  ```bibtex
  @inproceedings{manipulathor,
    title={{ManipulaTHOR: A Framework for Visual Object Manipulation}},
    author={Kiana Ehsani and Winson Han and Alvaro Herrasti and
            Eli VanderBilt and Luca Weihs and Eric Kolve and
            Aniruddha Kembhavi and Roozbeh Mottaghi},
    booktitle={CVPR},
    year={2021}
  }
  ```

  If you use RoboTHOR scenes, please cite the following paper:

  ```bibtex
  @inproceedings{robothor,
    author={Matt Deitke and Winson Han and Alvaro Herrasti and
            Aniruddha Kembhavi and Eric Kolve and Roozbeh Mottaghi and
            Jordi Salvador and Dustin Schwenk and Eli VanderBilt and
            Matthew Wallingford and Luca Weihs and Mark Yatskar and
            Ali Farhadi},
    title={{RoboTHOR: An Open Simulation-to-Real Embodied AI Platform}},
    booktitle={CVPR},
    year={2020}
  }
  ```



  AI2-THOR is an open-source project built by the [PRIOR team](//prior.allenai.org) at the [Allen Institute for AI](//allenai.org) (AI2).
  AI2 is a non-profit institute with the mission to contribute to humanity through high-impact AI research and engineering.

  <br />

  <a href="//prior.allenai.org">
  <p align="center"><img width="100%" src="https://raw.githubusercontent.com/allenai/ai2thor/main/doc/static/ai2-prior.svg" /></p>
  </a>


pkgId: b721cda135624975a1a94fac8d4604c2bf862df3a9a3cdd53b6668bbdfc5d829
name: python-ai2thor-colab
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Utility functions for using AI2-THOR with Google Colab.
url: https://github.com/allenai/ai2thor-colab
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai2thor-colab-0.1.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img width="80%" src="https://raw.githubusercontent.com/allenai/ai2thor-colab/main/doc/static/cover.svg" /></p>

  <h2 align="center"><em>Run AI2-THOR on the Cloud using Google Colab</em></h2>

  <p align="center">
      <a href="//github.com/allenai/ai2thor/blob/main/LICENSE">
          <img alt="License" src="https://img.shields.io/github/license/allenai/ai2thor.svg?color=blue">
      </a>
      <a href="https://ai2thor.allenai.org/" target="_blank">
          <img src="https://img.shields.io/badge/ai2thor-website-blue">
      </a>
      <a href="https://github.com/allenai/ai2thor" target="_blank">
          <img src="https://img.shields.io/badge/ai2thor-github-green">
      </a>
      <a href="https://colab.research.google.com/github/allenai/ai2thor-colab/blob/main/templates/AI2_THOR_Full_Starter_Template.ipynb" target="_blank">
          <img src="https://img.shields.io/badge/colab-full&nbsp;template-orange">
      </a>
      <a href="https://colab.research.google.com/github/allenai/ai2thor-colab/blob/main/templates/AI2_THOR_Minimal_Starter_Template.ipynb" target="_blank">
          <img src="https://img.shields.io/badge/colab-minimal&nbsp;template-orange">
      </a>
  </p>





  To get started, we recommend saving a copy of the <a href="https://colab.research.google.com/github/allenai/ai2thor-colab/blob/main/templates/AI2_THOR_Full_Starter_Template.ipynb" target="_blank">AI2-THOR Colab Full Starter Template</a> to your drive. It goes over many helper functions that are often useful.

  <a href="https://colab.research.google.com/github/allenai/ai2thor-colab/blob/main/templates/AI2_THOR_Full_Starter_Template.ipynb">
      <img src="https://raw.githubusercontent.com/allenai/ai2thor-colab/main/doc/static/full-starter-template.svg" />
  </a>

  https://user-images.githubusercontent.com/28768645/119420726-06d8bc80-bcb2-11eb-9acf-e9b151121506.mp4



  We also provide a <a href="https://colab.research.google.com/github/allenai/ai2thor-colab/blob/main/templates/AI2_THOR_Minimal_Starter_Template.ipynb" target="_blank">Minimal Starter Template</a> that does not showcase any helper functions. This is often useful as a starting point to minimally reproduce issues, highlight, or test functionality.

  <a href="https://colab.research.google.com/github/allenai/ai2thor-colab/blob/main/templates/AI2_THOR_Minimal_Starter_Template.ipynb">
      <img src="https://raw.githubusercontent.com/allenai/ai2thor-colab/main/doc/static/minimal-starter-template.svg" />
  </a>

  ![image](https://user-images.githubusercontent.com/28768645/119420252-e5c39c00-bcb0-11eb-84d8-98ed862a687b.png)





  Using Python's packaging manager, `ai2thor_colab` can be installed with

  ```python
  pip install ai2thor_colab
  ```



  AI2-THOR requires an X Server to run on a Linux machine. It allows us to open a Unity window where we can render scenes and observe images. Colab runs Linux, but it does not start an X Server by default. Using `ai2thor_colab.start_xserver()`, we can install all required X Server dependencies and start it up:

  ```python
  import ai2thor_colab
  ai2thor_colab.start_xserver()
  ```



  **Questions.** If you have any questions on AI2-THOR, please ask them on [AI2-THOR's GitHub Discussions Page](https://github.com/allenai/ai2thor/discussions).

  **Issues.** If you encounter any issues while using AI2-THOR, please open an [Issue on AI2-THOR's GitHub](https://github.com/allenai/ai2thor/issues). If you encounter an issue with AI2-THOR Colab, please open an [Issue on our GitHub](https://github.com/allenai/ai2thor-colab/issues)



  | Section | Description |
  | :-- | :-- |
  | [AI2-THOR Website](https://ai2thor.allenai.org/) | The AI2-THOR website, which contains extensive documentation on using the API. |
  | [AI2-THOR GitHub](https://github.com/allenai/ai2thor) | Contains the source code and development of AI2-THOR. |
  | [AI2-THOR Demo](https://ai2thor.allenai.org/demo/) | Interact and play with AI2-THOR live in the browser. |



  AI2-THOR and AI2-THOR Colab are open-source projects built by the [PRIOR team](//prior.allenai.org) at the [Allen Institute for AI](//allenai.org) (AI2).
  AI2 is a non-profit institute with the mission to contribute to humanity through high-impact AI research and engineering.

  <br />

  <a href="//prior.allenai.org">
  <p align="center"><img width="100%" src="https://raw.githubusercontent.com/allenai/ai2thor/main/doc/static/ai2-prior.svg" /></p>
  </a>


pkgId: 78b9f6f75b372bc628b469695e1f010b4042c1b264953b6dca940b41c9808356
name: python-ai3-workers
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Utilities and standard configurations for creating Streamlit workers in the AIAIAI ecosystem
url: https://hub.nucleoo.com/aiaiai/ai3-workers
rpm_license: CC-BY-NC-4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai3-workers-0.1.2-1.src.rpm
checksum_type: sha256
description:
  A Python package that provides utilities and standard configurations for creating Streamlit workers in the AIAIAI ecosystem.



  - 🎨 Automatic styling and configuration
  - 🌐 Built-in internationalization (i18n) support
  - 🔑 Consistent component key management
  - 📏 Automatic height adjustment
  - 🔄 Worker rendering status tracking



  Install using Poetry:

  ```bash
  poetry add ai3-workers
  ```

  Or with pip:

  ```bash
  pip install ai3-workers
  ```



  Create a new worker with minimal boilerplate:

  ```python
  from ai3_workers.core.config import create_worker


  st = create_worker()

  def main():
      name = st.text_input("Enter your name")
      if st.button("Submit"):
          st.write(f"Hello, {name}!")

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



  Recommended project structure for a worker:

  ```
  my-worker/
  ├── src/
  │   ├── i18n.json          # Translations file
  │   ├── interface.py       # Main worker file
  │   └── modules/           # Worker-specific modules
  ├── pyproject.toml
  └── poetry.lock
  ```



  Add translations in `src/i18n.json`:

  ```json
  {
    "title": {
      "en": "My Worker",
      "es": "Mi Worker",
      "nl": "Mijn Worker"
    },
    "description": {
      "en": "A simple worker example",
      "es": "Un ejemplo simple de worker",
      "nl": "Een eenvoudig worker voorbeeld"
    }
  }
  ```

  The package will automatically load translations and use them for the worker title and description. You can also customize these directly:

  ```python
  st = create_worker(
      title="Custom Title",
      description="Custom description"
  )
  ```



  The package provides a wrapped version of Streamlit that automatically:

  - Generates consistent component keys
  - Applies standard styling
  - Sets default values for common properties

  Supported components include:

  - Button components (primary style by default)
  - Input components
  - Form components
  - Data display components
  - Media components



  1. Clone the repository:

  ```bash
  git clone git@hub.nucleoo.com:aiaiai/ai3-workers.git
  ```

  2. Install dependencies:

  ```bash
  poetry install
  ```



  From your worker directory:

  ```bash
  poetry run streamlit run src/interface.py
  ```


pkgId: e11f6e355e5ec44c56b94ca38a67b2a437c6886ed91059215897add26b70aa04
name: python-ai4-metadata
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: AI4OS Hub applications metadata utilities
url: https://github.com/ai4os/ai4-metadata
rpm_license: Apache-2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai4-metadata-2.2.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/github/license/ai4os/ai4-metadata.svg)](https://github.com/ai4os/ai4-metadata/blob/master/LICENSE)
  [![GitHub release](https://img.shields.io/github/release/ai4os/ai4-metadata.svg)](https://github.com/ai4os/ai4-metadata/releases)
  [![PyPI](https://img.shields.io/pypi/v/ai4-metadata.svg)](https://pypi.python.org/pypi/ai4-metadata)
  [![Python versions](https://img.shields.io/pypi/pyversions/ai4-metadata.svg)](https://pypi.python.org/pypi/ai4-metadata)

  [![DOI](https://zenodo.org/badge/721337407.svg)](https://zenodo.org/doi/10.5281/zenodo.13343453)

  Metadata utilities for the AI4OS hub data science applications.

  The AI4OS hub data science applications use metadata to describe the data
  sources, models, and other resources. The metadata is used to validate the
  resources and to provide information to the users.



  The metadata utilities can be installed using pip:

      $ pip install ai4-metadata



  The AI4 metadata utilities can be invoked from the command line. The utilities
  provide commands to validate and migrate the metadata files.

      $ ai4-metadata --help



  The metadata utilities provide a command-line interface (CLI) tool
  `ai4-metadata-validate` that can be used to validate the metadata files. The
  CLI tool accepts the metadata files as input parameters.

      $ ai4-metadata validate instances/sample-v2.mods.json
      ╭─ Success ──────────────────────────────────────────────────────────────────╮
      │ 'instances/sample-v2.mods.json' is valid for version 2.0.0                 │
      ╰────────────────────────────────────────────────────────────────────────────╯

  Different metadata versions can be specified, either by using the
  `--metadata-version` or by providing the metadata schema file. The following
  two executions are equivalent:

      $ ai4-metadata validate --metadata-version 2.0.0 instances/sample-v2.mods.json
      ╭─ Success ──────────────────────────────────────────────────────────────────╮
      │ 'instances/sample-v2.mods.json' is valid for version 2.0.0                 │
      ╰────────────────────────────────────────────────────────────────────────────╯
      $ ai4-metadata validate --schema schemata/ai4-apps-v2.0.0.json instances/sample-v2.mods.json
      ╭─ Success ──────────────────────────────────────────────────────────────────╮
      │ 'instances/sample-v2.mods.json' is valid for version 2.0.0                 │
      ╰────────────────────────────────────────────────────────────────────────────╯
      $ ai4-metadata validate --metadata-version 1.0.0 instances/sample-v2.mods.json
      ╭─ Error ────────────────────────────────────────────────────────────────────╮
      │ Error validating instance 'instances/sample-v2.mods.json': 'date_creation' │
      │ is a required property                                                     │
      ╰────────────────────────────────────────────────────────────────────────────╯

  Metadata files can be present in either JSON or YAML format. The metadata
  utilities will automatically detect the format.

      $ ai4-metadata validate instances/sample-v2.mods.yaml
      ╭─ Success ──────────────────────────────────────────────────────────────────╮
      │ 'instances/sample-v2.mods.yaml' is valid for version 2.0.0                 │
      ╰────────────────────────────────────────────────────────────────────────────╯
      $ ai4-metadata validate instances/sample-v2.mods.json
      ╭─ Success ──────────────────────────────────────────────────────────────────╮
      │ 'instances/sample-v2.mods.json' is valid for version 2.0.0                 │
      ╰────────────────────────────────────────────────────────────────────────────╯



  The metadata utilities provide a command-line interface (CLI) tool
  `ai4-metadata-migrate` that can be used to migrate the metadata files from V1
  to latest V2. To save the output, use the `--output` option.

      $ ai4-metadata migrate --output sample-v2.mods.json instances/sample-v1.mods.json
      ╭─ Success ──────────────────────────────────────────────────────────────────╮
      │ V1 metadata 'instances/sample-v1.mods.json' migrated to version            │
      │ MetadataVersions.V2 and stored in 'sample-v2.mods.json'                    │
      ╰────────────────────────────────────────────────────────────────────────────╯

  Please review the changes, as the metadata migration is not complete, and
  manual steps are needed.



  <img width=300 align="left" src="https://raw.githubusercontent.com/AI4EOSC/.github/ai4eosc/profile/EN-Funded.jpg" alt="Funded by the European Union" />

  This project has received funding from the European Union’s Horizon Research and Innovation programme under Grant agreement No. [101058593](https://cordis.europa.eu/project/id/101058593)


pkgId: ecd16f1b31791811d52661b4e9af5d0b8cf6384de0c55da973e34fd583e81aed
name: python-ai4bharat-transliteration
arch: src
version: 1.1.3
epoch: 0
release: 1
url: https://github.com/AI4Bharat/IndicXlit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai4bharat-transliteration-1.1.3-1.src.rpm
checksum_type: sha256
summary:
  Indic-Xlit: Transliteration library for Indic Languages. Conversion of text from English to 21 languages of South Asia.

description:
  Running a flask server using a 3-line script:
  ```py
  from ai4bharat.transliteration import xlit_server
  app, engine = xlit_server.get_app()
  app.run(host='0.0.0.0', port=8000)
  ```
  Then on browser (or) curl, use link as `http://{IP-address}:{port}/tl/{lang-id}/{word_in_eng_script}`
  Example:
  http://localhost:8000/tl/ta/amma


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


pkgId: 8bc5eb7d91eb0cab945b9458254cc5c807a8763e48faeed8ea473dfca829fc24
name: python-ai71
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: The official Python library for the AI71 API
url: https://pypi.org/project/ai71/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ai71-0.0.21-1.src.rpm
checksum_type: sha256
description:
  Developers building Python 3.8+ apps can now interact seamlessly with the AI71 API thanks to the ai71 Python library. It includes built-in type checking for both requests and responses, and provides both synchronous and asynchronous HTTP clients powered by httpx.



  The API documentation can be found [here](https://api.ai71.ai/redoc).


  ```
  pip install ai71
  ```


  Define `AI71_API_KEY` environment variable or provide `api_key` in `AI71` and `AsyncAI71`.

  ```
  import os
  from ai71 import AI71

  client = AI71()

  chat_completion = client.chat.completions.create(
      messages=[{"role": "user", "content": "What is your name?"}],
      model="tiiuae/falcon-180B-chat",
  )
  ```


  ```
  import asyncio

  from ai71 import AsyncAI71

  client = AsyncAI71()


  async def main():
      stream = await client.chat.completions.create(
          messages=[{"role": "user", "content": "What is your name?"}],
          model="tiiuae/falcon-180B-chat",
          stream=True,
      )
      async for chunk in stream:
          print(chunk.choices[0].delta.content or "", end="")


  asyncio.run(main())
  ```


pkgId: a004a38d6501525046873f249066a49d401eaad5e2112490c6f7bc5590953b30
name: python-aiXplain
arch: src
version: 0.2.20
epoch: 0
release: 1
summary: aiXplain SDK adds AI functions to software.
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
location_href: Packages/python-aiXplain-0.2.20-1.src.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: 0fc569df2ecd225c9e8db19b446dc6bbd0d1ffaafe337b18bd8624211e0f6c60
name: python-aiZero
arch: src
version: 0.0.4a2
epoch: 0
release: 1
url: https://pypi.org/project/aiZero/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiZero-0.0.4a2-1.src.rpm
checksum_type: sha256
summary:
  A simple and easy-to-use library that connects to common artificial intelligence interfaces, allowing for quick development of local web applications. It includes mainstream AI capabilities such as LLM text interaction, image understanding, audio understanding, image generation, speech recognition, and speech synthesis.

description:
  aiZero是一个简单易用的可以连接常用人工智能接口，快速搭建可视化本地web应用的Python第三方库，适配幻码人工智能初阶课程。

  0.0.4版本起，支持使用chatapi.hlestudy.com接口提供的API，您仅需要将下述例程的set_apikey方法改为set_apikey_new即可。此外，新接口不支持声音理解功能的流式输出，语音合成功能的使用方式也稍有差异。



  ```python
  from aiZero import AIWebApp


  def my_ai_function():
      pass

  app = AIWebApp(title='人工智能助手')    # 初始化web应用
  app.set_apikey('YOUR_API_KEY')    # 设定AI接口的api key
  app.add_input_text()    # 在页面中添加一个输入文本框
  app.add_submit(my_ai_function)    # 添加一个提交按钮，点击后执行函数
  app.run(port=6060)    # 启动应用，设定端口，默认为5000
  ```

  启动后，你将可以在浏览器中访问http://127.0.0.1:6060/ 查看搭建好的web应用。

  如果需要实现AI功能的可视化呈现，你只需要将`'YOUR_API_KEY'`替换为真实的api key，并完善`my_ai_function`函数即可。







  ```python
  from aiZero import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text    # 获取输入文本框的文字内容
      reply = text_generation([text])    # 调用AI接口，获取回复反馈
      app.results.append({'text': reply})    # 以文字形式将结果推送至前端

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  ```python
  from aiZero import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      chat_history.append(text)    # 将输入内容添加到对话历史
      reply = text_generation(chat_history)
      chat_history.append(reply)    # 将回复结果添加到对话历史
      app.results.append({'text': reply})

  chat_history = []    # 储存对话历史
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  ```python
  from aiZero import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      chat_history.append(text)
      
      reply = text_generation(chat_history, prompt='你是一个10岁的小学生，名叫小幻')
      chat_history.append(reply)
      app.results.append({'text': reply})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```





  ```python
  from aiZero import AIWebApp, image_understanding

  def my_ai_function():
      text = app.input_text
      img = app.input_pic    # 获取上传的图片
      reply = image_understanding(img, [text])
      app.results.append({'text': reply})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_pic_file()    # 添加一个图片文件上传按钮
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  ```python
  from aiZero import AIWebApp, image_understanding

  def my_ai_function():
      text = app.input_text
      img = app.input_pic    # 获取捕获的图片
      reply = image_understanding(img, [text])
      app.results.append({'text': reply})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_camera()    # 添加摄像头捕获窗口和按钮
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```





  ```python
  from aiZero import AIWebApp, audio_understanding

  def my_ai_function():
      text = app.input_text
      audio = app.input_audio    # 获取上传的音频
      reply = audio_understanding(audio, [text])
      app.results.append({'text': reply})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_audio_file()    # 添加一个音频文件上传按钮
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  ```python
  from aiZero import AIWebApp, audio_understanding

  def my_ai_function():
      text = app.input_text
      audio = app.input_audio    # 获取录制的音频
      reply = audio_understanding(audio, [text])
      app.results.append({'text': reply})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_record()    # 添加音频录制功能区
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  ```python
  from aiZero import AIWebApp, image_generation

  def my_ai_function():
      text = app.input_text
      reply = image_generation(text)
      app.results.append({'image': reply})    # 将生成的图像推送到前端

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  ```python
  from aiZero import AIWebApp, human_repaint

  def my_ai_function():
      img = app.input_pic
      reply = human_repaint(img)
      app.results.append({'image': reply})

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_camera()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```

  以上例程为使用摄像头采集图像，也可以改为上传图片文件。

  `human_repaint`函数可以接受`style`参数设定风格类型，可选值为0～9的数字（默认值为7）。



  ```python
  from aiZero import AIWebApp, sketch_to_image

  def my_ai_function():
      text = app.input_text    # 涂鸦作画的提示文字
      img = app.input_pic    # 涂鸦草图图像
      reply = sketch_to_image(img, text)
      app.results.append({'image': reply})

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_pic_file()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```

  以上例程为上传图片文件，也可以改为用摄像头捕获图像。

  `sktech_to_image`函数可以接受`style`参数设定风格类型，包括：

  - `"<3d cartoon>"`：3D 卡通
  - `"<anime>"`：二次元（默认值）
  - `"<oil painting>"`：油画
  - `"<watercolor>"` ：水彩
  - `"<flat illustration>"`：扁平插画



  ```python
  from aiZero import AIWebApp, speech_recognition

  def my_ai_function():
      audio = app.input_audio
      reply = speech_recognition(audio)
      app.results.append({'text': reply})

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_record()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```

  所用接口支持中英文双语的语音识别。以上例程为实时录音，也可以改为上传录音音频文件。



  ```python
  from aiZero import AIWebApp, speech_synthesis

  def my_ai_function():
      text = app.input_text
      reply = speech_synthesis(text)
      app.results.append({'audio': reply})    # 将音频结果推送到前端

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```

  `speech_synthesis`函数可以接受以下参数：

  - `model`：设定使用的语音模型，详细列表参见[链接](https://help.aliyun.com/zh/dashscope/model-list)。hlestudy提供的apikey不支持此参数。
  - `rate`：设定语速快慢，取值范围0.5~2，默认值为1。hlestudy提供的apikey暂不支持此参数。
  - `pitch`：设定语调高低，取值范围0.5~2，默认值为1。hlestudy提供的apikey暂不支持此参数。
  - `voice`：设定使用的音色，详细列表参见[链接](https://help.aliyun.com/zh/dashscope/developer-reference/timbre-list)。仅hlestudy提供的apikey支持此参数。





  aiZero支持方便地将不同的AI功能进行链式整合，例如，将文字交互、语音识别、语音合成结合起来，可以实现语音交互。

  ```python
  from aiZero import AIWebApp, text_generation, speech_recognition, speech_synthesis

  def my_ai_function():
      audio = app.input_audio
      text = speech_recognition(audio)
      chat_history.append(text)
      reply = text_generation(chat_history)
      chat_history.append(reply)
      reply_audio = speech_synthesis(reply)
      app.results.append({'audio': reply_audio})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_record()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  aiZero支持同时输出文字、音频和图像等多种不同类型的信息，但每种类型的信息只能为一个。例如，我们可以输入文字，同时以文本和音频形式输出AI的响应。

  ```python
  from aiZero import AIWebApp, text_generation, speech_synthesis

  def my_ai_function():
      text = app.input_text
      chat_history.append(text)
      reply = text_generation(chat_history)
      chat_history.append(reply)
      reply_audio = speech_synthesis(reply)
      app.results.append({'text': reply, 'audio': reply_audio})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  `aiZero`也支持在一次大模型交互的输出时，分不同时间输出不同信息。例如，我们制作一个绘图助手，它可以将用户输入的简易文字信息扩充为详细的画面信息后，再交给图像生成功能完成图像的创作。在这个功能设计中，AI的文字回复响应很快而图像生成响应较慢，因此应当在不同时间推送至前端。

  ```python
  from aiZero import AIWebApp, text_generation, image_generation

  def my_ai_function():
      text = app.input_text
      chat_history.append(text)
      reply = text_generation(chat_history, prompt='你是一个人工智能绘图助手，你负责将用户输入信息中描述的画面扩充为详细的绘图AI的提示词')
      chat_history.append(reply)
      
      app.results.append({'text': reply, 'running': True})
      img = image_generation(reply)
      
      app.results.append({'image': img})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```

  为了能让前端在收到第一次的文本输出后不会结束对其他输出的监听，必须在输出未完全结束时，在结果中添加`'running'`键，而在输出完全结束时，推送不包含`'running'`键的结果。



  在大模型文字交互（`text_generation`）、图像理解（`image_understanding`）、声音理解（`audio_understanding`，hlestudy提供的apikey不支持）等功能中，大模型回复的文本信息支持以流式形式输出，即逐步输出文本内容而非一次性输出全部文本。设置方法只需要将函数的可选参数`stream`设为`True`即可，以基础的文字交互为例：

  ```python
  from aiZero import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      chat_history.append(text)
      
      reply = text_generation(chat_history, stream=True)
      for r in reply:
          
          app.results.append({'text': r, 'running': True})
      chat_history.append(r)
      
      app.results.append({'text': r})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```



  在`aiZero`中，所有错误信息都会以`'错误:'`作为开始部分输出，因此，可以在获取输出信息时，先判断是否为错误信息，再进行相应的推送。

  ```python
  from aiZero import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      chat_history.append(text)
      reply = text_generation(chat_history)
      if reply.startswith('错误:'):
          app.results.append({'text': reply})
          chat_history.pop()
      else:
          chat_history.append(reply)
          app.results.append({'text': reply})

  chat_history = []
  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run(port=6060)
  ```


pkgId: 70d695b3c446f93ba3bcc75b426a2ae321f59ba22a538f8faed1ad75f1f833dd
name: python-aiZero-gr
arch: src
version: 0.0.1a3
epoch: 0
release: 1
url: https://pypi.org/project/aiZero-gr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiZero-gr-0.0.1a3-1.src.rpm
checksum_type: sha256
summary:
  A simple and easy-to-use library that connects to common artificial intelligence interfaces (powered by Gradio), allowing for quick development of local web applications. It includes mainstream AI capabilities such as LLM text interaction, image understanding, audio understanding, image generation, speech recognition, and speech synthesis.

description:
  aiZero-gr是一个简单易用的可以连接常用人工智能接口，快速搭建可视化本地web应用的Python第三方库，在[aiZero](https://pypi.org/project/aiZero)库的基础上，调整为基于gradio框架的界面展示。

  当前版本仅支持阿里云灵积模型服务的api key和有限的功能调用，且暂不支持流式输出。本文档只包含基础功能的示例，进阶使用技巧可以参照aiZero库的文档内容。



  ```python
  from aiZero_gr import AIWebApp


  def my_ai_function():
      pass

  app = AIWebApp(title='人工智能助手')    # 初始化web应用
  app.set_apikey('YOUR_API_KEY')    # 设定AI接口的api key
  app.add_input_text()    # 在页面中添加一个输入文本框
  app.add_submit(my_ai_function)    # 设定提交按钮点击后执行的函数功能
  app.run()    # 启动应用
  ```

  启动后，程序将自动输出本地网址，你将可以在浏览器中访问并查看搭建好的web应用。

  如果需要实现AI功能的可视化呈现，你只需要将`'YOUR_API_KEY'`替换为真实的api key，并完善`my_ai_function`函数。







  ```python
  from aiZero_gr import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text    # 获取输入文本框的文字内容
      reply = text_generation(text)    # 调用AI接口，获取回复反馈
      app.results['text'] = reply    # 以文字形式将结果推送至前端

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      history = app.chat_history    # 获取对话历史记录
      reply = text_generation(text, history)    # 将历史记录同时提交
      app.results['text'] = reply

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      history = app.chat_history
      
      reply = text_generation(text, history, prompt='你是一个10岁的小学生，名叫小幻')
      app.results['text'] = reply

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, image_understanding

  def my_ai_function():
      text = app.input_text
      img = app.input_pic    # 获取输入的图像
      history = app.chat_history
      reply = image_understanding(img, text, history)
      app.results['text'] = reply

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_input_pic()    # 添加图像输入组件
  app.add_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, audio_understanding

  def my_ai_function():
      text = app.input_text
      audio = app.input_audio    # 获取输入的音频
      history = app.chat_history
      reply = audio_understanding(audio, text, history)
      app.results['text'] = reply

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_input_audio()    # 添加音频输入组件
  app.add_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, image_generation

  def my_ai_function():
      text = app.input_text
      reply = image_generation(text)
      app.results['image'] = reply    # 将生成的图像推送到前端

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, human_repaint

  def my_ai_function():
      img = app.input_pic
      reply = human_repaint(img)
      app.results['image'] = reply

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_pic()
  app.add_submit(my_ai_function)
  app.run()
  ```

  `human_repaint`函数可以接受`style`参数设定风格类型，可选值为0～9的数字（默认值为7）。



  ```python
  from aiZero_gr import AIWebApp, sketch_to_image

  def my_ai_function():
      text = app.input_text    # 涂鸦作画的提示文字
      img = app.input_pic    # 涂鸦草图图像
      reply = sketch_to_image(img, text)
      app.results['image'] = reply

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_input_pic()
  app.add_submit(my_ai_function)
  app.run()
  ```

  `sktech_to_image`函数可以接受`style`参数设定风格类型，包括：

  - `"<3d cartoon>"`：3D 卡通
  - `"<anime>"`：二次元（默认值）
  - `"<oil painting>"`：油画
  - `"<watercolor>"` ：水彩
  - `"<flat illustration>"`：扁平插画



  ```python
  from aiZero_gr import AIWebApp, speech_recognition

  def my_ai_function():
      audio = app.input_audio
      reply = speech_recognition(audio)
      app.results['text'] = reply

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_audio()
  app.add_submit(my_ai_function)
  app.run()
  ```

  所用接口支持中英文双语的语音识别。



  ```python
  from aiZero_gr import AIWebApp, speech_synthesis

  def my_ai_function():
      text = app.input_text
      reply = speech_synthesis(text)
      app.results['audio'] = reply    # 将音频结果推送到前端

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_submit(my_ai_function)
  app.run()
  ```

  `speech_synthesis`函数可以接受以下参数：

  - `rate`：设定语速快慢，取值范围0.5~2，默认值为1。
  - `pitch`：设定语调高低，取值范围0.5~2，默认值为1。
  - `voice`：设定使用的音色，详细列表参见[链接](https://help.aliyun.com/zh/dashscope/developer-reference/timbre-list)。


pkgId: 7c001ab1ca26eaa6668c659dd711c979f252eda92fe283e127406a141bc4d948
name: python-aiZero-gr
arch: src
version: 0.0.3a1
epoch: 0
release: 1
url: https://pypi.org/project/aiZero-gr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiZero-gr-0.0.3a1-1.src.rpm
checksum_type: sha256
summary:
  A simple and easy-to-use library that connects to common artificial intelligence interfaces (powered by Gradio), allowing for quick development of local web applications. It includes mainstream AI capabilities such as LLM text interaction, image understanding, audio understanding, image generation, speech recognition, and speech synthesis.

description:
  aiZero-gr是一个简单易用的可以连接常用人工智能接口，快速搭建可视化本地web应用的Python第三方库，在[aiZero](https://pypi.org/project/aiZero)库的基础上，调整为基于gradio框架的界面展示。

  当前版本仅支持阿里云百炼大模型服务的api key和有限的功能调用。



  ```python
  from aiZero_gr import AIWebApp


  def my_ai_function():
      pass

  app = AIWebApp(title='人工智能助手')    # 初始化web应用
  app.set_apikey('YOUR_API_KEY')    # 设定AI接口的api key
  app.add_input_text()    # 在页面中添加一个输入文本框
  app.set_submit(my_ai_function)    # 设定提交按钮点击后执行的函数功能
  app.run()    # 启动应用
  ```

  启动后，程序将自动输出本地网址，你将可以在浏览器中访问并查看搭建好的web应用。

  如果需要实现AI功能的可视化呈现，你只需要将`'YOUR_API_KEY'`替换为真实的api key，并完善`my_ai_function`函数。







  ```python
  from aiZero_gr import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text    # 获取输入文本框的文字内容
      reply = text_generation(text)    # 调用AI接口，获取回复反馈
      app.send(reply)    # 将结果推送至前端

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.set_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      history = app.chat_history    # 获取对话历史记录
      reply = text_generation(text, history)    # 将历史记录同时提交
      app.send(reply)

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.set_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      history = app.chat_history
      
      reply = text_generation(text, history, prompt='你是一个10岁的小学生，名叫小幻')
      app.send(reply)

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.set_submit(my_ai_function)
  app.run()
  ```



  ```Python
  from aiZero_gr import AIWebApp, text_generation

  def my_ai_function():
      text = app.input_text
      history = app.chat_history
      
      reply = text_generation(text, history, stream=True)
      
      for r in reply:
  	    app.results.send(reply)

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.set_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, image_understanding

  def my_ai_function():
      text = app.input_text
      img = app.input_pic    # 获取输入的图像
      history = app.chat_history
      reply = image_understanding(img, text, history)
      app.send(reply)

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_input_pic()    # 添加图像输入组件
  app.set_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, audio_understanding

  def my_ai_function():
      text = app.input_text
      audio = app.input_audio    # 获取输入的音频
      history = app.chat_history
      reply = audio_understanding(audio, text, history)
      app.send(reply)

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_input_audio()    # 添加音频输入组件
  app.set_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, image_generation

  def my_ai_function():
      text = app.input_text
      reply = image_generation(text)
      app.send(reply, 'image')    # 推送图像时，需要明确类型为image

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.set_submit(my_ai_function)
  app.run()
  ```



  ```python
  from aiZero_gr import AIWebApp, human_repaint

  def my_ai_function():
      img = app.input_pic
      reply = human_repaint(img)
      app.send(reply, 'image')

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_pic()
  app.set_submit(my_ai_function)
  app.run()
  ```

  `human_repaint`函数可以接受`style`参数设定风格类型，可选值为0～9的数字（默认值为7）。



  ```python
  from aiZero_gr import AIWebApp, sketch_to_image

  def my_ai_function():
      text = app.input_text    # 涂鸦作画的提示文字
      img = app.input_pic    # 涂鸦草图图像
      reply = sketch_to_image(img, text)
      app.send(reply, 'image')

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_input_pic()
  app.set_submit(my_ai_function)
  app.run()
  ```

  `sktech_to_image`函数可以接受`style`参数设定风格类型，包括：

  - `"<3d cartoon>"`：3D 卡通
  - `"<anime>"`：二次元（默认值）
  - `"<oil painting>"`：油画
  - `"<watercolor>"` ：水彩
  - `"<flat illustration>"`：扁平插画



  ```python
  from aiZero_gr import AIWebApp, speech_recognition

  def my_ai_function():
      audio = app.input_audio
      reply = speech_recognition(audio)
      app.send(reply)

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_audio()
  app.set_submit(my_ai_function)
  app.run()
  ```

  所用接口支持中英文双语的语音识别。



  ```python
  from aiZero_gr import AIWebApp, speech_synthesis

  def my_ai_function():
      text = app.input_text
      reply = speech_synthesis(text)
      app.send(reply, 'audio')    # 将音频结果推送到前端

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.set_submit(my_ai_function)
  app.run()
  ```

  `speech_synthesis`函数可以接受以下参数：

  - `rate`：设定语速快慢，取值范围0.5~2，默认值为1。
  - `pitch`：设定语调高低，取值范围0.5~2，默认值为1。
  - `voice`：设定使用的音色，详细列表参见[链接](https://help.aliyun.com/zh/dashscope/developer-reference/timbre-list)。



  ```python
  from aiZero_gr import AIWebApp, voice_clone, speech_synthesis

  def my_ai_function():
      text = app.input_text
      audio = app.input_audio
      if audio:
          voice_id = voice_clone(audio)
          app.voice_id = voice_id    # 记录本轮生成的音色名
          app.send(voice_id)
      
      reply = speech_synthesis(text, model='cosyvoice-clone-v1', voice=app.voice_id)
      app.send(reply, 'audio')

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.add_input_audio()
  app.set_submit(my_ai_function)
  app.run()
  ```

  `voice_clone`函数返回根据语音音频获取的音色名，该音色可再经`speech_synthesis`函数合成语音，但使用时必须指定`model`参数值为`'cosyvoice-clone-v1'`。





  aiZero-gr支持方便地将不同的AI功能进行链式整合，例如，将文字交互、语音识别、语音合成结合起来，可以实现语音交互。

  运用时，注意系统默认的chat_history为**前端可见的对话历史记录**，如果需要将前端不可见的数据作为传递给AI的对话历史，则需要**手动维护对话历史记录**。

  ```python
  from aiZero_gr import AIWebApp, text_generation, speech_recognition, speech_synthesis

  def my_ai_function():
      audio = app.input_audio
      text = speech_recognition(audio)
      reply = text_generation(text, history)
      
      history.add_user_content(text)
      history.add_ai_content(reply)
      reply_audio = speech_synthesis(reply)
      app.send(reply_audio, 'audio')

  app = AIWebApp(title='人工智能助手')
  history = app.create_history()    # 手动创建对话历史
  app.set_apikey('YOUR_API_KEY')
  app.add_input_audio()
  app.set_submit(my_ai_function)
  app.run()
  ```



  aiZero-gr支持同时输出文字、音频和图像等多种不同类型的信息，但每种类型的信息只能为一个。例如，我们可以输入文字，同时以文本和音频形式输出AI的响应。

  ```python
  from aiZero_gr import AIWebApp, text_generation, speech_synthesis

  def my_ai_function():
      text = app.input_text
      history = app.chat_history
      reply = text_generation(text, history)
      reply_audio = speech_synthesis(reply)
      app.send(reply)
      app.send(reply_audio, 'audio')

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.set_submit(my_ai_function)
  app.run()
  ```



  aiZero-gr也支持在一次大模型交互的输出时，分不同时间输出不同信息。例如，我们制作一个绘图助手，它可以将用户输入的简易文字信息扩充为详细的画面信息后，再交给图像生成功能完成图像的创作。在这个功能设计中，AI的文字回复响应很快而图像生成响应较慢，因此应当在不同时间推送至前端。

  ```python
  from aiZero_gr import AIWebApp, text_generation, image_generation

  def my_ai_function():
      text = app.input_text
      reply = text_generation(text, prompt='你是一个人工智能绘图助手，你负责将用户输入信息中描述的画面扩充为详细的绘图AI的提示词')
      app.send(reply)
      img = image_generation(reply)
      app.send(img, 'image')

  app = AIWebApp(title='人工智能助手')
  app.set_apikey('YOUR_API_KEY')
  app.add_input_text()
  app.set_submit(my_ai_function)
  app.run()
  ```


pkgId: c920c7b76d54a61188df1efc29a5cec723032a84e8944bdd1b5e87b4ab08ec5e
name: python-aia
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: AIA chasing through OpenSSL for TLS certificate chain building and verifying
url: https://github.com/danilobellini/aia
rpm_license: 2-clause BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aia-0.2.0-1.src.rpm
checksum_type: sha256
description:
  This library was built as a workaround to the CPython
  [issue 18617](https://bugs.python.org/issue18617)
  (AIA chasing for missing intermediate certificates on TLS connections)
  regarding SSL/TLS.

  **Why a session?**
  That's not really a session in the HTTP sense,
  it's just a way to cache the downloaded certificates in memory,
  so one doesn't need to validate the same certificate more than once.

  **How does it get the certificate chain?**
  It gets the whole chain
  from the AIA (Authority Information Access) extension
  of each certificate,
  and gets the root certificate locally, from the system.

  **How does it validate the certificate chain?**
  Through OpenSSL, which must be installed as an external dependency.

  **When should I use it?**
  Ideally, never, but that might not be an option.
  When the web server configuration
  doesn't include the entire chain (apart from the root certificate),
  there are only two "options":
  ignore the certificate (not secure)
  or get the intermediary certificates in the chain through AIA
  (that's why this small library was written).




  Anywhere, assuming OpenSSL is already installed:

  ```bash
  pip install aia
  ```

  For system installation in Arch Linux, there's also the
  [python-aia](https://aur.archlinux.org/packages/python-aia/)
  package in AUR.




  For simple requests on HTTPS, there's a straightforward way based
  on the standard library `urllib.request.urlopen`.

  ```python
  from aia import AIASession
  aia_session = AIASession()


  content = aia_session.download("https://...")


  response = aia_session.urlopen("https://...")


  from urllib.request import urlopen
  url = "https://..."
  context = aia_session.ssl_context_from_url(url)
  response = urlopen(url, context=context)
  ```

  The context methods also helps when working with HTTP client libraries.
  For example, with [`requests`](http://python-requests.org/):

  ```python
  from tempfile import NamedTemporaryFile
  from aia import AIASession
  import requests

  aia_session = AIASession()
  url = "https://..."
  cadata = aia_session.cadata_from_url(url)  # Validated PEM certificate chain
  with NamedTemporaryFile("w") as pem_file:
      pem_file.write(cadata)
      pem_file.flush()
      resp = requests.get(url, verify=pem_file.name)
  ```

  With [`httpx`](https://www.python-httpx.org/) in synchronous code
  it's really straightforward, since it accepts the `SSLContext` instance:

  ```python
  from aia import AIASession
  import httpx

  aia_session = AIASession()
  url = "https://..."
  context = aia_session.ssl_context_from_url(url)
  resp = httpx.get(url, verify=context)
  ```

  The certificate fetching part of this library and the OpenSSL call
  are blocking, so this library is still not prepared
  for asynchronous code.
  But one can easily make some workaround to use it, for example with
  [`tornado.httpclient`](https://www.tornadoweb.org/en/stable/httpclient.html)
  or with the already seen `httpx`, using `asyncio`:

  ```python
  import asyncio
  from functools import partial
  from aia import AIASession

  async def get_context(aia_session, url, executor=None):
      return await asyncio.get_event_loop().run_in_executor(
          executor,
          partial(aia_session.ssl_context_from_url, url),
      )



  from tornado.httpclient import AsyncHTTPClient

  async def download_tornado_async(url):
      aia_session = AIASession()
      context = await get_context(aia_session, url)
      client = AsyncHTTPClient()
      try:
          resp = await client.fetch(url, ssl_options=context)
          return resp.body
      finally:
          client.close()

  result = asyncio.run(download_tornado_async("https://..."))



  import httpx

  async def download_httpx_async(url):
      aia_session = AIASession()
      context = await get_context(aia_session, url)
      async with httpx.AsyncClient(verify=context) as client:
          resp = await client.get(url)
          return resp.content

  result = asyncio.run(download_httpx_async("https://..."))
  ```


pkgId: 3b370aa80969b19dc0979ae48a93004860b0d832f7e33d5a0a9a94cf344bd933
name: python-aiagenthub
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A general-purpose multi-agent orchestration framework.
url: https://pypi.org/project/aiagenthub/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiagenthub-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A general-purpose multi-agent orchestration framework for building agentic software.



  Requires Python 3.10+

  ```shell
  pip install agenthub
  ```

  or

  ```shell
  pip install agenthub
  ```



  ```python
  from agenthub import Team, Agent

  team = Team()

  writer_agent = Agent(
      name="Sophisticated writer",
      instructions="You write about honey bees.",
  )

  response = team.run(
      agent=writer_agent,
      messages=[{"role": "user", "content": "Create a motivational haiku."}],
  )

  print(response.messages[-1]["content"])
  ```

  ```
  Fields of golden light,
  Bees dance through blossoms with grace—
  Sweet rewards await.
  ```



  This project includes code from [OpenAI Swarm](https://github.com/openai/swarm).

  - Ilan Bigio - [ibigio](https://github.com/ibigio)
  - James Hills - [jhills20](https://github.com/jhills20)
  - Shyamal Anadkat - [shyamal-anadkat](https://github.com/shyamal-anadkat)
  - Charu Jaiswal - [charuj](https://github.com/charuj)
  - Colin Jarvis - [colin-openai](https://github.com/colin-openai)
  - Katia Gil Guzman - [katia-openai](https://github.com/katia-openai)


pkgId: e78b204a4895066f3bfa9e9fd0cc2de6079b8fc94c0115ae6169391ea9b7042c
name: python-aiagents4pharma
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: AI Agents for drug discovery, drug development, and other pharmaceutical R&D
url: https://pypi.org/project/aiagents4pharma/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiagents4pharma-1.0.0-1.src.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`

  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. **Launch the agent:**
     To launch the Talk2BioModels agent, run:
     ```bash
     streamlit run app/frontend/streamlit_app.py
     ```


pkgId: 96aff12788bc472c8d4201162c28e0618dd95e0d57d636db87651f185cfdead1
name: python-aiask
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: AIAsk is an intelligent AI assistant that leverages AI to enhance your daily life.
url: https://pypi.org/project/aiask/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiask-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Aiask is a simple AI chatbot that uses the Langchain to generate responses to user input.

  screen:


  ![](./screen.png)


pkgId: 1694ac5ace1c30c3793d305ec55d6b23369565adf0a9db1dc3688857357ecfe9
name: python-aiask
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: AIAsk is an intelligent AI assistant that leverages AI to enhance your daily life.
url: https://pypi.org/project/aiask/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiask-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Aiask is a simple AI chatbot that uses the Langchain to generate responses to user input.

  screen:


  ![](./screen.png)




  ```bash
  pip install aiask
  ```


pkgId: e13c06c017b1e2aed55c40e3bae9c6da1f2ff6b0cfde98e8f56af38792273cfd
name: python-aiautocommit
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: AI generated commit messages
url: https://pypi.org/project/aiautocommit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiautocommit-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![Release Notes](https://img.shields.io/github/release/iloveitaly/aiautocommit)](https://github.com/iloveitaly/aiautocommit/releases) [![Downloads](https://static.pepy.tech/badge/aiautocommit/month)](https://pepy.tech/project/aiautocommit) [![Python Versions](https://img.shields.io/pypi/pyversions/aiautocommit)](https://pypi.org/project/aiautocommit) ![GitHub CI Status](https://github.com/iloveitaly/aiautocommit/actions/workflows/build_and_publish.yml/badge.svg) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  Generate intelligent commit messages using AI. aiautocommit analyzes your staged changes and creates conventional commit messages, handling both small tweaks and large changesets effectively.

  Yes, there are a lot of these. Main ways this is different:

  * Simple codebase
  * Ability to easily customize prompts on a per-repo basis



  ```shell
  pip install aiautocommit
  ```



  * Generates conventional commit messages
  * Customizable prompts and exclusions
  * Pre-commit hook integration
  * Supports custom config directories



  Set your OpenAI API key:

  ```
  export OPENAI_API_KEY=<YOUR API KEY>
  ```

  Stage your changes and run aiautocommit:

  ```
  git add .

  aiautocommit commit


  aiautocommit commit --print-message
  ```





  First, you'll want to enable logging so you can extract the diff and prompt and iterate on it in ChatGPT:

  ```shell
  export AIAUTOCOMMIT_LOG_LEVEL=DEBUG
  export AIAUTOCOMMIT_LOG_FILE=aiautocommit.log
  ```

  Now, you'll have a nice log you can tail and fiddle with from there.



  aiautocommit looks for configuration files in these locations (in priority order):

  * .aiautocommit/ in current directory
  * $XDG_CONFIG_HOME/aiautocommit/ (defaults to ~/.config/aiautocommit/)
  * Custom path via aiautocommit_CONFIG environment variable

  To get started with customization:

  ```shell
  aiautocommit dump-prompts
  ```

  This creates a `.aiautocommit/` directory with:

  * `diff_prompt.txt`: Template for generating diff summaries
  * `commit_prompt.txt`: Template for generating commit messages
  * `exclusions.txt`: List of files to exclude from processing



  To automatically generate commit messages during git commits:

  ```
  aiautocommit install-pre-commit
  ```



  * `OPENAI_API_KEY`: Your OpenAI API key
  * `aiautocommit_MODEL`: AI model to use (default: gpt-4-mini)
  * `aiautocommit_CONFIG`: Custom config directory path
  * `LOG_LEVEL`: Logging verbosity
  * `aiautocommit_LOG_PATH`: Custom log file path



  `gpt-commit` uses the [OpenAI API](https://platform.openai.com/docs) to generate commit messages. Both file names and contents from files that contain staged changes will be shared with OpenAI when using `gpt-commit`. OpenAI will process this data according to their [terms of use](https://openai.com/policies/terms-of-use) and [API data usage policies](https://openai.com/policies/api-data-usage-policies). On March 1st 2023 OpenAI pledged that by default, they would not use data submitted by customers via their API to train or improve their models, and that this data will be retained for a maximum of 30 days, after which it will be deleted.



  [This project](https://github.com/markuswt/gpt-commit) inspired this project. It had a very simple codebase. I've taken the idea and expanded it to include a lot more features, specifically per-project prompt customization.



  I looked at a bunch of projects before building this one.

  - https://github.com/abi/aiautocommit - python, inactive. Many files, not simple.
  - https://github.com/Sett17/turboCommit - rust, inactive.
  - https://github.com/Nutlope/aicommits - typescript. Node is so slow and I hate working with it.
  - https://github.com/Elhameed/aicommits - python
  - https://github.com/zurawiki/gptcommit - active, rust. Too complicated and no prompt customization.
  - https://github.com/ywkim/gpt-commit - lisp, inactive.
  - https://github.com/markuswt/gpt-commit - single file, python based. No commits > 1yr. Very simple codebase.
  - https://github.com/josenerydev/gpt-commit - also python
  - https://github.com/di-sukharev/opencommit - has conventional commit structure


pkgId: 403674addf97bcff6d367bd7d84fe189ad0f83c32d9c09293c5f13dffc91c4d0
name: python-aiautocommit
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: AI generated commit messages
url: https://pypi.org/project/aiautocommit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiautocommit-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Release Notes](https://img.shields.io/github/release/iloveitaly/aiautocommit)](https://github.com/iloveitaly/aiautocommit/releases) [![Downloads](https://static.pepy.tech/badge/aiautocommit/month)](https://pepy.tech/project/aiautocommit) [![Python Versions](https://img.shields.io/pypi/pyversions/aiautocommit)](https://pypi.org/project/aiautocommit) ![GitHub CI Status](https://github.com/iloveitaly/aiautocommit/actions/workflows/build_and_publish.yml/badge.svg) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  Generate intelligent commit messages using AI. aiautocommit analyzes your staged changes and creates conventional commit messages, handling both small tweaks and large changesets effectively.

  Yes, there are a lot of these. Main ways this is different:

  * Simple codebase
  * Ability to easily customize prompts on a per-repo basis



  ```shell
  pip install aiautocommit
  ```



  * Generates conventional commit messages
  * Customizable prompts and exclusions
  * Pre-commit hook integration
  * Supports custom config directories



  Set your OpenAI API key:

  ```
  export OPENAI_API_KEY=<YOUR API KEY>
  ```

  Stage your changes and run aiautocommit:

  ```
  git add .

  aiautocommit commit


  aiautocommit commit --print-message
  ```





  First, you'll want to enable logging so you can extract the diff and prompt and iterate on it in ChatGPT:

  ```shell
  export AIAUTOCOMMIT_LOG_LEVEL=DEBUG
  export AIAUTOCOMMIT_LOG_FILE=aiautocommit.log
  ```

  Now, you'll have a nice log you can tail and fiddle with from there.



  aiautocommit looks for configuration files in these locations (in priority order):

  * .aiautocommit/ in current directory
  * $XDG_CONFIG_HOME/aiautocommit/ (defaults to ~/.config/aiautocommit/)
  * Custom path via aiautocommit_CONFIG environment variable

  To get started with customization:

  ```shell
  aiautocommit dump-prompts
  ```

  This creates a `.aiautocommit/` directory with:

  * `diff_prompt.txt`: Template for generating diff summaries
  * `commit_prompt.txt`: Template for generating commit messages
  * `exclusions.txt`: List of files to exclude from processing
  * `commit_suffix.txt`: Static suffix to append to commit messages. Useful for trailers.



  To automatically generate commit messages during git commits:

  ```
  aiautocommit install-pre-commit
  ```

  [Learn more about git hooks here.](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks)




  Lefthook is an excellent tool for managing git hooks. To use aiautocommit with lefthook, add the following to your `.lefthook.yml`:

  ```yaml
  prepare-commit-msg:
    commands:
      aiautocommit:
        run: aiautocommit commit --output-file "{1}"
        interactive: true
        env:
          
          LEFTHOOK: 0
          
          LOG_LEVEL: info
          OPENAI_LOG: warn
        skip:
          merge:
          rebase:
          
          run: ! which aiautocommit > /dev/null
  ```



  * `OPENAI_API_KEY`: Your OpenAI API key
  * `AIAUTOCOMMIT_OPENAI_API_KEY`: Unique API key for OpenAI, overrides `OPENAI_API_KEY` (useful for tracking or costing purposes)
  * `AIAUTOCOMMIT_MODEL`: AI model to use (default: gpt-4-mini)
  * `AIAUTOCOMMIT_CONFIG`: Custom config directory path
  * `LOG_LEVEL`: Logging verbosity
  * `AIAUTOCOMMIT_LOG_PATH`: Custom log file path



  `gpt-commit` uses the [OpenAI API](https://platform.openai.com/docs) to generate commit messages. Both file names and contents from files that contain staged changes will be shared with OpenAI when using `gpt-commit`. OpenAI will process this data according to their [terms of use](https://openai.com/policies/terms-of-use) and [API data usage policies](https://openai.com/policies/api-data-usage-policies). On March 1st 2023 OpenAI pledged that by default, they would not use data submitted by customers via their API to train or improve their models, and that this data will be retained for a maximum of 30 days, after which it will be deleted.



  [This project](https://github.com/markuswt/gpt-commit) inspired this project. It had a very simple codebase. I've taken the idea and expanded it to include a lot more features, specifically per-project prompt customization.



  I looked at a bunch of projects before building this one.

  - https://github.com/abi/aiautocommit - python, inactive. Many files, not simple.
  - https://github.com/Sett17/turboCommit - rust, inactive.
  - https://github.com/Nutlope/aicommits - typescript. Node is so slow and I hate working with it.
  - https://github.com/Elhameed/aicommits - python
  - https://github.com/zurawiki/gptcommit - active, rust. Too complicated and no prompt customization.
  - https://github.com/ywkim/gpt-commit - lisp, inactive.
  - https://github.com/markuswt/gpt-commit - single file, python based. No commits > 1yr. Very simple codebase.
  - https://github.com/josenerydev/gpt-commit - also python
  - https://github.com/di-sukharev/opencommit - has conventional commit structure


pkgId: bd9ac882892f335c9a23241b31e511cfb95bc5cf274e0e025442d536a8ebeecb
name: python-aiautocommit
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: AI generated commit messages
url: https://pypi.org/project/aiautocommit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiautocommit-0.9.0-1.src.rpm
checksum_type: sha256
description:
  [![Release Notes](https://img.shields.io/github/release/iloveitaly/aiautocommit)](https://github.com/iloveitaly/aiautocommit/releases) [![Downloads](https://static.pepy.tech/badge/aiautocommit/month)](https://pepy.tech/project/aiautocommit) [![Python Versions](https://img.shields.io/pypi/pyversions/aiautocommit)](https://pypi.org/project/aiautocommit) ![GitHub CI Status](https://github.com/iloveitaly/aiautocommit/actions/workflows/build_and_publish.yml/badge.svg) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  Generate intelligent commit messages using AI. aiautocommit analyzes your staged changes and creates conventional commit messages, handling both small tweaks and large changesets effectively.

  Yes, there are a lot of these. Main ways this is different:

  * Simple codebase. [< 400 LOC](aiautocommit/__init__.py) and most of it is prompts and comments.
  * Ability to easily customize prompts on a per-repo basis



  ```shell
  pip install aiautocommit
  ```



  * Generates conventional commit messages
  * Customizable prompts and exclusions
  * Pre-commit hook integration
  * Supports custom config directories
  * Does not generate a commit during a merge or reversion (when an existing autogen'd msg exists)



  Set your OpenAI API key:

  ```
  export OPENAI_API_KEY=<YOUR API KEY>
  ```

  Stage your changes and run aiautocommit:

  ```
  git add .


  aiautocommit commit


  aiautocommit commit --print-message
  ```

  Using the CLI directly is the best way to debug and tinker with the project as well.





  First, you'll want to enable logging so you can extract the diff and prompt and iterate on it in ChatGPT:

  ```shell
  export AIAUTOCOMMIT_LOG_LEVEL=DEBUG
  export AIAUTOCOMMIT_LOG_FILE=aiautocommit.log
  ```

  Now, you'll have a nice log you can tail and fiddle with from there.



  aiautocommit looks for configuration files in these locations (in priority order):

  * .aiautocommit/ in current directory
  * $XDG_CONFIG_HOME/aiautocommit/ (defaults to ~/.config/aiautocommit/)
  * Custom path via aiautocommit_CONFIG environment variable

  To get started with customization:

  ```shell
  aiautocommit dump-prompts
  ```

  This creates a `.aiautocommit/` directory with:

  * `diff_prompt.txt`: Template for generating diff summaries
  * `commit_prompt.txt`: Template for generating commit messages
  * `exclusions.txt`: List of files to exclude from processing
  * `commit_suffix.txt`: Static suffix to append to commit messages. Useful for trailers.



  To automatically generate commit messages during git commits:

  ```
  aiautocommit install-pre-commit
  ```

  [Learn more about git hooks here.](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks)




  Lefthook is an excellent tool for managing git hooks. To use aiautocommit with lefthook, add the following to your `.lefthook.yml`:

  ```yaml
  prepare-commit-msg:
    commands:
      aiautocommit:
        run: aiautocommit commit --output-file "{1}"
        interactive: true
        env:
          
          LEFTHOOK: 0
          
          LOG_LEVEL: info
          OPENAI_LOG: warn
        skip:
          merge:
          rebase:
          
          run: ! which aiautocommit > /dev/null
  ```



  * `OPENAI_API_KEY`: Your OpenAI API key
  * `AIAUTOCOMMIT_OPENAI_API_KEY`: Unique API key for OpenAI, overrides `OPENAI_API_KEY` (useful for tracking or costing purposes)
  * `AIAUTOCOMMIT_MODEL`: AI model to use (default: gpt-4-mini)
  * `AIAUTOCOMMIT_CONFIG`: Custom config directory path
  * `LOG_LEVEL`: Logging verbosity
  * `AIAUTOCOMMIT_LOG_PATH`: Custom log file path



  * https://cbea.ms/git-commit/



  `gpt-commit` uses the [OpenAI API](https://platform.openai.com/docs) to generate commit messages. Both file names and contents from files that contain staged changes will be shared with OpenAI when using `gpt-commit`. OpenAI will process this data according to their [terms of use](https://openai.com/policies/terms-of-use) and [API data usage policies](https://openai.com/policies/api-data-usage-policies). On March 1st 2023 OpenAI pledged that by default, they would not use data submitted by customers via their API to train or improve their models, and that this data will be retained for a maximum of 30 days, after which it will be deleted.



  [This project](https://github.com/markuswt/gpt-commit) inspired this project. It had a very simple codebase. I've taken the idea and expanded it to include a lot more features, specifically per-project prompt customization.



  I looked at a bunch of projects before building this one.

  - https://github.com/abi/aiautocommit - python, inactive. Many files, not simple.
  - https://github.com/Sett17/turboCommit - rust, inactive.
  - https://github.com/Nutlope/aicommits - typescript. Node is so slow and I hate working with it.
  - https://github.com/Elhameed/aicommits - python
  - https://github.com/zurawiki/gptcommit - active, rust. Too complicated and no prompt customization.
  - https://github.com/ywkim/gpt-commit - lisp, inactive.
  - https://github.com/markuswt/gpt-commit - single file, python based. No commits > 1yr. Very simple codebase.
  - https://github.com/josenerydev/gpt-commit - also python
  - https://github.com/di-sukharev/opencommit - has conventional commit structure


pkgId: 1d7f9366882d67d809ca31ef653f14380bd930ab1c9cdda651d9759075bbc3c7
name: python-aib2ofx
arch: src
version: 0.73.4
epoch: 0
release: 1
summary: Download data from aib.ie in OFX format
url: https://github.com/yacoob/aib2ofx
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aib2ofx-0.73.4-1.src.rpm
checksum_type: sha256
description:
  ...or how to grab transaction data out of AIB's online interface, and format it
  into `OFX` file.

  **NOTE:** Last AIB login update (Feb' 2021) made me realise how brittle the
  overall machinery here is. The code that works around Web Storage API use is
  ugly and likely to break. The most likely road forward for this project is to
  decouple it into [ofxstatement](https://github.com/kedder/ofxstatement) plugin
  and (maybe) Selenium-powered CSV acquisition script. The former will be easy,
  the latter will most likely be a nightmare to maintain and install, unless you
  enjoy having your banking details pipe through an arbitrary docker image.

  Time will tell.



      python3 -mvenv aib2ofx
      source aib2ofx/bin/activate
      pip3 install aib2ofx

  This will create a virtualenv for `aib2ofx`, fetch its code then install it with
  all dependencies. Once that completes, you'll find `aib2ofx` executable in the
  `bin` directory of this new virtualenv.



  Create a `~/.aib2ofx.json` file, with AIB login details.
  Set the permission bits to 0600 to prevent other system users from reading it.

      touch ~/.aib2ofx.json
      chmod 0600 ~/.aib2ofx.json

  It has a JSON format, single object with one key per AIB login you want to use.

      {
          "bradmajors": {
              "regNumber": "12345678",
              "pin": "12345"
          }
      }

  The fields are as follows:

  * regNumber
      > Your AIB registered number.

  * pin
      > Your five digit PIN.

  You can put more than one set of credentials in the file; the script
  will download data for all accounts for all logins.

      {
          "bradmajors": {
              "regNumber": "12345678",
              "pin": "12345"
          },
          "janetweiss": {
              "regNumber": "87654321",
              "pin": "54321"
          }
      }

  Note that there's no comma after the last account details.

  Once you've prepared that config file, run:

      aib2ofx -d /output/directory

  The script should connect to AIB, log in using provided credentials,
  iterate through all accounts, and save each of those to a separate
  file located in `/output/directory`.



  There is none.

  I've written that script with my best intentions, it's not malicious,
  it's not sending the data anywhere, it's not doing anything nasty. I'm
  using it day to day to get data about my AIB accounts into a financial
  program that I use. It should work for you as good as it works for
  me. See the `LICENSE` file for more details.



  aib2ofx works only with python 3.

  In order to set up a dev environment clone the repository, get
  [poetry](https://python-poetry.org/docs/#installation)
  and run `poetry install`. This will create a virtualenv with all
  dependencies installed. You can activate it with `poetry shell`.


pkgId: 3ef85b5369c251db71b5a79203dc35a9d69813c0d8c683bbf2c6b7909504e9d7
name: python-aibasics
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: AI Uncovered: A Comprehensive Guide to AI Basics and Applications
url: https://aibasics.halla.ai
rpm_license: CC-BY-4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibasics-0.10.1-1.src.rpm
checksum_type: sha256
description:
  [![pypi-image]][pypi-url]
  [![version-image]][release-url]
  [![release-date-image]][release-url]
  [![jupyter-book-image]][docs-url]

  <!-- Links: -->
  [codecov-image]: https://codecov.io/gh/chu-aie/aibasics/branch/main/graph/badge.svg?token=dzfp4tGZ87
  [codecov-url]: https://codecov.io/gh/chu-aie/aibasics
  [pypi-image]: https://img.shields.io/pypi/v/aibasics
  [license-image]: https://img.shields.io/github/license/chu-aie/aibasics
  [license-url]: https://github.com/chu-aie/aibasics/blob/main/LICENSE
  [version-image]: https://img.shields.io/github/v/release/chu-aie/aibasics?sort=semver
  [release-date-image]: https://img.shields.io/github/release-date/chu-aie/aibasics
  [release-url]: https://github.com/chu-aie/aibasics/releases
  [jupyter-book-image]: https://jupyterbook.org/en/stable/_images/badge.svg

  [repo-url]: https://github.com/chu-aie/aibasics
  [pypi-url]: https://pypi.org/project/aibasics
  [docs-url]: https://aibasics.halla.ai
  [changelog]: https://github.com/chu-aie/aibasics/blob/main/CHANGELOG.md
  [contributing guidelines]: https://github.com/chu-aie/aibasics/blob/main/CONTRIBUTING.md
  <!-- Links: -->

  AI Uncovered: A Comprehensive Guide to AI Basics and Applications

  - Documentation: [https://aibasics.halla.ai][docs-url]
  - GitHub: [https://github.com/chu-aie/aibasics][repo-url]
  - PyPI: [https://pypi.org/project/aibasics][pypi-url]

  AI Uncovered is a 15-week, beginner-friendly course in Korean, designed to provide a comprehensive introduction to artificial intelligence (AI) and its real-world applications. Students will explore various AI concepts and techniques, such as machine learning, deep learning, natural language processing, and object detection. The course includes hands-on lab sessions using Google Colab, allowing students to practice what they've learned. By the end, students will have a solid understanding of AI fundamentals and be prepared for an AI-driven future.



  See the [CHANGELOG] for more information.



  Contributions are welcome! Please see the [contributing guidelines] for more information.



  This project is released under the [CC-BY-4.0 License][license-url].


pkgId: bcc0ec2c6925c09f7581fe9bb07e9c03eb5705a8a35bba2c484b5bdade8fae41
name: python-aibeehive
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A lightweight, stateless llm orchestration framework.
url: https://pypi.org/project/aibeehive/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibeehive-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A general-purpose framework for orchestrating LLM workflows (forked from OpenAI's Swarm).



  Requires Python 3.10+

  ```shell
  pip install aibeehive
  ```

  or

  ```shell
  pip install aibeehive
  ```



  ```python
  from aibeehive import Swarm, Bee

  swarm = Swarm()

  def ask_queen_bee():
      return queen_bee

  worker_bee = Bee(
      name="Worker Bee",
      instructions="You are a helpful worker bee.",
      functions=[transfer_to_queen_bee],
  )

  queen_bee = Bee(
      name="Queen Bee",
      instructions="Guide your worker bees to be helpful.",
  )

  response = swarm.run(
      bee=worker_bee,
      messages=[{"role": "user", "content": "Create a motivational haiku to inspire the worker bees."}],
  )

  print(response.messages[-1]["content"])
  ```

  ```
  Hope glimmers brightly,
  New paths converge gracefully,
  What can I assist?
  ```



  - [Overview](#overview)
  - [Examples](#examples)
  - [Documentation](#documentation)
    - [Running Swarm](#running-swarm)
    - [Bees](#bees)
    - [Functions](#functions)
    - [Streaming](#streaming)
  - [Evaluations](#evaluations)
  - [Utils](#utils)



  - Ilan Bigio - [ibigio](https://github.com/ibigio)
  - James Hills - [jhills20](https://github.com/jhills20)
  - Shyamal Anadkat - [shyamal-anadkat](https://github.com/shyamal-anadkat)
  - Charu Jaiswal - [charuj](https://github.com/charuj)
  - Colin Jarvis - [colin-openai](https://github.com/colin-openai)
  - Katia Gil Guzman - [katia-openai](https://github.com/katia-openai)



  This project includes code from [OpenAI Swarm](https://github.com/openai/swarm).


pkgId: 364d751274ea33aabe157e15bf71e01c53dab6ce4e4f6a93dc2075651d1b6dd5
name: python-aibridge-test
arch: src
version: 0.4.9
epoch: 0
release: 1
summary: Bridge for LLM"s
url: https://github.com/me/myproject
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibridge-test-0.4.9-1.src.rpm
checksum_type: sha256
description:
  AIBridge is the python package with the support of the Multiple LLM's,User can utilised the Formatters ,prompts, varibales to get most of the LLM's Through the AIBridge



  - Python 3



  ```python
  pip install aibridge-test
  ```



  - Setting the the aibridge_config.yaml at your desire choice
  - In .env file set the path for file.

  ```python
  Example in bash we set:
  export AIBRIDGE_CONFIG=C:/Users/Admin/aibridge/aibridge_config.yaml
  variable name for env:AIBRIDGE_CONFIG
  ```

  ```python
  starter file.
  &id001
  data: *id001
  group_name: my_consumer_group
  message_queue: redis
  no_of_threads: 1
  open_ai:
    - key: API KEY HERE
      priority: equal
  palm_api:
    - key: API KEY HERE
      priority: equal
  stable_diffusion:
    - key: API KEY HERE
      priority: equal
  redis_host: localhost
  redis_port: Loacal Host
  stream_name: my_stream
  database: nosql
  database_name: aibridge
  database_uri: mongodb://localhost:27017
  per_page: 10

  ```



  - With the help of the AIBridge we can svae the prompts in your sql/nosql data bases by default the :sqllite on the disc space
  - To configure the database you have add the data in config file.

  ```python
  from AIBridge impprt Setconfig

  Setconfig.set_db_confonfig(database=sql,database_name=None,database_uri=None)



  ```

  - If you want use the sqllite on the disc no need to configure these for db support
  - Currently AI bridge support only the OPEN_AI api:

  ```python
  from AIBridge import SetConfig
  SetConfig.set_api_key(ai_service="open_ai",key="YOUR_API_KEY",priority="high")

  ```



  - Prompt save mechanism is used the save the reusable and extraordinary prompts that give you the exceptional result from LLM

  ```python
  from AIBridge import PromptInsertion


  data = PromptInsertion.save_prompt(
      prompt="your prompt:{{data}},context:{{context}}",
      name="first_prompt",
      prompt_data={"data": "what is purpose of the ozone here"},
      variables={"context": "environment_context"},
  )
  print(data)





  data = PromptInsertion.update_prompt(
      id="prompt_id",
      name="updated_prompt",
      prompt_data={"data": "write abouts the plastic pollution"},
      variables={"context": "ocean_pollution"},
  )
  print(data)



  data = PromptInsertion.get_prompt(id="prompt_id")
  print(data)


  data = PromptInsertion.get_all_prompt(page=1)
  print(data)
  ```



  - why variables?-> variables are the specific data used the get the desired and with context from ai LLM's.
  - These is the example of the self consistance prompts Ref:https://www.promptingguide.ai/techniques/consistency
  - Varibales methods:

  ```python
  from AIBridge import VariableInsertion




  data = VariableInsertion.save_variables(
      var_key="ochean_context",
      var_value=[
          "Ocean pollution is a significant environmental issue that poses a threat to marine life and ecosystems"
      ],
  )
  print(data)


  data = VariableInsertion.update_variables(
      id="variable_id",
      var_key="updated_string",
      var_value=["updated senetece about topics"],
  )
  print(data)


  data = VariableInsertion.get_variable(id="variable_id")


  data = VariableInsertion.get_all_variable(page=1)

  ```



  - LLm=open_ai
  - default_model="gpt-3.4-turbo-oo3"
  - Max_toke count - 3500
  - temprature set to 0.5
    methods

  ```python
  from AIBridge import OpenAIService
  import json

  json_schema = json.dumps({"animal": ["list of animals"]})
  xml_schema = "<animals><category>animal name</category></animals>"
  csv = "name,category,species,age,weight,color,habitat"
  data = OpenAIService.generate(
      prompts=["name of the animals in the  {{jungle}}"],
      prompt_ids=None,
      prompt_data=[{"jungle": "jungle"}],
      variables=None,
      output_format=["json"],
      format_strcture=[json_schema],
      model="gpt-3.5-turbo",
      variation_count=1,
      max_tokens=3500,
      temperature=0.5,
      message_queue=False,
  )
  print(data)













  output = {
      "items": {
          "response": [
              {
                  "data": [
                      '{"animal": ["lion", "tiger", "elephant", "monkey", "snake", "gorilla", "leopard", "crocodile", "jaguar", "giraffe"]}'
                  ]
              }
          ],
          "token_used": 85,
          "created_at": 1689323114.9568439,
          "ai_service": "open_ai",
      }
  }

  ```



  - default Queue=redis,



  ```python
  from AIBridge import SetConfig

  SetConfig.redis_config(
      redis_host="localhost",
      redis_port="port _for redis",
      group_name="consumer gorup name",
      stream_name="redis topic",
      no_of_threads=1,#concurrent thread ypu want run for your application
  )
  ```

  - To use the Queue service set message_queue = True

  ```python
  from AIBridge import OpenAIService
  import json

  json_schema = json.dumps({"animal": ["list of animals"]})
  data = OpenAIService.generate(
      prompts=["name of the animals in the  {{jungle}}"],
      prompt_ids=None,
      prompt_data=[{"jungle": "jungle"}],
      variables=None,
      output_format=["json"],
      format_strcture=[json_schema],
      message_queue=True# to activate message queue service
  )

  print(data)
  ```

  \*Response for above function is the id of the response stored in the databse

  ```json
  { "response_id": "eaa61944-3216-4ba1-bec5-05842fb86d86" }
  ```

  - Message queue is for increasing scalibilty
  - for APplication server you have turn on the consumer when application getting started.

  ```python
  from AIBridge import MessageQ


  MessageQ.mq_deque()
  ```

  - In the non application environmen:
    - you can run set message queue=True
  - Run the below function to procees the Stream data in consumer

  ```python
  from AIBridge import MessageQ

  data = MessageQ.local_process()
  print(data)
  ```



  ```python
  from AIBridge.ai_services.openai_images import OpenAIImage

  images = OpenAIImage.generate(
      prompts=["A sunlit indoor lounge area with a pool containing a flamingo"],
      image_data=["image loacation or image url"],
      mask_image=["image loacation or image url"],
      variation_count=1,
      process_type="edit",
  )
  print(images)










  ```



  - To set APi key in aibridge_config.yaml file you can add the it directly in aibridge_config.yaml file in the format

  ```yaml
     palm_api:
    - key: AIz****************************QkkA(your-api_key)
      priority: equal
  ```

  ```python
      from AIBridge import SetConfig
      SetConfig.set_api_key(ai_service="palm_api",key="YOUR_API_KEY",priority="high")
      
  ```

  ````
  ```python
  from AIBridge import PalmText

  prompt = """
  write paragraph about the {{prompting}}in ai and let user know what is the{{prompting}} and how the {{prompting}} works in genrative AI
  """
  json_format = """{"text": "paragraph here"}"""
  data = PalmText.generate(
      prompts=[prompt],
      prompt_data=[{"prompting": "model training"}],
      output_format=["json"],
      format_strcture=[json_format],
      message_queue=True,
  )
  print(data)












  ````



  ```python
      from AIBridge import PalmChat
      
      examples = [
          (
              "What's up?",
              "What isn't up?? The sun rose another day, the world is bright, anything is possible!",
          ),
          (
              "I'm kind of bored",
              "How can you be bored when there are so many fun, exciting, beautiful experiences to be had in the world?",
          ),
      ]
      data = PalmChat.generate(
          messages="give the protype for the stack on c++",
          context="carreer or growth advides",
          variation_count=3,
          message_queue=True,
      )
      print(data)
      
      
      
      
      
      
  ```



  ```yaml
  stable_diffusion:
    - key: API Key here
      priority: equal
  ```

  - stable diffusion we have 3 action "img2img,text2image, inpaint"
  - #### text2imag

  ```python
  from AIBridge import StableDiffusion

  data = StableDiffusion.generate(
      prompts=["cat sitting on bench"],# prompts is the list for how many images you have to genrate per request
      action="text2img",
  )
  print(data)
  ```

  - #### image2imag

  ```python
  from AIBridge import StableDiffusion

  init_image = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
  data = StableDiffusion.generate(
      prompts=["cat sitting on bench"],
      image_data=[init_image], #image data is the list followed by the prompts for each prompt there should be one image data
      action="img2img",
  )
  print(data)
  ```

  - #### inpaint

  ```python
  from AIBridge import StableDiffusion

  mask_image = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
  init_image = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
  data = StableDiffusion.generate(
      prompts=["cat sitting on bench"],
      image_data=[init_image],
      mask_image=[mask_image],
      action="inpaint",
  )
  print(data)
  ```

  - ### Note
  - At the image genration time thorugh api in stable diffusion complexex image some time take time so they are keep in the que and to fetch the image after completion we have to provide the response id

  ```python
  from AIBridge import StableDiffusion
  data=StableDiffusion.fetch_image(id="image_id here")
  print(Data)
  ```

  ```josn
  {
      "status": "success",
      "id": 12202888,
      "output": [
          "https://pub-8b49af329fae499aa563997f5d4068a4.r2.dev/generations/e5cd86d3-7305-47fc-82c1-7d1a3b130fa4-0.png"
      ]
  }
  ```

  - for Getting the information about all Queuing parameters

  ```Pyhton
  from AIBridge import StableDiffusion
  data=StableDiffusion.system_load(id="image_id here")
  print(Data)
  ```

  ```json
  {
    "queue_num": 0,
    "queue_time": 0,
    "status": "ok"
  }
  ```



  ```yaml
  cohere_api:
    - key: API Key here
      priority: equal
  ```

  ```python
      from AIBridge import SetConfig
      SetConfig.set_api_key(ai_service="cohere_api",key="YOUR_API_KEY",priority="high")
      
  ```

  ```python
  from AIBridge import CohereApi
  json_str = """{"text": "text here"}"""
  csv_string = "name,animal_type,prey,predators"
  xml_string = """<data><animal>animal information here</animal></data>"""
  data = CohereApi.generate(
      prompts=["give the me the more information about the {{animals}}"],
      prompt_data=[{"animals": "animals"}],
      format_strcture=[xml_string],
      output_format=["xml"],
  )
  print(data)












  ```



  ```yaml
  ai21_api:
    - key: API Key here
      priority: equal
  ```

  ```python
      from AIBridge import SetConfig
      SetConfig.set_api_key(ai_service="ai21_api",key="YOUR_API_KEY",priority="high")
      
  ```

  ```python
  from AIBridge import AI21labsText
  json_str = """{"text": "text here"}"""
  csv_string = "name,animal_type,prey,predators"
  xml_string = """<?xml version="1.0" encoding="UTF-8" ?><data><animal>animal information here</animal></data>"""
  data = AI21labsText.generate(
      prompts=["give the me the more information about the {{animals}}"],
      prompt_data=[{"animals": "tigers"}],
      format_strcture=[csv_string],
      output_format=["csv"],
  )
  print(data)












  ```


pkgId: 4ae011b009baae74c9fdc2b7b0907fe6471a0140634ba39ba8a6c0191016e591
name: python-aibrix
arch: src
version: 0.1.0rc5
epoch: 0
release: 1
summary: AIBrix, the foundational building blocks for constructing your own GenAI inference infrastructure.
url: https://github.com/aibrix/aibrix/tree/main/python/aibrix
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibrix-0.1.0rc5-1.src.rpm
checksum_type: sha256
description:
  A versatile sidecar enabling metric standardization, model downloading, and management.



  AI Runtime can be installed by `pip`.

  ```sh
  pip install aibrix
  ```


  The AI Runtime supports model downloading from the following storage backends:
  * HuggingFace
  * S3
  * TOS

  For more details on model downloading, please refer to our [Runtime docs](https://github.com/aibrix/aibrix/blob/main/docs/source/features/runtime.rst#model-downloading).


  The AI Runtime hides various implementation details on the inference engine side, providing a universal method to guide model management, as well as expose inference monitoring metrics.

  At present, `vLLM` engine is supported, and in the future, `SGLang` and other inference engines will be supported.

  For more details on integrate with `vLLM`, please refer to our [Runtime docs](https://github.com/aibrix/aibrix/blob/main/docs/source/features/runtime.rst#metric-standardization).


  We welcome contributions from the community! Check out our [contributing guidelines](https://github.com/aibrix/aibrix/blob/main/CONTRIBUTING.md) to see how you can make a difference.



  ```bash

  pip install -e .
  ```



  Before contribute your code, please run the following commands to ensure that your code passes the tests and linting checks.

  ```bash

  poetry install --no-root --with dev


  bash ./scripts/format.sh
  ```



  AI Runtime is licensed under the [APACHE License](https://github.com/aibrix/aibrix/LICENSE.md).


pkgId: e74815f50afa28baf65d4fd3846c709cb138b5ff0e337ee896f4b7ae10c26d26
name: python-aibs-informatics-aws-lambda
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Utility library for building validated and typed AWS Lambda functions
url: https://github.com/AllenInstitute/aibs-informatics-aws-lambda/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibs-informatics-aws-lambda-0.0.4-1.src.rpm
checksum_type: sha256
description:
  This is a base package that can be used standalone with some core lambda functionality or as a dependency.

  The package contains  several classes and functions that make it easy to create strongly typed lambda functions with many nice-to-have features (serialization/deserialization, easy to add metrics, utilities to create batch sqs and dynamo db event bridge processing ). In addition to these base classes, you can also use a collection of general purpose lambda handler classes.


  The [`LambdaHandler`](src/aibs_informatics_aws_lambda/common/handler.py) class provides a base class for creating strongly typed lambda functions with features like serialization/deserialization, logging, and metrics.

  These classes extend the `LambdaHandler` class and provide a way to create strongly typed lambda functions that can be used as API Gateway endpoints.
  - [`ApiLambdaHandler`](src/aibs_informatics_aws_lambda/common/api/handler.py): A base class for API Gateway handlers.
  - [`ApiResolverBuilder`](src/aibs_informatics_aws_lambda/common/api/resolver.py): A utility class for building API Gateway resolvers.

  Most of these lambda functions are found under [src/aibs_informatics_aws_lambda/handlers/](./src/aibs_informatics_aws_lambda/handlers/)

  - [`CreateDefinitionAndPrepareArgsHandler`](src/aibs_informatics_aws_lambda/handlers/batch/create.py): Handles the creation and preparation of AWS Batch job definitions.
  - [`PrepareBatchDataSyncHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/operations.py): Prepares data synchronization tasks for AWS Batch.


  - [`GetJSONFromFileHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/operations.py): Retrieves JSON data from a file.
  - [`PutJSONToFileHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/operations.py): Writes JSON data to a file.
  - [`DataSyncHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/operations.py): Simple data sync task.
  - [`BatchDataSyncHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/operations.py): Handles batch of data sync tasks.
  - [`PrepareBatchDataSyncHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/operations.py): Taking a data sync request, it analyzes and generates multiple batches of data sync tasks to evenly distribute the load across multiple batch data sync tasks.

  - [`GetDataPathStatsHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/file_system.py): Retrieves statistics about data paths.
  - [`ListDataPathsHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/file_system.py): Lists data paths.
  - [`OutdatedDataPathScannerHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/file_system.py): Scans for outdated data paths.
  - [`RemoveDataPathsHandler`](src/aibs_informatics_aws_lambda/handlers/data_sync/file_system.py): Removes data paths.

  - [`PrepareDemandScaffoldingHandler`](src/aibs_informatics_aws_lambda/handlers/demand/scaffolding.py): Prepares scaffolding for demand execution.

  - [`NotificationRouter`](src/aibs_informatics_aws_lambda/handlers/notifications/router.py): Routes notifications to the appropriate notifier.
  - [`SESNotifier`](src/aibs_informatics_aws_lambda/handlers/notifications/notifiers/ses.py): Sends notifications via Amazon SES.
  - [`SNSNotifier`](src/aibs_informatics_aws_lambda/handlers/notifications/notifiers/sns.py): Sends notifications via Amazon SNS.

  - [`ImageReplicatorHandler`](src/aibs_informatics_aws_lambda/handlers/ecr/replicate_image.py): Handles the replication of ECR images between repositories using the [`ECRImageReplicator`](https://github.com/AllenInstitute/aibs-informatics-aws-utils/tree/main/src/aibs_informatics_aws_utils/ecr/image_replicator.py).

  With this package, you can also invoke lambda functions from the command line. The CLI executable is installed as `handle-lambda-request` and can be used to invoke lambda functions with payloads that can be specified as JSON, files, or S3 objects.
  ```
  usage: handle-lambda-request [-h] [--handler-qualified-name HANDLER_QUALIFIED_NAME] [--payload PAYLOAD] [--response-location RESPONSE_LOCATION]
  CLI AWS Lambda Handler
  options:
    -h, --help            show this help message and exit
    --handler-qualified-name HANDLER_QUALIFIED_NAME, --handler-name HANDLER_QUALIFIED_NAME, --handler HANDLER_QUALIFIED_NAME
                          handler function qualified name. If not provided, will try to load from ('AWS_LAMBDA_FUNCTION_HANDLER', '_HANDLER') env variables
    --payload PAYLOAD, --event PAYLOAD, -e PAYLOAD
                          event payload of function. If not provided, will try to load from AWS_LAMBDA_EVENT_PAYLOAD env variable
    --response-location RESPONSE_LOCATION, -o RESPONSE_LOCATION
                          optional response location to store response at. can be S3 or local file. If not provided, will load from AWS_LAMBDA_EVENT_RESPONSE_LOCATION env variable.
  ```


  ```bash
  handle-lambda-request --handler-qualified-name aibs_informatics_aws_lambda.handlers.data_sync.operations.GetJSONFromFileHandler --payload '{"path": "/path/to/file.json"}' --response-location /tmp/response.json
  ```

  ```bash
  handle-lambda-request --handler-qualified-name aibs_informatics_aws_lambda.handlers.data_sync.operations.GetJSONFromFileHandler --payload-file /path/to/payload.json --response-location /tmp/response.json
  ```

  ```bash
  handle-lambda-request --handler-qualified-name aibs_informatics_aws_lambda.handlers.data_sync.operations.GetJSONFromFileHandler --payload-file s3://bucket/key/payload.json --response-location s3://bucket/key/response.json
  ```

  ```bash
  AWS_LAMBDA_EVENT_PAYLOAD='{"path": "/path/to/file.json"}'
  AWS_LAMBDA_EVENT_RESPONSE_LOCATION='/tmp/response.json'
  handle-lambda-request --handler-qualified-name aibs_informatics_aws_lambda.handlers.data_sync.operations.GetJSONFromFileHandler
  ```

  The package includes comprehensive tests for all handlers, which can be found under the [test](test) directory.

  Any and all PRs are welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

  This software is licensed under the Allen Institute Software License, which is the 2-clause BSD license plus a third clause that prohibits redistribution and use for commercial purposes without further permission. For more information, please visit [Allen Institute Terms of Use](https://alleninstitute.org/terms-of-use/).


pkgId: a7d1d099cf034142a0a8c2686ca3420cb6dc5be16eeb467fd9d5392d24a367b0
name: python-aibs-informatics-aws-utils
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Library of AWS utility code for informatics projects at the Allen Institute for Brain Science
url: https://github.com/AllenInstitute/aibs-informatics-aws-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibs-informatics-aws-utils-0.0.2-1.src.rpm
checksum_type: sha256
description:
  The AIBS Informatics AWS Utils library provides a collection of utilities and tools for working with AWS services. This library includes functionalities for interacting with AWS S3, ECR, Lambda, and other AWS services, making it easier to integrate AWS capabilities into various projects at the Allen Institute for Brain Science.

  Any and all PRs are welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

  This software is licensed under the Allen Institute Software License, which is the 2-clause BSD license plus a third clause that prohibits redistribution and use for commercial purposes without further permission. For more information, please visit [Allen Institute Terms of Use](https://alleninstitute.org/terms-of-use/).


pkgId: 9339ccc5150f3cbd7eaa04f610725dfae9d83c55e6bcb182db8328fd32c953ab
name: python-aibs-informatics-cdk-lib
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: CDK Library for AIBS Informatics services
url: https://github.com/AllenInstitute/aibs-informatics-cdk-lib/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibs-informatics-cdk-lib-0.0.3-1.src.rpm
checksum_type: sha256
description:
  The AIBS Informatics CDK Library is a collection of AWS Cloud Development Kit (CDK) constructs and utilities designed to facilitate the deployment and management of cloud infrastructure for the Allen Institute for Brain Science. This library includes constructs for managing AWS Batch environments, Elastic File System (EFS) configurations, CloudWatch dashboards, and more. It aims to provide reusable and configurable components to streamline the development and deployment of cloud-based applications and services.

  - **Batch**: Constructs for setting up and managing AWS Batch environments, including job queues, compute environments, and monitoring.
  - **EFS**: Utilities and constructs for configuring and managing Elastic File System (EFS) resources.
  - **CloudWatch**: Tools for creating and managing CloudWatch dashboards and alarms.
  - **Service Compute**: Constructs for defining compute resources, including Lambda functions and Batch compute environments.
  - **State Machine Fragments**: Reusable fragments for AWS Step Functions, including batch job submission and data synchronization.
  - **Assets**: Definitions and utilities for managing code assets, including Lambda functions and Docker images.
  - **Core**: Base constructs and utilities used across the library, including environment configurations and common IAM policies.

  Any and all PRs are welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

  This software is licensed under the Allen Institute Software License, which is the 2-clause BSD license plus a third clause that prohibits redistribution and use for commercial purposes without further permission. For more information, please visit [Allen Institute Terms of Use](https://alleninstitute.org/terms-of-use/).

rpm_license:
  Allen Institute Software License – This software license is the 2-clause BSD license plus a third clause that prohibits redistribution and use for commercial purposes without further permission.  Copyright © 2024. Allen Institute.  All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Redistributions and use for commercial purposes are not permitted without the Allen Institute’s written permission. For purposes of this license, commercial purposes are the incorporation of the Allen Institute's software into anything for which you will charge fees or other compensation or use of the software to perform a commercial service for a third party. Contact terms@alleninstitute.org for commercial licensing opportunities.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 7802c1f43d06ee9fe81b4b03dce3d4b0d88c7c4f0027aa0bfb371dee3d61b8c2
name: python-aibs-informatics-core
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Core package for informatics projects at the Allen Institute for Brain Science
url: https://github.com/AllenInstitute/aibs-informatics-core/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibs-informatics-core-0.0.6-1.src.rpm
checksum_type: sha256
description:
  The AIBS Informatics Core library provides a collection of core functionalities and utilities for various projects at the Allen Institute for Brain Science. This library includes modules for handling environment configurations, data models, executors, and various utility functions.


  The `utils` module provides various utility functions and classes to facilitate common tasks such as logging, hashing, and working with dictionaries and strings.
  - **file_operations**: Functions for working with files and directories.
  - **decorators**: Decorators for adding functionality to functions and methods.
  - **hashing**: Functions for generating hashes.
  - **json**: Functions for working with JSON data.
  - **logging**: Utilities for setting up and managing logging.
  - **modules**: Functions dealing with modules and imports.
  - **multiprocessing**: Functions for working with multiprocessing.
  - **os_operations**: Functions for working with the operating system.
  - **time**: Functions for working with time.
  - **units**: Functions for converting units.
  - **version**: Functions and classes for handling version numbers.
  - **tools.dicttools**: Functions for manipulating dictionaries.
  - **tools.strtools**: Functions for manipulating strings.

  The `models` module defines protocols and base models used for serialization and deserialization of data. This module provides base classes for creating data models and utilities for working with data models.
  There are a few base classes that can be used to create data models:
  - **ModelBase**: A base class for creating data models.
  - **DataClassModel**: A base class for creating data models using dataclasses.
  - **SchemaModel**: A base class for creating data models using marshmallow schemas + dataclass.
  - **WithValidation**: A mixin class for adding validation to data models.

  The `executors` module provides base classes and utilities for creating and running executors. Executors are responsible for handling specific tasks or requests. They allow for validating inputs/outputs based on schema data models
  - **BaseExecutor**: A base class for creating executors.
  - **run_cli_executor**: A utility function for running executors from the command line.

  The `env` module provides a concept of `EnvBase` which allows for creating isolated namespaces based on the type and name of environment:
  ```python
  env_base = EnvBase('dev-projectX')
  env_base.prefixed('my_resource', 'blue')  # 'dev-projectX-my_resource-blue'
  ```

  The `collections` module provides various collection classes and utilities for working with collections of data.
  - Classes
    - **DeepChainMap**: A class for creating recursive capable deep chain maps.
    - **Tree**: A subclass of dict for creating tree structures from sequences.
    - **ValidatedStr**: A class for creating validated strings based on regex patterns.
  - Mixins
    - **PostInitMixin**: A mixin class for handling post-initialization tasks.
    - **EnvBaseMixins**: A mixin class for handling environment-related tasks.
  - Enums
    - **BaseEnum**: A base class for creating enums.
    - **OrderedEnum**: A base class for creating ordered enums.
    - **StrEnum**: A base class for creating string enums.
    - **OrderedStrEnum**: A base class for creating ordered string enums.

  Any and all PRs are welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

  This software is licensed under the Allen Institute Software License, which is the 2-clause BSD license plus a third clause that prohibits redistribution and use for commercial purposes without further permission. For more information, please visit [Allen Institute Terms of Use](https://alleninstitute.org/terms-of-use/).

rpm_license:
  Allen Institute Software License – This software license is the 2-clause BSD license plus a third clause that prohibits redistribution and use for commercial purposes without further permission.  Copyright © 2024. Allen Institute.  All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Redistributions and use for commercial purposes are not permitted without the Allen Institute’s written permission. For purposes of this license, commercial purposes are the incorporation of the Allen Institute's software into anything for which you will charge fees or other compensation or use of the software to perform a commercial service for a third party. Contact terms@alleninstitute.org for commercial licensing opportunities.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: a43007d5e13b3861d88bb6d112986934c7af7e340c3cb803ccca7db892130d07
name: python-aibs-informatics-test-resources
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: unit test resources for AIBS informatics packages
url: https://github.com/AllenInstitute/aibs-informatics-test-resources/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aibs-informatics-test-resources-0.0.4-1.src.rpm
checksum_type: sha256
description:
  This package provides a collection of utilities and resources to facilitate testing in various AIBS Informatics projects. It includes base test classes, mock utilities, and other helpful tools.


  The [`BaseTest`](./src/aibs_informatics_test_resources/base.py) class provides a base class for creating unit tests with common setup and teardown functionality. It includes the following features:
  - **Environment Management**:
    - `set_env_vars(*key_values_pairs: Tuple[str, Optional[str]])`: Set environment variables for the duration of the test.
    - `reset_environ`: Class variable to reset environment variables after each test.
  - **Temporary Files and Directories**:
    - `tmp_path(basename: Optional[str] = None) -> Path`: Create a temporary directory.
    - `tmp_file(basename: Optional[str] = None, dirname: Optional[str] = None, content: Optional[str] = None) -> Path`: Create a temporary file with optional content.
  - **Assertions**:
    - `assertStringPattern(pattern: str, actual: str)`: Assert that a string matches a given regex pattern.
    - `assertJsonEqual(first: Union[dict, str, int, list], second: Union[dict, str, int, list])`: Assert that two JSON objects are equal.
    - `assertListEqual(list1: List[Any], list2: List[Any], msg: Any = None, presort: bool = False, **presort_kwargs) -> None`: Assert that two lists are equal, with an option to sort them before comparison.
  - **Mocking**:
    - `create_patch(name: str, **kwargs) -> MagicMock`: Create a patch for a given name and add it to the cleanup list.
  - **Context Managers**:
    - `chdir(destination: Union[str, Path])`: Context manager to change the current working directory temporarily.

  - `does_not_raise`: A context manager for assertions that no exceptions are raised.
  - [`reset_environ_after_test`](./src/aibs_informatics_test_resources/utils.py): A decorator to reset environment variables after a test.

  Here is an example of how to use the `BaseTest` class in your tests:
  ```python
  from aibs_informatics_test_resources import BaseTest
  class MyTest(BaseTest):
      def test_example(self):
          self.assertEqual(1 + 1, 2)
      def test_use_temp_file(self):
          with self.tmp_file(content="Hello, World!") as tmp_file:
              self.assertTrue(tmp_file.exists())
              self.assertEqual(tmp_file.read_text(), "Hello, World!")
  ```

  Any and all PRs are welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

  This software is licensed under the Allen Institute Software License, which is the 2-clause BSD license plus a third clause that prohibits redistribution and use for commercial purposes without further permission. For more information, please visit [Allen Institute Terms of Use](https://alleninstitute.org/terms-of-use/).

rpm_license:
  Allen Institute Software License – This software license is the 2-clause BSD license plus a third clause that prohibits redistribution and use for commercial purposes without further permission.  Copyright © 2024. Allen Institute.  All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Redistributions and use for commercial purposes are not permitted without the Allen Institute’s written permission. For purposes of this license, commercial purposes are the incorporation of the Allen Institute's software into anything for which you will charge fees or other compensation or use of the software to perform a commercial service for a third party. Contact terms@alleninstitute.org for commercial licensing opportunities.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 660f83f50c0e62f096bc314655e909ebe8a25abbff408ae2537c248a41ed27b4
name: python-aic-utils
arch: src
version: 1.5.4
epoch: 0
release: 1
summary: AIC API wrapper
url: https://github.com/dylandoyle11/aic_utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aic-utils-1.5.4-1.src.rpm
checksum_type: sha256
description:
  The AIC Utilities package provides a set of classes and methods to interact with the AIC API for managing projects, workspaces, and pipelines. It also integrates with GitLab for source control management and Slack for logging and notifications. The package includes three main components:

  1. **AIC**: Manages interactions with the ACI API for fetching project and workspace details, handling pipeline configurations, and managing file uploads.
  2. **GitLabManager**: Manages interactions with GitLab, including pushing files to repositories, managing repository existence, and ensuring the correct subgroup configuration based on the workspace.
  3. **SlackLogger**: Provides logging functionality that sends log messages to a specified Slack channel, with the ability to redirect print statements to Slack.




  The `AIC` class handles interactions with the J.D. Power API, including managing projects, workspaces, pipelines, and file uploads.



  - **`__init__(self, api_key, project, workspace, pipelines=[], gitlab_token=None)`**
    - Initializes the AIC instance with the specified API key, project, workspace, pipelines, and optional GitLab token.

  - **`get_data(self)`**
    - Prints project, workspace, and drive IDs.

  - **`get_config(self)`**
    - Returns the pipeline configurations.

  - **`get_project(self, project)`**
    - Fetches the project ID for the specified project name.

  - **`get_workspace(self, workspace)`**
    - Fetches the workspace ID for the specified workspace name.

  - **`pop_pipelines(self)`**
    - Retrieves and returns the list of pipelines in the specified workspace.

  - **`fetch_pipeline_config(self, pipeline)`**
    - Fetches the configuration for a single pipeline.

  - **`pop_pipeline_config(self, pipelines)`**
    - Fetches configurations for multiple pipelines concurrently using `ThreadPoolExecutor`.

  - **`get_drive_id(self, drive_name="config")`**
    - Fetches the drive ID for the specified drive name.

  - **`upload_json(self, file_name, json_content)`**
    - Uploads JSON content to the specified drive.

  - **`push_to_gitlab(self, pipelines=[])`**
    - Pushes pipeline configurations to GitLab concurrently.

  - **`upload_configs_to_drive(self)`**
    - Uploads pipeline configurations to the drive.

  - **`get_files_from_drive(self, drive_id=None)`**
    - Retrieves files from the specified drive.

  - **`download_file(self, drive_id, file_name)`**
    - Downloads a file from the storage drive.

  - **`download_from_gcs(self, gs_path)`**
    - Downloads content from Google Cloud Storage using the specified path.

  - **`delete_file(self, drive_id, file_id)`**
    - Deletes a file from the storage drive.

  - **`push_source_code(AIC_prod, AIC_qa, prod_to_qa=False, qa_to_prod=False, pipelines=[])`**
    - Overwrites pipeline configurations between production and QA based on the specified direction and pipelines.

  - **`write_config_to_pipeline(self, config)`**
    - Uploads the given configuration to the corresponding pipeline job.


  The `GitLabManager` class manages interactions with GitLab, including pushing files, checking repository existence, and creating repositories if needed.



  - **`__init__(self, aic_instance, gitlab_token=None, gitlab_namespace='pin/pin-analytics/pin-fusion-2.0/pipelines', gitlab_base_url='https://git.autodatacorp.org/api/v4', use_hash_comparison=True)`**
    - Initializes the GitLabManager instance with the specified AIC instance, GitLab token, namespace, base URL, and hash comparison setting.

  - **`get_token_expiration_date(self)`**
    - Retrieves the expiration date of the GitLab token.

  - **`check_token_expiration(self)`**
    - Checks and reports the token expiration date.

  - **`read_gitlab_token(self)`**
    - Reads the GitLab token from the storage drive.

  - **`generate_hash(self, content)`**
    - Generates a hash for the given content to check for changes.

  - **`get_existing_file_content(self, repo_name, file_name)`**
    - Fetches the existing content of a file from the specified repository in GitLab.

  - **`push_file_to_repo(self, repo_name, file_name, file_content)`**
    - Pushes a file to the specified repository in GitLab, only if the content has changed.

  - **`ensure_correct_subgroup(self, workspace)`**
    - Ensures the correct subgroup path based on the workspace.

  - **`create_repository(self, repo_name)`**
    - Creates a new repository in the specified subgroup.

  - **`get_subgroup_id(self)`**
    - Fetches the GitLab subgroup ID based on the namespace path.

  - **`get_namespace_id(self)`**
    - Retrieves the namespace ID for the current GitLab namespace.

  - **`repository_exists(self, repo_path)`**
    - Checks if the repository exists in GitLab.


  The `SlackLogger` class provides logging functionality that sends log messages to a specified Slack channel. It includes a custom logging handler that integrates with Python's logging module.



  - **`__init__(self, token, channel)`**
    - Initializes the SlackLogger with the specified Slack token and channel.

  - **`send_message(self, text)`**
    - Sends a message to the specified Slack channel.

  - **`SlackLoggerHandler(logging.Handler)`**
    - A custom logging handler that sends log messages to Slack using the SlackLogger.

  - **`redirect_print_to_logger(logger)`**
    - Redirects print statements to the specified logger.

  - **`create_logger(cls, slack_token='xoxb-7424459969442-7456034210037-EMCjbI9oi1xTszU1iUh4tLFH', slack_channel='C07DYFK5SE8', redirect_print=True)`**
    - Creates a logger that sends log messages to Slack, with options to redirect print statements.




  ```python
  from aic_utils.aic import AIC


  aic_instance = AIC(api_key='your_api_key', project='PIN ANALYTICS', workspace='PIN FUSION 2.0', pipelines=['pipeline1', 'pipeline2'])


pkgId: ac460ce9858bb72e4734b817fe4afc3f4353c97f1f6974f0400ee326eb0bf1a5
name: python-aichatlite
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Claude Similar Chat using Huggingface
url: https://github.com/yourusername/pyopengenai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aichatlite-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A chatbot system using huggingchat with most capable model qwen2.5-70B model , to achieve similar featurs of claude.

  ![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)




  - [x] Feature 1: Integrate hugchat and start ui
  - [ ] Feature 2: Integrate websearch
  - [ ] Feature 3: PDF+Chat
  - [ ] Feature 4: Ai Researcher on specific topic or request ( arxiv,google etc..)


pkgId: f4fd0f9d3e434c8d7f3c9ad9b86bc46f32eb8f174f1455099d13d2793315707e
name: python-aichatlite
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: claude chat
url: https://github.com/username/sa
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aichatlite-0.2.2-1.src.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: a2c814d3b8d9c6996ea1fa3d67ab11ada322d2a00207755c1ffaded34369f21b
name: python-aici
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: A command line interface for ChatGPT
url: https://github.com/tkykszk/aici/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aici-0.0.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/aici.svg)](https://pypi.org/project/aici/) [![Python Versions](https://img.shields.io/pypi/pyversions/aici.svg)](https://pypi.org/project/aici/) [![License](https://img.shields.io/pypi/l/aici.svg)](https://opensource.org/licenses/MIT)

  a command line i/f tool for the AI like ChatGPT. 🤖💬

  Use Case: would like to use ChatGPT with editors like Emacs and/or automated tools.

  ![commandline](images/aicissv.webp)

  ![emacs](images/aiciemacsssv.webp)



  `pip install aici`



  This program is based on Python🐍 that queries OpenAI’s ChatGPT model. It takes a user’s prompt as input and outputs the response from ChatGPT. The output can be directed to either standard output or the clipboard📋. Additionally, you can specify the model to use and set a custom system message .



  | Argument       | env val               | Default                      | Type | Description                                               |
  | -------------- | --------------------- | ---------------------------- | ---- | --------------------------------------------------------- |
  | -v, --version  |                       | -                            |      | Show version and exit                                     |
  | prompt         |                       | -                            | str  | The prompt to send to ChatGPT or "-" to read from stdin   |
  | -m, --model    | OPENAI_CHATGPT_MODEL  | gpt-4o                       | str  | model name                                                |
  | -c, --complete |                       | False (default streaming)    | bool | get a message when completed                              |
  | -s, --system   | OPENAI_CHATGPT_SYSTEM | You are a helpful assistant. | str  | specify the content value of role:system for the chat API |
  | -o, --output   |                       | stdout                       | str  | output destination, "clip" for clipboard                  |

  [chatgpt model document](https://platform.openai.com/docs/models)



  💻 std input
  💬 command parameter



  💻 std output (streaming, beffering)
  📋 clipboard



  🔑 it can be chosen using environment variable OPENAI_API_KEY or config file

  ```
  set OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxx
  ```

  it will check the files in the following locations (in the order listed below).
  ~/.config/aici/config ~/.aici

  ```
  OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxx
  ```

  🖥️ On Windows file path, it is expanded like
  | File path| Windows Specific|
  |--------------------------------------------------|:--:|
  | `C:\Users\{USERNAME}\AppData\Local\aici\config` |✔ |
  | `C:\Users\{USERNAME}\AppData\Roaming\aici\config`|✔ |
  | `C:\Users\{USERNAME}\.config\aici\config` | |
  |`C:\Users\{USERNAME}\.aici` | |
  (The priority of the applied config files is in the order listed from top to bottom.)



  💨 input from cli

  ```
  $ aici Hello
  ```

  💨 read from stdin

  ```
  $ echo Hello | aici -
  ```

  💨 output to clipboard 📋

  ```
  $ echo Hello | aici - --output clip
  ```





  Below is the content of `emacs/aici.el`

  ```elisp

  (defun aici-call ()
    "Send selected region or prompt for input if no region is selected to the 'aici' command and insert the output in real-time."
    (interactive)
    (let* ((text (if (use-region-p)
                     (buffer-substring-no-properties (region-beginning) (region-end))
                   (read-string "Enter text: ")))
           ;; Attempt to create or get the output buffer
           (output-buffer (get-buffer-create "*AICI Output*")))

      ;; Check if the buffer creation was successful
      (if (not output-buffer)
          (error "Failed to create or access the output buffer")
        ;; Clear the output buffer
        (with-current-buffer output-buffer
          (erase-buffer)
          ;; Set the buffer to markdown-mode
          (markdown-mode))

        ;; Display a message indicating that processing is ongoing
        (message "Processing...")

        ;; Start the process and stream the output to the buffer
        (let ((process (start-process "aici-process" output-buffer "sh" "-c"
                                      (format "echo %s | aici -" (shell-quote-argument text)))))
          ;; Set a process filter to handle output streaming
          (set-process-filter process
                              (lambda (proc output)
                                ;; Explicitly reference the output-buffer by capturing it in the lambda
                                (let ((buffer (process-buffer proc)))
                                  (when (buffer-live-p buffer)
                                    (with-current-buffer buffer
                                      (goto-char (point-max))
                                      (insert output)
                                      ;; Optionally display the buffer in real-time
                                      (display-buffer buffer))))))

          ;; Set a sentinel to handle process completion
          (set-process-sentinel process
                                (lambda (proc event)
                                  ;; Again, ensure that output-buffer is properly referenced
                                  (let ((buffer (process-buffer proc)))
                                    (when (buffer-live-p buffer)
                                      (if (string= event "finished\n")
                                          (message "Processing complete.")
                                        (message "Processing interrupted: %s" event))))))))

        ;; Ensure the output buffer is displayed after starting the process
        (display-buffer output-buffer)))

  ```



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


pkgId: 23e7290158d8f20570f877c276efa80b14b87336cad42abf7b4790f7598f9c4e
name: python-aicli-agent
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/callmexss/aicli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aicli-agent-0.1.3-1.src.rpm
checksum_type: sha256
description:
  [English Version](README_en.md)



  一个基于AI的命令行助手工具。



  ![](./images/python-automate-aicli-ex1-zh.gif)





  ```sh
  pip install aicli-agent
  ```



  1. 克隆此仓库:

  ```sh
  git clone https://github.com/callmexss/aicli.git
  cd aicli
  ```

  2. 安装依赖:

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

  3. 设置环境变量:

  复制`.env.example`文件为`.env`并填写必要的环境变量:
  ```sh
  cp .env.example .env
  ```
  然后编辑`.env`文件,填写您的API密钥和其他设置。



  安装后,您可以直接在命令行中使用`aicli`命令:

  ```sh
  aicli 查询
  ```

  例如:

  ```sh
  aicli 列出当前目录的文件
  aicli "帮我安装 nvm"
  ```



  本项目基于 [GeneralAgent](https://github.com/CosmosShadow/GeneralAgent) 构建。


pkgId: 6ba37cc9f0a602f2a4ae38a400625479e562e8428e3d989e55d312a6a49f5287
name: python-aiconfig-extension-hugging-face
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: An extension for using Hugging Face tasks to parse models for AIConfig.
url: https://github.com/lastmile-ai/aiconfig/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiconfig-extension-hugging-face-0.0.13-1.src.rpm
checksum_type: sha256
description:
  This extension contains AIConfig model parsers with two main subfolders:

  1. `local_inference`: Loads models onto your machine and uses Hugging Face transformers and diffusors locally.
  2. `remote_inference_client`: Uses Hugging Face's InferenceClient API to connect to models remotely





  If you are not testing and developing locally (just using the published extension), ignore this and go to Part 2

  1. From the `aiconfig/extensions/HuggingFace`, run this command: `pip3 install build && cd python && python -m build && pip3 install dist/*.whl`
  2. Link your local dev environment to the current dir: `pip3 install -e .`. Afterwards if you do `pip3 list | grep aiconfig`, you should see this linked to your local path. If you ever wish to use the published extension, you will need to first remove the extension: `pip3 uninstall aiconfig-extension-hugging-face && pip3 install aiconfig-extension-hugging-face`
  3. After you're done testing, be sure to delete the generated folder(s) in the `aiconfig/HuggingFace` dir. It'll probably look something like `python/dist` and `python/<package_name>.egg-info`



  ``pip3 install aiconfig-extension-hugging-face``

  1. Import the library to your code: `from aiconfig_extension_hugging_face import <EXTENSION>`.
  2. Import the AIConfig model registery: `from aiconfig import ModelRegistryParser`
  3. In code, add all the relevant model parser objects that you want to use from this extension to the registry. Ex: `ModelParserRegistry.register_model_parser(HuggingFaceTextGenerationTransformer())`. You can read the docstrings under `ModelParserRegistry` class for more info
  4. In your AIConfig, add a field `model_parsers` with the model you want to use and the id of the extension you want to use: . Ex: https://github.com/lastmile-ai/aiconfig/blob/f1840995b7a12acba371a59ac3b8c69b3962fc68/cookbooks/Getting-Started/travel.aiconfig.json#L19-L22
  5. Now whenever you call `aiconfig.run()` these model parsers will be loaded and available!


pkgId: d165daf6e2add95526f9a32f5cd9ba8a546a4374129aeaa6adb061d1154b9d40
name: python-aicontext
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Simple context management for AI conversations
url: https://github.com/spencerkinney/aicontext
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aicontext-0.0.1-1.src.rpm
checksum_type: sha256
description:
  Simple context management for AI chat applications. Handles message history and formatting across different LLM providers.


  ```python
  from aicontext import AIChatContext, ai_chat_context
  from openai import OpenAI
  from anthropic import Anthropic


  context = AIChatContext(system_prompt="You are a helpful assistant.")
  openai, anthropic = OpenAI(), Anthropic()


  @ai_chat_context(context)
  def ask_gpt(prompt: str):
      return openai.chat.completions.create(
          model="gpt-4",
          messages=[{"role": "system", "content": context.system_prompt}] + context.get_messages()
      )

  @ai_chat_context(context)
  def ask_claude(prompt: str):
      return anthropic.messages.create(
          model="claude-3-5-sonnet-20240620",
          system=context.system_prompt,
          messages=context.get_messages(),
          max_tokens=1024
      )


  ask_gpt("What's the capital of France?")
  ask_claude("What's interesting about it?")
  print(context.format())  # Print conversation
  ```




  ```python
  @ai_chat_context(context, assistant_name="Researcher")
  def researcher(prompt: str):
      return anthropic.messages.create(
          model="claude-3-5-sonnet-20240620",
          system=context.system_prompt,
          messages=context.get_messages(),
          max_tokens=1024
      )

  @ai_chat_context(context, assistant_name="Coder")
  def coder(prompt: str):
      return openai.chat.completions.create(
          model="gpt-4",
          messages=[{"role": "system", "content": context.system_prompt}] + context.get_messages()
      )


  researcher("Explain quantum computing")
  coder("Show me a quantum random number generator")


  print(context.format(assistant_name="Researcher"))
  print(context.latest(assistant_name="Coder"))
  ```


  ```python

  print(context.format(limit=5))


  print(context.format(
      assistant_name="Researcher",
      role="assistant",
      limit=2
  ))


  messages = context.get_messages()
  ```


  ```python

  saved = context.to_json()


  new_context = AIChatContext(messages=saved)
  ```



  ```bash
  pip install aicontext
  ```




  ```python
  AIChatContext(
      system_prompt: Optional[str] = None,    # System instructions
      max_messages: Optional[int] = None,     # Message limit
      messages: Optional[Union[List[Dict], str]] = None  # Load existing
  )
  ```


  | Method | Description |
  |--------|-------------|
  | `get_messages()` | Get messages for API calls |
  | `filter(assistant_name=None, role=None, limit=None)` | Filter messages |
  | `format(**kwargs)` | Get formatted history |
  | `latest(assistant_name=None)` | Get latest message |
  | `to_json()` | Export to JSON |
  | `load_messages(messages)` | Load messages |
  | `clear(assistant_name=None)` | Clear history |


  ```python
  @ai_chat_context(
      context: AIChatContext,         # Context instance
      assistant_name: str = "default" # Optional name
  )
  ```


  ```python
  context.filter(
      assistant_name="Researcher",  # Filter by assistant
      role="assistant",            # Filter by role
      limit=5,                     # Limit results
      offset=2                     # Skip messages
  )
  ```



  MIT


pkgId: 67169549bbba4027f9d3c2833ca001284a54b7b2e0e54ea08dc973775b190f86
name: python-aicrowd-cli
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: A CLI app to interact with AIcrowd
url: https://gitlab.aicrowd.com/aicrowd/aicrowd-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aicrowd-cli-0.1.15-1.src.rpm
checksum_type: sha256
description:
  `aicrowd-cli` is a simple CLI tool for interacting with the AIcrowd platform. It is written in python, using [click](https://click.palletsprojects.com/en/7.x/).

  Download datasets, make submissions and much more with a single command!

  [![pipeline status](https://gitlab.aicrowd.com/aicrowd/aicrowd-cli/badges/master/pipeline.svg)](https://gitlab.aicrowd.com/aicrowd/aicrowd-cli/-/commits/master)
  [![coverage report](https://gitlab.aicrowd.com/aicrowd/aicrowd-cli/badges/master/coverage.svg)](https://gitlab.aicrowd.com/aicrowd/aicrowd-cli/-/commits/master)

  [Documentation](https://docs.aicrowd.com/aicrowd-cli/)


  python3.6 and above are supported on all platforms.


  Kindly raise an issue [here](https://gitlab.aicrowd.com/aicrowd/aicrowd-cli/-/issues/new).


pkgId: ec054932173ef55c797383ab54d40398dccae0aa5f7b9a2308b48244803c7266
name: python-aicscytoparam
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: Cytoplasm parameterization using spherical harmonics
url: https://github.com/AllenCell/aics-cytoparam
rpm_license: Allen Institute Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aicscytoparam-0.1.12-1.src.rpm
checksum_type: sha256
description:
  **Stable Release:** `pip install aicscytoparam`<br>
  **Development Head:** `pip install git+https://github.com/AllenCell/aics-cytoparam.git`

  Here we outline an example of how to use `aicscytoparam` to create a parameterization of a 3D cell. In this case, the 3D cells will be represented by a cell segementation, nuclear segmentation and a fluorescent protein (FP) image representing the fluorescent signal of a tagged protein.
  ```python

  import numpy as np
  import matplotlib.pyplot as plt
  from aicscytoparam import cytoparam
  from skimage import morphology as skmorpho
  ```
  ```python


  w = 100
  mem = np.zeros((w, w, w), dtype = np.uint8)
  mem[20:80, 20:80, 20:80] = 1
  nuc = np.zeros((w, w, w), dtype = np.uint8)
  nuc[40:60, 40:60, 30:50] = 1


  gfp = np.random.rand(w**3).reshape(w,w,w)
  gfp[mem==0] = 0
  gfp[:, w//2:] = 0
  gfp[nuc>0] = 0

  plt.imshow((mem + nuc)[w//2], cmap='gray')
  plt.imshow(gfp[w // 2], cmap='gray', alpha=0.25)
  plt.axis('off')
  ```
  ![Cuboid cell](docs/im1.jpg)
  ```python


  coords, coeffs_centroid = cytoparam.parameterize_image_coordinates(
      seg_mem=mem,
      seg_nuc=nuc,
      lmax=16, # Degree of the spherical harmonics expansion
      nisos=[32, 32] # Number of interpolation layers
  )
  coeffs_mem, centroid_mem, coeffs_nuc, centroid_nuc = coeffs_centroid


  gfp_representation = cytoparam.cellular_mapping(
      coeffs_mem=coeffs_mem,
      centroid_mem=centroid_mem,
      coeffs_nuc=coeffs_nuc,
      centroid_nuc=centroid_nuc,
      nisos=[32, 32],
      images_to_probe=[('gfp', gfp)]
  ).data.squeeze()

  print(gfp_representation.shape)
  ```
  `(65, 8194)`
  ```python


  from skimage import morphology as skmorpho
  mem_round = skmorpho.ball(w // 3) # radius of our round cell
  nuc_round = skmorpho.ball( w// 3) # radius of our round nucleus

  nuc_round = skmorpho.binary_erosion(
      nuc_round, selem=np.ones((20, 20, 20))
      ).astype(np.uint8)

  plt.imshow((mem_round + nuc_round)[w // 3], cmap='gray')
  plt.axis('off')
  ```
  ![Cuboid cell](docs/im2.jpg)
  ```python


  coords_round, _ = cytoparam.parameterize_image_coordinates(
      seg_mem=mem_round,
      seg_nuc=nuc_round,
      lmax=16,
      nisos=[32, 32]
  )

  gfp_morphed = cytoparam.morph_representation_on_shape(
      img=mem_round + nuc_round,
      param_img_coords=coords_round,
      representation=gfp_representation
  )

  plt.imshow((mem_round + nuc_round)[w // 3], cmap='gray')
  plt.imshow(gfp_morphed[w // 3], cmap='gray', alpha=0.25)
  plt.axis('off')
  ```
  ![Cuboid cell](docs/im3.jpg)

  For an example of how this package was used to analyse a dataset of over 200k single-cell images at the Allen Institute for Cell Science, please check out our paper in [bioaRxiv](https://www.biorxiv.org/content/10.1101/2020.12.08.415562v1).

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.

  If you have any questions, feel free to leave a comment in our Allen Cell forum: [https://forum.allencell.org/](https://forum.allencell.org/).
  ***Free software: Allen Institute Software License***


pkgId: 575b7b08f36debc4e9a9331a79bc496c81a99452c6a503a6a0c8078bffa64f2c
name: python-aicsshparam
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Spherical harmonics parametrization for 3D starlike shapes
url: https://github.com/AllenCell/aics-shparam
rpm_license: Allen Institute Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aicsshparam-0.1.10-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/AllenCell/aics-shparam/workflows/Build%20Main/badge.svg)](https://github.com/AllenCell/aics-shparam/actions)
  [![Documentation](https://github.com/AllenCell/aics-shparam/workflows/Documentation/badge.svg)](https://AllenCell.github.io/aics-shparam/)



  ![Parameterization of cell and nuclear shape](https://github.com/AllenCell/aics-shparam/blob/main/docs/logo.gif?raw=true)



  **Stable Release**: `pip install aicsshparam`

  **Build from source to make customization**:

  ```console
  git clone git@github.com:AllenCell/aics-shparam.git
  cd aics-shparam
  pip install -e .
  ```



  Here we outline an example of how one could use spherical harmonics coefficients as shape descriptors on a synthetic dataset composed by 3 different shapes: spheres, cubes and octahedrons.

  ```python

  import numpy as np
  import pandas as pd
  import matplotlib.pyplot as plt
  from sklearn.decomposition import PCA
  from aicsshparam import shtools, shparam
  from skimage.morphology import ball, cube, octahedron
  np.random.seed(42) # for reproducibility
  ```

  ```python


  def get_random_3d_shape():
      idx = np.random.choice([0, 1, 2], 1)[0]
      element = [ball, cube, octahedron][idx]
      label = ['ball', 'cube', 'octahedron'][idx]
      img = element(10 + int(10 * np.random.rand()))
      img = np.pad(img, ((1, 1), (1, 1), (1, 1)))
      img = img.reshape(1, *img.shape)
      
      img = shtools.rotate_image_2d(
          image=img,
          angle=360 * np.random.rand()
      ).squeeze()
      return label, img



  df_coeffs = []
  for i in range(30):
      
      label, img = get_random_3d_shape()
      
      
      (coeffs, _), _ = shparam.get_shcoeffs(image=img, lmax=4)
      coeffs.update({'label': label})
      df_coeffs.append(coeffs)
  df_coeffs = pd.DataFrame(df_coeffs)


  with pd.option_context('display.max_rows', 5, 'display.max_columns', 5):
      display(df_coeffs)
  ```

  ![Coefficients dataframe](https://github.com/AllenCell/aics-shparam/blob/main/docs/table1.jpg?raw=true)

  ```python


  pca = PCA(n_components=2)
  trans = pca.fit_transform(df_coeffs.drop(columns=['label']))
  df_trans = pd.DataFrame(trans)
  df_trans.columns = ['PC1', 'PC2']
  df_trans['label'] = df_coeffs.label


  with pd.option_context('display.max_rows', 5, 'display.max_columns', 5):
      display(df_trans)
  ```

  ![PCA dataframe](https://github.com/AllenCell/aics-shparam/blob/main/docs/table2.jpg?raw=true)

  ```python

  fig, ax = plt.subplots(1,1, figsize=(3,3))
  for label, df_label in df_trans.groupby('label'):
      ax.scatter(df_label.PC1, df_label.PC2, label=label, s=50)
  plt.legend(loc='upper left', bbox_to_anchor=(1.05, 1))
  plt.xlabel('PC1')
  plt.ylabel('PC2')
  plt.show()
  ```

  ![PC1 vs. PC2](https://github.com/AllenCell/aics-shparam/blob/main/docs/pc12.png?raw=true)




  For an example of how this package was used to analyse a dataset of over 200k single-cell images at the Allen Institute for Cell Science, please check out our paper in [bioaRxiv](https://www.biorxiv.org/content/10.1101/2020.12.08.415562v1).


  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.




  If you have any questions, feel free to leave a comment in our Allen Cell forum: [https://forum.allencell.org/](https://forum.allencell.org/).


  _Free software: Allen Institute Software License_


pkgId: c52f5eae91597fbbbd082a1cb24d4934fcdaaa2d35cadf5ce9b1a4e5b0e0d155
name: python-aidbox-python-sdk
arch: src
version: 0.1.13
epoch: 0
release: 1
summary: Aidbox SDK for python
url: https://pypi.org/project/aidbox-python-sdk/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aidbox-python-sdk-0.1.13-1.src.rpm
checksum_type: sha256
description:
  [![build status](https://github.com/Aidbox/aidbox-python-sdk/actions/workflows/build.yaml/badge.svg)](https://github.com/Aidbox/aidbox-python-sdk/actions/workflows/build.yaml)
  [![pypi](https://img.shields.io/pypi/v/aidbox-python-sdk.svg)](https://pypi.org/project/aidbox-python-sdk/)
  [![Supported Python version](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/release/python-390/)



  1. Create a python 3.9+ environment `pyenv `
  2. Set env variables and activate virtual environment `source activate_settings.sh`
  2. Install the required packages with `pipenv install --dev`
  3. Make sure the app's settings are configured correctly (see `activate_settings.sh` and `aidbox_python_sdk/settings.py`). You can also
   use environment variables to define sensitive settings, eg. DB connection variables (see example `.env-ptl`)
  4. You can then run example with `python example.py`.





  main.py
  ```python
  from aidbox_python_sdk.main import create_app as _create_app
  from aidbox_python_sdk.settings import Settings
  from aidbox_python_sdk.sdk import SDK


  settings = Settings(**{})
  sdk = SDK(settings, resources={}, seeds={})


  def create_app():
      app = await _create_app(SDK)
      return app


  async def create_gunicorn_app() -> web.Application:
      return create_app()
  ```


  ```python
  import logging
  from aiohttp import web
  from aidbox_python_sdk.types import SDKOperation, SDKOperationRequest

  from yourappfolder import sdk


  @sdk.operation(
      methods=["POST", "PATCH"],
      path=["signup", "register", {"name": "date"}, {"name": "test"}],
      timeout=60000  ## Optional parameter to set a custom timeout for operation in milliseconds
  )
  def signup_register_op(_operation: SDKOperation, request: SDKOperationRequest):
      """
      POST /signup/register/21.02.19/testvalue
      PATCH /signup/register/22.02.19/patchtestvalue
      """
      logging.debug("`signup_register_op` operation handler")
      logging.debug("Operation data: %s", operation)
      logging.debug("Request: %s", request)
      return web.json_response({"success": "Ok", "request": request["route-params"]})

  ```



  To access Aidbox Client, SDK, settings, DB Proxy the `app` (`web.Application`) is extended by default with the following app keys that are defined in `aidbox_python_sdk.app_keys` module:

  ```python
  from aidbox_python_sdk import app_keys as ak
  from aidbox_python_sdk.types import SDKOperation, SDKOperationRequest

  @sdk.operation(["POST"], ["example"])
  async def update_organization_op(_operation: SDKOperation, request: SDKOperationRequest):
      app = request.app
      client = app[ak.client] # AsyncAidboxClient
      sdk = app[ak.sdk] # SDK
      settings = app[ak.settings] # Settings
      db = app[ak.db] # DBProxy
      return web.json_response()
  ```



  FHIR Client is not plugged in by default, however, to use it you can extend the app by adding new AppKey

  app/app_keys.py
  ```python
  from fhirpy import AsyncFHIRClient

  fhir_client: web.AppKey[AsyncFHIRClient] = web.AppKey("fhir_client", AsyncFHIRClient)
  ```

  main.py
  ```python
  from collections.abc import AsyncGenerator

  from aidbox_python_sdk.main import create_app as _create_app
  from aidbox_python_sdk.settings import Settings
  from aidbox_python_sdk.sdk import SDK
  from aiohttp import BasicAuth, web
  from fhirpy import AsyncFHIRClient

  from app import app_keys as ak

  settings = Settings(**{})
  sdk = SDK(settings, resources={}, seeds={)

  def create_app():
      app = await _create_app(SDK)
      app.cleanup_ctx.append(fhir_clients_ctx)
      return app


  async def create_gunicorn_app() -> web.Application:
      return create_app()


  async def fhir_clients_ctx(app: web.Application) -> AsyncGenerator[None, None]:
      app[ak.fhir_client] = await init_fhir_client(app[ak.settings], "/fhir")

      yield


  async def init_fhir_client(settings: Settings, prefix: str = "") -> AsyncFHIRClient:
      basic_auth = BasicAuth(
          login=settings.APP_INIT_CLIENT_ID,
          password=settings.APP_INIT_CLIENT_SECRET,
      )

      return AsyncFHIRClient(
          f"{settings.APP_INIT_URL}{prefix}",
          authorization=basic_auth.encode(),
          dump_resource=lambda x: x.model_dump(),
      )
  ```

  After that, you can use `app[ak.fhir_client]` that has the type `AsyncFHIRClient` everywhere where the app is available.



  ```python
  from aidbox_python_sdk.types import SDKOperation, SDKOperationRequest

  schema = {
      "required": ["params", "resource"],
      "properties": {
          "params": {
              "type": "object",
              "required": ["abc", "location"],
              "properties": {"abc": {"type": "string"}, "location": {"type": "string"}},
              "additionalProperties": False,
          },
          "resource": {
              "type": "object",
              "required": ["organizationType", "employeesCount"],
              "properties": {
                  "organizationType": {"type": "string", "enum": ["profit", "non-profit"]},
                  "employeesCount": {"type": "number"},
              },
              "additionalProperties": False,
          },
      },
  }


  @sdk.operation(["POST"], ["Organization", {"name": "id"}, "$update"], request_schema=schema)
  async def update_organization_op(_operation: SDKOperation, request: SDKOperationRequest):
      location = request["params"]["location"]
      return web.json_response({"location": location})
  ```


  ```shell
  POST /Organization/org-1/$update?abc=xyz&location=us

  organizationType: non-profit
  employeesCount: 10
  ```

rpm_license:
  MIT License  Copyright (c) 2019 Ilya Beda  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: 1071b48fdb3a1f554afdf5f815f88fb3ca5bb5578be4b66a4f465b83f8dcc8de
name: python-aidcraftbr
arch: src
version: 0.0.12.6
epoch: 0
release: 1
summary: A small example package
url: https://github.com/pypa/sampleproject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aidcraftbr-0.0.12.6-1.src.rpm
checksum_type: sha256
description:
  to use the bot resources import bot_resources
  functions are:
  * stopWatch: converts seconds into days hours minuts and seconds


pkgId: 6a6e9340d24a8190a855d5758d6656b829f4e8cec9f23f2989ce458d3041ecc5
name: python-aidd-codebase
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: High-level codebase for deep learning development in drug discovery.
url: https://github.com/aidd-msca/aidd-codebase
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aidd-codebase-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/aidd-codebase)
  ![PyPI](https://img.shields.io/pypi/pyversions/aidd-codebase)
  ![PyPI](https://img.shields.io/github/license/aidd-msca/aidd-codebase)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1jlyEd1yxhvFCN82YqEFI82q2n0k_y06F?usp=sharing)

  A high-level codebase for deep learning development in drug discovery applications using PyTorch-Lightning.



  The codebase requires the following additional dependencies
  - CUDA >= 11.4
  - PyTorch >= 1.9
  - Pytorch-Lightning >= 1.5
  - RDKit
  - Optionally supports: tensorboard and/or wandb




  The codebase can be installed from PyPI using `pip`, or your package manager of choice, with

  ```bash
  $ pip install aidd-codebase
  ```



  1. __*Configuration*__: The coding framework has a number of argument dataclasses in the file *arguments.py*. This file contains all standard arguments for each of the models. Because they are dataclasses, you can easily adapt them to your own needs.
  <br>
  Does your Seq2Seq adaptation need an extra argument? Import the Seq2SeqArguments from arguments.py, create your own dataclass which inherits it and add your extra argument. <br> <br>
  *It is important to note that the order of supplying arguments to a script goes as follows:* <br>
  - --flags override config.yaml <br>
  - config.yaml overrides default values in arguments.py <br>
  - default values from arguments.py are used when no other values are supplied<br>
  At the end, it stores all arguments in config.yaml
  <br><br>

  2. __*Use*__: The coding framework has four main parts: <br>
  - utils
  - data_utils
  - models
  - interpretation

  These parts should be used
  &nbsp;

  3. __*File Setup*__: The setup of the files in the system is best used as followed:<br>
  coding_framework<br>
  |-- ..<br>
  ESR X<br>
  |-- project 1<br>
    |-- data<br>
      |-- ..<br>
    |-- Arguments.py<br>
    |-- config.yaml<br>
    |-- main.py<br>
    |-- datamodule.py<br>
    |-- pl_framework.py<br>



  All fellows of the AIDD consortium have contributed to the packaged.



  Everyone interacting in the codebase, issue trackers, chat rooms, and mailing lists is expected to follow the [PyPA Code of Conduct](https://www.pypa.io/en/latest/code-of-conduct/).


pkgId: 8c864c889b05d48b573d8daef24fdc5e720e9d14c9b3ae52beab3ed27d2bb3b0
name: python-aiddl-core
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Core Library for the AI Domain Definition Language (AIDDL) Framework for Integrative AI
url: http://www.aiddl.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiddl-core-0.3.7-1.src.rpm
checksum_type: sha256
description:
  This is the Python implementation of the AIDDL Core Library.

  It provides everything needed for

  - Parsing AIDDL files
  - Working with containers and modules
  - Creating terms and types
  - Evaluating terms and types
  - Default functions for evaluation





  - Fixed issue in container method `get_processed_value`



  - Fixed initialization error for string term



  - AIDDL files now packaged in sdist and bdist



  - Refactored parser
  - Added aiddl resource module containing .aiddl files to remove dependency on AIDDL_PATH environment variable
  - Modules loaded from symbolic terms now need to be in a path that follows their name
    - Example: `x.y.z` must be in a file `x/y/z.aiddl` in any known path
  - Python modules can be added as path sources for .aiddl files to the new `Parser` class.
    - For example: `parser = Parser(c, aiddl_modules=[a, b, c])` assumes `a`, `b`, and `c` are python modules


pkgId: c6f7240a5bdd3afb19feee013326824ec8ae4a5ef9ce7f623cbffb32fa5f0477
name: python-aidebug
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: AI Coding Assistant Shell
url: https://pypi.org/project/aidebug/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aidebug-0.1.6-1.src.rpm
checksum_type: sha256
description:
  ![Alt Text](./images/AIDebug_Help_Menus.png)

  AIDebug Console is a Python-based command line application that leverages the power of OpenAI's GPT models to assist with debugging and developing software projects. It provides a user-friendly interface for interacting with your codebase, running your project, and even debugging your code with the help of AI.



  - **Project Management**: Select and deselect project files and directories.
  - **Project Configuration**: Configure specific project details such as language, type, framework, and run command.
  - **Code Execution**: Run your project directly from the console. (Automatically catches errors and asks user if they want to debug)
  - **AI Debugging**: Debug your project with the help of OpenAI's GPT Models.
  - **AI Feature Request**: Request a feature for your project from OpenAI's GPT Models.
  - **AI Code Documentation**: Get a README.md file for your project's GitHub repository.





  ```bash
  pip install aidebug
  ```



  1. Clone the repository to your local machine.
  2. Navigate to the project directory.
  3. Install the required Python packages using pip:

  ```bash
  pip install setuptools wheel
  ```
  4. Build the project with setup.py:

  ```bash
  python setup.py sdist bdist_wheel
  ```
  5. Change directory to the built project:

  ```bash
  cd dist
  ```
  6. Install the built .whl file with pip:

  ```bash
  pip install aidebug-0.0.8-py3-none-any.whl
  ```



  1. Set the necessary environment variables. You need to provide your OpenAI API key:

  ```bash
  export OPENAI_API_KEY=your_openai_api_key
  ```

  2. Run the project:

  ```bash
  aidebug
  ```

  3. Use the `help` command to see a list of available commands.



  - `OPENAI_API_HOST`: The API host for OpenAI. Default is `https://api.openai.com`.
  - `OPENAI_API_KEY`: Your OpenAI API key.


  Here is a brief explanation of the commands available in the AIDebug Console:

  - `cd <directory>`: Change the current working directory.
  - `exit`: Exit the AIDebug Console.
  - `project select`: Select project files and directories.
  - `project deselect`: Unselect files and directories by id.
  - `project run`: Run the project.
  - `project files paths`: Prints selected files paths.
  - `project files contents`: Prints selected files path and contents.
  - `config project language <language>`: Set the programming language of your project.
  - `config project type`: Set the type of your project.
  - `config project framework`: Set the framework that your project is using.
  - `config project run <command>`: Set the command used to run your project.
  - `config openai model <model>`: Set the OpenAI model to be used.
  - `config openai temperature <temperature>`: Set the OpenAI model's temperature.
  - `debug <error>`: Debug your project with the help of OpenAI's GPT Models.
  - `feature <feature_request>`: Request a feature for your project from OpenAI's GPT Models.
  - `readme <optional_message>`: Request a README.md file for your project's GitHub repository from OpenAI's GPT Models.

  Remember to replace `<directory>`, `<language>`, `<command>`, `<model>`, `<temperature>`, `<error>`, `<feature_request>`, and `<optional_message>` with your actual values.



  AIDebug Console allows you to run native system commands directly from the shell. Simply input the desired command, and it will be executed in the console.

  For example, to list the files in the current directory, you can use the command `ls`:

  ```
  > ls
  ```

  This feature provides flexibility and convenience for running various system tasks alongside your project debugging and development.



  This project has borrowed code from [TheR1D's shell_gpt project](https://github.com/TheR1D/shell_gpt/blob/main/sgpt/client.py). I would like to express my gratitude for the contribution to the open-source community which has greatly aided the development of this project.



  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.



  This project is licensed under the GNU v3 GPL-3.0 License. See the [LICENSE](LICENSE) file for details.


pkgId: 47c4c5e63598a0008550c430880877c6d0a5b4ba7a55801d19fc0f365ae94b35
name: python-aider-chat
arch: src
version: 0.56.0
epoch: 0
release: 1
summary: Aider is AI pair programming in your terminal
url: https://github.com/paul-gauthier/aider
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aider-chat-0.56.0-1.src.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:

  ```
  python -m pip install 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/paul-gauthier/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/paul-gauthier/aider/issues/124)
  - *What an amazing tool. It's incredible.* -- [valyagolev](https://github.com/paul-gauthier/aider/issues/6#issue-1722897858)
  - *Aider is such an astounding thing!* -- [cgrothaus](https://github.com/paul-gauthier/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/paul-gauthier/aider/issues/112#issuecomment-1637429008)
  - *Amazing project, definitely the best AI coding assistant I've used.* -- [joshuavial](https://github.com/paul-gauthier/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: 2a93b30777186e919708b83a9d92349b97d0ea0d83a3e7b4e53cae7ac0c81e2c
name: python-aider-chat
arch: src
version: 0.62.1
epoch: 0
release: 1
summary: Aider is AI pair programming in your terminal
url: https://github.com/Aider-AI/aider
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aider-chat-0.62.1-1.src.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:

  ```
  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: 083f6a92107b605c23e32485ec056b875964c79aef3cde3c9f872ba58aceb965
name: python-aidial-interceptors-sdk
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Framework for creating interceptors for AI DIAL
url: https://epam-rail.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aidial-interceptors-sdk-0.2.0-1.src.rpm
checksum_type: sha256
description:
  > [!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: 6e85649dcb10d8001088e05dd59f0bf003adeffb5010fbc759a07e48953e0d84
name: python-aidial-sdk
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Framework to create applications and model adapters for AI DIAL
url: https://epam-rail.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aidial-sdk-0.14.0-1.src.rpm
checksum_type: sha256
description:
  Framework to create applications and model adapters for [AI DIAL](https://epam-rail.com).

  Applications and model adapters implemented using this framework will be compatible with [AI DIAL API](https://epam-rail.com/dial_api) that was designed based on [Azure OpenAI API](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference).



  Install the library using [pip](https://pip.pypa.io/en/stable/getting-started):

  ```sh
  pip install aidial-sdk
  ```



  The echo application example replies to the user by repeating their last message:

  ```python

  import uvicorn

  from aidial_sdk import DIALApp
  from aidial_sdk.chat_completion import ChatCompletion, Request, Response



  class EchoApplication(ChatCompletion):
      async def chat_completion(
          self, request: Request, response: Response
      ) -> None:
          
          last_user_message = request.messages[-1]

          
          with response.create_single_choice() as choice:
              
              choice.append_content(last_user_message.text())



  app = DIALApp()
  app.add_chat_completion("echo", EchoApplication())


  if __name__ == "__main__":
      uvicorn.run(app, port=5000)
  ```



  ```sh
  python3 app.py
  ```



  Send the next request:

  ```sh
  curl http://127.0.0.1:5000/openai/deployments/echo/chat/completions \
    -H "Content-Type: application/json" \
    -H "Api-Key: DIAL_API_KEY" \
    -d '{
      "messages": [{"role": "user", "content": "Repeat me!"}]
    }'
  ```

  You will see the JSON response as:

  ```json
  {
      "choices":[
          {
              "index": 0,
              "finish_reason": "stop",
              "message": {
                  "role": "assistant",
                  "content": "Repeat me!"
              }
          }
      ],
      "usage": null,
      "id": "d08cfda2-d7c8-476f-8b95-424195fcdafe",
      "created": 1695298034,
      "object": "chat.completion"
  }
  ```



  This project uses [Python>=3.8](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).



  |Variable|Default|Description|
  |---|---|---|
  |DIAL_SDK_LOG|WARNING|DIAL SDK log level|



  Run the linting before committing:

  ```sh
  make lint
  ```

  To auto-fix formatting issues run:

  ```sh
  make format
  ```



  Run unit tests locally for available python versions:

  ```sh
  make test
  ```

  Run unit tests for the specific python version:

  ```sh
  make test PYTHON=3.11
  ```



  To remove the virtual environment and build artifacts run:

  ```sh
  make clean
  ```



  To build the package run:

  ```sh
  make build
  ```



  To publish the package to PyPI run:

  ```sh
  make publish
  ```


pkgId: 5d0e6869e502d22473dbf5f436dee5942eb35d9ba99b00e5b06937c140c43c3d
name: python-aidkit-client
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: aidkit for your CI/CD and j-notebooks.
url: https://pypi.org/project/aidkit-client/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aidkit-client-0.11.0-1.src.rpm
checksum_type: sha256
description:
  ![aidkit](https://www.neurocat.ai/wp-content/uploads/2018/11/addkit-hori.png)

  aidkit is an MLOps platform that allows you to assess and defend against threads
  and vulnerabilities of AI models before they deploy to production.
  aidkit-client is a companion python client library to seamlessly integrate with
  aidkit in python projects.


pkgId: 56e29712112d69c616bb2fb718a54dbeb444fd6effa655ab18733c9fd59c19bf
name: python-aids
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Client for AI Dynamic Storytelling Services.
url: https://github.com/Moist-Cat/AIDScrapper
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aids-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Based off a small script made by an Anonymous user. Now it's a full featured client which supports not only [AID][0] but also [Holo][0]. Alternatively, it can transform AID scenario objects in .scenario files for compatibility with the different AI Dynamic Storytelling platforms, specially [NAI][2]
  The json files can be transformed into .html for better readability although that's not the main purpose of this tool - you should upload it to one of the supported websites to use the stories.


  To install all requirements, use the following snippet after installing python on your machine.

      pip install -r requirements.txt

  Or just use:

      pip install aids



  To install the whole thing. You can manage it directly from console. Use:

      aids help

  Afterwards for a list of commands or:

      aids-windows.bat help

  If you use Windows.

  You can also use the package directly via:

      python3 -m aids help

  Or in outside the package directory with:

      python aids/manage.py help


  If you feel like messing around with the code make sure none of the tests are failing using the *test* command. It uses pytest if you have it installed or unittest as a fallback.

  [0]: https://play.aidungeon.io
  [1]: https://www.writeholo.com
  [2]: https://novelai.net/


pkgId: 70b8d8a7681d0d8fa2350a42f9d22f783b9725bd6dcdd9f01b828589045a6025
name: python-aif360
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: IBM AI Fairness 360
url: https://github.com/Trusted-AI/AIF360
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aif360-0.6.1-1.src.rpm
checksum_type: sha256
description:
  The AI Fairness 360 toolkit is an open-source library to help detect and mitigate bias in machine
  learning models. The AI Fairness 360 Python package includes a comprehensive set of metrics for datasets and models to
  test for biases, explanations for these metrics, and algorithms to mitigate bias in datasets and models.

  We have developed the package with extensibility in mind. This library is still in development. We encourage the
  contribution of your datasets, metrics, explainers, and debiasing algorithms.


pkgId: 719b78da0ce6caad54a6408adda3f45557529c46a42e8fd36ee16a7300f7eac0
name: python-aiffel7
arch: src
version: 0.6.11
epoch: 0
release: 1
summary: A simple Python library
url: https://github.com/dudnjsckrgo/aiffel7_library
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiffel7-0.6.11-1.src.rpm
checksum_type: sha256
description:
  - 패키지 설치

  ```pip install --upgrade aiffel7```

  - example 폴더에서 사용법 확인하기

  구현된 함수에대한 문서들이 들어있습니다.



  - pull request로 패키지에 포함할 파일을  aiffel7 폴더에 추가
  - 코드 상단에 기여자 적기(날짜 생략 가능)
  ```python




  ```
  - example folder에 사용법 작성


  - issues 에서 새로운 이슈 만들기
      라이브러리 구현이 되었으면 좋은 것들 문의를 하거나, 라이브러리에 문제가 있다면 알려주시면 됩니다.


pkgId: cbab8f5f9d24afa591e0c207d7a85ce6d2c1838c7d15d3fb183560aff5b17dca
name: python-aiflows
arch: src
version: 1.1.1
epoch: 0
release: 1
url: https://pypi.org/project/aiflows/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiflows-1.1.1-1.src.rpm
checksum_type: sha256
summary:
  aiFlows implements the abstraction of Flows proposed in "Flows: Building Blocks of Reasoning and Collaborating AI" and greatly simplifies the design and implementation of complex (work)Flows involving humans, AI systems, and tools.

description:
  <p align="center">
        <br/>
              <img src="assets/logo_text_statement_alt_rounded_corners.png" alt="image" width="600" height="auto">
        <br/>
  <p>

  <p align="center">
      <a href="https://epfl-dlab.github.io/aiflows">
      <img alt="Website" src="https://img.shields.io/badge/website-online-green">
      </a>
      <a href="https://discord.gg/yFZkpD2HAh">
      <img alt="Static Badge" src="https://img.shields.io/badge/Discord-gray?style=flat&logo=discord&link=https%3A%2F%2Fdiscord.gg%2FNJuDxSafCY">
      </a>
      <a href="https://epfl-dlab.github.io/aiflows/docs/built_with_sphinx/html/index.html">
      <img alt="Documentation" src="https://img.shields.io/badge/docs-online-green">
      </a>
      <a href="https://www.python.org/downloads/release/python-3100/"><img alt="PyPi version" src="https://img.shields.io/badge/python-3.10-blue.svg"></a>
      <a href="https://arxiv.org/abs/2308.01285">
      <img alt="Documentation" src="https://img.shields.io/badge/arXiv-2308.01285-b31b1b.svg">
      </a>
  </p>

  > 📢
  > Major update: We’re excited to announce the release of version 1.1.0 of our project! This release introduces significant enhancements to aiFlows, highlighted by the introduction of the Flows engine. This engine empowers concurrent execution and peer-to-peer distributed collaboration, revolutionizing the way you interact with your projects.
  >
  > We are still polishing some aspects of the developer experience, so share your feedback on [Discord](https://discord.gg/yFZkpD2HAh)!


  🤖🌊 **aiFlows** embodies the [*Flows*](https://arxiv.org/abs/2308.01285) abstraction and greatly simplifies the design and implementation of complex (work)Flows involving humans, AI systems, and tools. In collaboration with [CoLink](https://github.com/CoLearn-Dev/colink-server-dev), it enables:

  - 🧩 Modularity: Flows can be stacked like LEGO blocks into arbitrarily nested structures with the complexity hidden behind a message-based interface
  - 🤝 Reusability: Flows shared on the FlowVerse can be downloaded and tailor-fitted to your needs
  - 🕸 Remote Peer-to-Peer Collaboration: Flows can readily engage in a peer-to-peer collaboration with other remote Flows that could run anywhere
  - 🔀 Concurrency: Flows can readily implement concurrent execution (e.g., a Flow being invoked by multiple Flows or a Flow invoking multiple Flows concurrently) –– without *any* additional complexity


  The library is compatible with Python 3.10+.

  ```shell
  pip install aiflows
  ```

  <details>
    <summary>Other installation options</summary>



  ```shell
  git clone git@github.com:epfl-dlab/aiflows.git
  cd aiflows
  pip install -e .
  ```
  </details>



  The framework is centered around *Flows* and *messages*.
  Flows are independent, self-contained, goal-driven computational building blocks that can complete semantically meaningful units of work.
  To exchange information, Flows communicate via a standardized message-based interface. Messages can be of any type the recipient Flow can process.
  <p align="center">
        <img src="assets/fig1_rounded_corners.png" alt="image" width="1000" height="auto">
        <p align="justify">
        <strong>The <em>Flows</em> framework exemplified.</strong> The first column depicts examples of tools. Notably, in the Flows framework, AI systems correspond to tools. The second column depicts Atomic Flows, effectively minimal wrappers around tools constructed from the example tools. The third column depicts examples of Composite Flows defining structured interaction between <em>Atomic</em> or <em>Composite</em> Flows. The fourth column illustrates a specific <em>Composite</em> competitive coding Flow as those used in the experiments in the paper. The fifth column outlines the structure of a hypothetical Flow, defining a meta-reasoning process that could support autonomous behavior.
        </p>
  <p>


  The FlowVerse is a repository of Flows (powered by the 🤗 HuggingFace hub) created and shared by our community for everyone to use! With aiFlows, Flows can be readily downloaded, used, extended, or composed into novel, more complex Flows. For instance, sharing a Flow that uses only API-based tools (tools subsume models in the Flows abstraction) is as simple as sharing a config file (e.g., [here](https://huggingface.co/aiflows/AutoGPTFlowModule) is the AutoGPT Flow on FlowVerse). For the ones using ChatGPT, you could think of them as completely customizable open-source GPTs(++).

  The FlowVerse is continuously growing. To explore the currently available Flows, check out the 🤲│flow-sharing Forum on the Discord [server](https://discord.gg/yFZkpD2HAh). Additionally, the _Tutorials_ and _Detailed Examples_ in the [Getting Started](https://epfl-dlab.github.io/aiflows/docs/built_with_sphinx/html/getting_started/index.html) sections cover some of the Flows we provide in more detail (e.g., the ChatAtomicFlow and QA, VisionAtomicFlow and VisualQA, ReAct and ReAct with human feedback, AutoGPT, etc.).


  AI is set to revolutionize the way we work. Our mission is to support AI researchers and to allow them to seamlessly share advancements with practitioners. This will establish a feedback loop, guiding progress toward beneficial directions while ensuring that everyone can freely access and benefit from the next-generation AI tools.



  - The ability to design, implement, and study arbitrarily complex interactions -- even interactions that require concurrent execution or remote collaboration
  - Complete control and customizability (e.g., the tools, the specific Flows and the information they have access to, the choice of models and their deployment, etc.)


  - The ability to readily reproduce, reuse, or build on top of Flows shared on the FlowVerse and systematically study them across different settings (the infrastructure in the <a href="https://github.com/epfl-dlab/cc_flows">cc_flows</a> repository could be a useful starting point in future studies)
  - The ability to readily make your work accessible to practitioners and other researchers and access their feedback.


  - The ability to readily reuse or build on top of Flows shared on the FlowVerse
  - The ability to readily give access to your Flows to others
  - Direct access to any advancements in the field.

  To develop the next-generation AI tools, we will need a principled abstraction that supports concurrent execution and peer-to-peer remote collaboration. At the same time, to maximize their benefits, developers and researchers will need to have complete control over their workflows. aiFlows strives to empower you to make each Flow your own! See the [contribute](#contribute) section for more information.





  Here, you'll see how you can run inference with your first question-answering Flow, and you can trivially change between vastly different question-answering Flows thanks to the modular abstraction and FlowVerse!



  In this tutorial, we introduce you to the library's features through a walkthrough of how to build useful Flows of gradually increasing complexity.



  We are constantly optimizing our Flow development workflow (pun intended:). In this short guide, we share our best tips so that you don't have to learn the hard way.



  Many of the recently proposed prompting and collaboration strategies involving tools, humans, and AI models are, in essence, specific Flows (see the figure below). In the links above, you'll find a detailed walkthrough of how to build some representative workflows.

  <p align="center">
        <img src="assets/previous_flows_rounded.png" alt="image" width="1000" height="auto">
        <p align="justify">
  <p>



  Check out the examples folder for more examples of how to build and use aiFlows.



  As mentioned above, our goal is to make Flows a community-driven project that will benefit researchers and developers alike (see the [Why should I use aiFlows?](#why-should-i-use-aiflows) section), and to achieve this goal, we need your help.

  You can become a part of the project in a few ways:
  - contribute to the aiFlows codebase: this will directly improve the library and benefit everyone using it
  - contribute to the FlowVerse: by making your work accessible to everyone, others might improve your work and build on it, or you can build on others' work
  - use the library in your creative projects, push it to its limits, and share your feedback: the proof of the pudding is in the eating, and the best way to identify promising directions, as well as important missing features, is by experimenting
  - last but not least, ⭐ the repository and 📣 share aiFlows with your friends and colleagues; spread the word ❤️


  We have tried to find a way for anyone to benefit by contributing to the project. The <a href="https://epfl-dlab.github.io/aiflows/docs/built_with_sphinx/html/contributing_info/contribute_index.html">Contribution Guide</a> describes our envisioned workflows in more detail (we would love to hear your feedback on this -- the Discord [server](https://discord.gg/yFZkpD2HAh) already has a channel for it :)).

  In a nutshell, this is just the beginning, and we have a long way to go. Stay tuned, and let's work on a great (open-source) AI future together!




  If you found this work useful, please cite it as:

  ```
  @misc{josifoski2023flows,
        title={Flows: Building Blocks of Reasoning and Collaborating AI},
        author={Martin Josifoski and Lars Klein and Maxime Peyrard and Baldwin Nicolas and Yifei Li and Saibo Geng and Julian Paul Schnitzler and Yuxing Yao and Jiheng Wei and Debjit Paul and Robert West},
        year={2023},
        eprint={2308.01285},
        archivePrefix={arXiv},
        primaryClass={cs.AI}
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2023 EPFL Data Science Lab (dlab)  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: 38f218ca1da4005b85b80399b84b1418e9957dfa471b5567f86702b44d50e069
name: python-aift
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: AI for Thai Python Package
url: https://github.com/AIforThai/aiforthai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aift-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Piyawat Chuangkrud


  ```bash
  pip install aift
  ```



  ```python
  from aift import setting

  setting.set_api_key('YOUR_API_KEY')
  ```



  ```python
  from aift.multimodal import textqa

  textqa.generate('ข้อความ')
  ```

  ```python
  from aift.multimodal import audioqa

  audioqa.generate('audio.mp3', 'ถอดเสียงข้อความ')
  ```

  ```python
  from aift.multimodal import vqa

  vqa.generate('image.jpg', 'บรรยายรูปนี้')
  ```




  ```python
  from aift.nlp.alignment import en_alignment

  en_alignment.analyze("en_text", 'th_text', return_json=True)
  ```

  ```python
  from aift.nlp.alignment import zh_alignment

  zh_alignment.analyze("zh_text", 'th_text')
  ```


  ```python
  from aift.nlp import g2p

  g2p.analyze('ข้อความ')
  ```


  ```python
  from aift.nlp.longan import sentence_tokenizer

  sentence_tokenizer.tokenize('ข้อความ')
  ```

  ```python
  from aift.nlp.longan import tagger

  tagger.tag('ระบุ|ข้อความ|ใน|นี้')
  ```

  ```python
  from aift.nlp.longan import token_tagger

  token_tagger.tokenize_tag('ข้อความ')
  ```

  ```python
  from aift.nlp.longan import tokenizer

  tokenizer.tokenize('ข้อความ')
  ```


  ```python
  from aift.nlp import ner

  ner.analyze('ข้อความ')
  ```


  ```python
  from aift.nlp import qa

  qa.analyze('ข้อความ')
  ```


  ```python
  from aift.nlp import sentiment

  sentiment.analyze('ข้อความ') # engine = ssense, emonews, thaimoji, cyberbully
  ```
  ```python
  sentiment.analyze('ข้อความ', engine='emonews')
  ```
  ```python
  sentiment.analyze('ข้อความ', engine='thaimoji')
  ```
  ```python
  sentiment.analyze('ข้อความ', engine='cyberbully')
  ```


  ```python
  from aift.nlp import similarity

  similarity.similarity('ข้อความ') # engine = thaiwordsim, wordapprox
  ```
  ```python
  similarity.similarity('ข้อความ', engine='thaiwordsim', model='thwiki') # model = thwiki, twitter
  ```
  ```python
  similarity.similarity('ข้อความ', engine='wordapprox', model='food', return_json=True) # model = personname, royin, food
  ```


  ```python
  from aift.nlp import soundex

  soundex.analyze('ชื่อ') # model = personname, royin
  ```


  ```python
  from aift.nlp import tag

  tag.analyze('ข้อความ', numtag=5)
  ```


  ```python
  from aift.nlp import text_cleansing

  text_cleansing.clean('ข้อความ')
  ```


  ```python
  from aift.nlp import text_sum

  text = """
  long text
  """

  text_sum.summarize(text)
  ```


  ```python
  from aift.nlp import tokenizer

  tokenizer.tokenize('ข้อความ')
  ```
  ```python
  tokenizer.tokenize('ข้อความ', return_json=True)
  ```
  ```python
  tokenizer.tokenize('ข้อความ', engine='trexplusplus') # engine = lexto, trexplus, trexplusplus
  ```


  ```python
  from aift.nlp.translation import en2th

  en2th.translate("en_text")
  ```

  ```python
  from aift.nlp.translation import th2en

  th2en.translate("ข้อความ")
  ```

  ```python
  from aift.nlp.translation import th2zh
  th2zh.translate('ข้อความ', return_json=True)
  ```

  ```python
  from aift.nlp.translation import zh2th
  zh2th.translate('你的微笑真好看。', return_json=True)
  ```




  ```python
  from aift.image.classification import chest_classification

  chest_classification.analyze('image.jpg', return_json=True)
  ```

  ```python
  from aift.image.classification import maskdetection

  maskdetection.analyze('image.jpg')
  ```

  ```python
  from aift.image.classification import nsfw

  nsfw.analyze('image.jpg')
  ```

  ```python
  from aift.image.classification import violence_classification

  violence_classification.analyze('image.jpg')
  ```



  ```python
  from aift.image.correlator import correlator

  correlator.analyze('image.jpg', arr='คน', num=1)
  ```


  ```python
  from aift.image.detection import carlogo

  carlogo.analyze('image.jpg',  return_json=True)
  ```

  ```python
  from aift.image.detection import face_blur

  face_blur.analyze('image.jpg')
  ```

  ```python
  from aift.image.detection import face_detection

  face_detection.analyze('image.jpg', return_json=True)
  ```

  ```python
  from aift.image.detection import handwritten

  handwritten.analyze('image.jpg')
  ```

  ```python
  from aift.image.detection import lpr

  lpr.analyze('image.jpg', crop=0, rotate=1)
  ```

  ```python
  from aift.image.detection import weapon_detection

  weapon_detection.analyze('image.jpg')
  ```


  ```python
  from aift.image.dicom2image import dicom2image

  dicom2image.analyze('image.dcm')
  ```


  ```python
  from aift.image import super_resolution

  super_resolution.analyze('image.jpg')
  ```


  ```python
  from aift.image import thaifood

  thaifood.analyze('image.jpg')
  ```



  ```python
  from aift.speech import tts

  tts('สวัสดีครับ', 'file.wav')
  ```

  ```python
  from aift.speech import stt

  stt('file.wav', return_json=True)
  ```


pkgId: e33c053e46aef0976573f2041d36cff6f8a2d7d7c00245137f59ce1725cbec2c
name: python-aigents
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: Adapters for Large Language Models and Generative Pre-trained Transformers APIs
url: https://github.com/bessavagner/aigents.git
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aigents-0.12.0-1.src.rpm
checksum_type: sha256
description:
  Adapters for Large Language Models and Generative Pre-trained Transformers APIs





  ```bash
  python -m pip install aigents
  ```



  The `aigents` package intention is to tackle the issue of out there having a wide variety of different AI models APIs, even though most of them keep similar standards, it might be confusing or challeging for developers to merge, scale and write conssitent solutions that englobes them.



  The main classes for completions or chat have _Chatters_ on their name. For instance, `aigents.GoogleChatter` uses Google's AI completion models to generate chat responses. The method for calling responses is `answer`.

  The constructors for _Chatters_ differs a little, but on thing in common on them is the `setup` (`str`) argument: a text instructing the AI model to play some role. For example:

  ``` python
  from aigents import GoogleChatter

  setup = "You are a very experienced and successful fantasy novel writer. "

  api_key = "YOUR_GOOGLE_AI_API_KEY"
  temperature = 0.5  # for creativity
  chatter = GoogleChatter(setup=setup, api_key=api_key)

  response = chatter.answer(
      "What are the difference between soft magic system "
      "and hard magic system?"
  )
  ```

  The returned value is a string corresponding on the first [candidate response from Gemini API](https://ai.google.dev/api/python/google/generativeai/GenerativeModel#generate_content), which you can access using the attribute `chatter.last_response`.

  For `OpenAI` and `Google` chatters you can the the API key using `.env` file. Use the `.sample.env`: paste your API keys and save it as `.env`



  By default, `chatter.answer` has `conversation=True` for every _Chatter_. This means that the object keeps a record of the messages (conversation), which you can access using the attribute `chatter.messages`.

  If the messages exceeds the token window allowed for the corresponding model, the instance will try to reduce the size of the messages. If the default values of `use_agent=True` is set for `chatter.answer`, the _Chatter_  will use another instance to summarize messages, in order to preserve most of the history and meaning of the conversation. Otherwise it will remove the oldest (but the `chatter.setup`, if provided) messages.

  This section provides a brief overview of the classes in `core.py` and their usage.



  Every chatter have an async version. For instance, the previous code can be written using async version of the OpenAI's chatter:

  ``` python
  from aigents import AsyncOpenAIChatter

  setup = "You are a very experienced and successful fantasy novel writer. "

  api_key = "YOUR_OPEN_AI_API_KEY"
  temperature = 0.5  # for creativity
  chatter = AsyncOpenAIChatter(setup=setup, api_key=api_key)

  response = await chatter.answer(
      "What are the difference between soft magic system "
      "and hard magic system?"
  )
  ```



  * **AsyncGoogleChatter**: async version of `GoogleChatter`;
  * **GoogleVision**: agent for image chat (<span style="color: #b04e27;">Important</span>: gemini-pro-vision does not generate images as for this date);
  * **AsyncGoogleVision**: async version of `GoogleVision`
  * **OpenAIChatter**: chatter that uses OpenAI's API;
  * **BingChatter**: uses the uses [g4f](https://github.com/xtekky/gpt4free/tree/main) adpter, with `Bing` provider;
  * **AsyncBingChatter**: async version of `BingChatter`.



  You can check different AI models used by `aigents` in module `constants`. For instance, for changing OpenAI chatter's model from `gpt-3.5-turbo-0125` to `gpt-4-0125-preview`:

  ```python
  from aigents import OpenAIChatter
  from aigents.constants import MODELS

  api_key = "YOUR_OPEN_AI_API_KEY"
  chatter = OpenAIChatter(setup=setup, api_key=api_key)
  chatter.change_model(MODELS[4])  # gpt-4o-mini

  print(chatter.model)
  ```



  The `Context` class in `aigents` provides functionality for generating embeddings from a source and generating a context based on a question. This is particularly useful for contextual chat applications.



  To generate embeddings from a source, you can use the `generate_embeddings` method. This method supports generating embeddings from a string, a pandas DataFrame, a Path to a parquet file containing embeddings, or a dictionary containing 'chunks'of text, 'n_tokens' corresponding to the number of tokens, counted using tiktoken library, and 'embeddings' which are numpy arrays of the encoded chunks as embeddings.

  Here's an example of how to use the `generate_embeddings` method:

  ```python
  import asyncio
  from aigents import Context

  async def get_embeddings_dataframe(text):

      
      context = Context(text=text)
      
      return await context.generate_embeddings(embedding_model='gemini')

  text = ''
  with open('path/to/your/text', 'r') as textfile:
      text = textfile.read()
  data = asyncio.run(get_embeddings_dataframe(text))

  print(data)
  ```

  Here we use the Google's Gemini embedding generator. Note that you'll have to set your Gemini's API key in yur environment variables. Alternatively you can pass the api key as the argument `api_key` in `generate_embeddings` method.

  Currently, embeddings generation via `Context` is only possible using async paradigm. This type of choice is due to the underperform of when using large texts, since each chunk of text corresponds to one api call, so it's better to make asynchronous calls.

  After context generation, you can extract only relevant chunks based on a given *query*:


  ```python
  import asyncio
  from aigents import Context

  async def get_relevant_chunks(question, text):
      embedding_model = 'gemini'
      pipeline = 'en_core_web_md'
      
      context = Context(text=text)
      
      await context.generate_embeddings(embedding_model=embedding_model)
      return await context.generate_context(
          question,
          pipeline=pepiline
      )

  text = ''
  with open('path/to/your/text', 'r') as textfile:
      text = textfile.read()

  question = 'What is this article about?'
  relevant_data = asyncio.run(get_relevant_chunk(question, text))

  print(relevant_data)
  ```

  You'll have to install the corresponding [spacy pipeline](https://github.com/explosion/spacy-models/releases). For instance, if your text is in portuguese, you'd want to install `pt-core-news-sm` or `pt-core-news-md`:

  ```bash
  python -m spacy install pt-core-news-md
  ```

  Than pass the value to the argument `pipeline` of the `generate_context` method.



  Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.



  This project is licensed under [GNU_GPL_v3.0](https://github.com/xtekky/gpt4free/blob/main/LICENSE)



  `aigents` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).


pkgId: 58d2cf0f6db2f118e04cb93f7b4b15bc20af7f2cd973e37424002f8554fc8ead
name: python-aigs
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/aigs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aigs-0.0.5-1.src.rpm
checksum_type: sha256
description:
  In this course we use Python 3.11. Running `pip install aigs`
  in a clean Python 3.11 virtual environment should install all dependencies.
  We are assuming that you have a basic understanding of Python and programming.



  `labs/` contains exercises for the course, which you should do.
  Being able to do the contents of `labs/` is a prerequisite
  for being able making a successful final project.

  I recommend cloning this repository, and making a folder `my/`
  where you can put your own code (I will be updating this repository).

  1. [Lab 1: Math](labs/lab_1.py)
  2. [Lab 2: Neural networks](labs/lab_2.py)
  3. [Lab 3: Evolutionary computation](labs/lab_3.py)
  4. [Lab 4: Deep learning](labs/lab_4.py)
  5. [Lab 5: Reinforcement learning](labs/lab_5.py)



  There are three mandatory projects in this course.
  They are all under `/prjs` and are not yet completed.
  Won't make much sense to look at them until they are completed,
  as major parts will be changed and added.



  [backprob](https://colah.github.io/posts/2015-08-Backprop/)


pkgId: c11b7ea00f4edd4764d6157dcfc121fcbe07dfa4a714ff566514d1de7def4e14
name: python-aihandler
arch: src
version: 1.19.0
epoch: 0
release: 1
summary: AI Handler: An engine which wraps certain huggingface models
url: https://github.com/Capsize-Games/aihandler
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aihandler-1.19.0-1.src.rpm
checksum_type: sha256
description:
  - `AIRUNNER_ENVIRONMENT` - `dev` or `prod`. Defaults to `dev`. This controls the LOG_LEVEL
  - `LOG_LEVEL` - `FATAL` for production, `DEBUG` for development. Override this to force a log level


  These environment variables keep you offline until you need to download a model. This prevents unwanted online access and speeds up usage of huggingface libraries.
  - `DISABLE_TELEMETRY` Keep this set to 1 at all times. Huggingface collects minimal telemetry when downloading a model from their repository but this will keep it disabled. [See more info in this github thread](https://github.com/huggingface/diffusers/pull/1833#issuecomment-1368484414)
  - `HF_HUB_OFFLINE` When loading a diffusers model, huggingface libraries will attempt to download an updated cache before running the model. This prevents that check from happening (long with a boolean passed to `load_pretrained` see the runner.py file for examples)
  - `TRANSFORMERS_OFFLINE` Similar to `HF_HUB_OFFLINE` but for transformers models


pkgId: 4f4fa7f8023dc18cb0c157fd96a0817d2bf8fc95b66504d7dda7b49a20a79dab
name: python-aihive
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A multi-agent orchestration framework.
url: https://pypi.org/project/aihive/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aihive-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A general-purpose multi-agent orchestration framework.



  Requires Python 3.10+

  ```shell
  pip install aihive
  ```

  or

  ```shell
  pip install aihive
  ```



  ```python
  from aihive import Swarm, AI

  swarm = Swarm()

  def ask_queen_agent():
      return queen_agent

  worker_agent = AI(
      name="Worker AI",
      instructions="You are a helpful worker agent.",
      functions=[transfer_to_queen_agent],
  )

  queen_agent = AI(
      name="Queen AI",
      instructions="Guide your worker agents to be helpful.",
  )

  response = swarm.run(
      agent=worker_agent,
      messages=[{"role": "user", "content": "Create a motivational haiku to inspire the worker agents."}],
  )

  print(response.messages[-1]["content"])
  ```

  ```
  Hope glimmers brightly,
  New paths converge gracefully,
  What can I assist?
  ```



  This project includes code from [OpenAI Swarm](https://github.com/openai/swarm).

  - Ilan Bigio - [ibigio](https://github.com/ibigio)
  - James Hills - [jhills20](https://github.com/jhills20)
  - Shyamal Anadkat - [shyamal-anadkat](https://github.com/shyamal-anadkat)
  - Charu Jaiswal - [charuj](https://github.com/charuj)
  - Colin Jarvis - [colin-openai](https://github.com/colin-openai)
  - Katia Gil Guzman - [katia-openai](https://github.com/katia-openai)


pkgId: a5d80900bb6d9d7001e3c770ab6d4e2ab575b6d4bf47b82ad125f23078fe14e8
name: python-aihive-tools-core
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: AIHive core package
url: https://pypi.org/project/aihive-tools-core/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aihive-tools-core-0.0.4-1.src.rpm
checksum_type: sha256
description:
  Core package for the AIHive framework, providing base classes and utilities.



  ```bash
  pip install aihive-tools-core
  ```



  ```python
  from aihive_tools.core import BaseTool

  class MyTool(BaseTool):
      name = "my-tool"
      description = "My custom tool"

      def execute(self, **kwargs):
          
          pass
  ```


pkgId: 231ae8fab84986bc2be3c8639a351a01c0dc10d3e9b9aad1157602b4545be5c2
name: python-aihive-tools-duckduckgo
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: AIHive duckduckgo package
url: https://pypi.org/project/aihive-tools-duckduckgo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aihive-tools-duckduckgo-0.0.5-1.src.rpm
checksum_type: sha256
description:
  This package provides duckduckgo integration for the AIHive framework.



  ```bash
  pip install aihive-tools-duckduckgo
  ```



  ```python
  from aihive_tools.duckduckgo import DuckduckgoTool

  tool = DuckduckgoTool()
  result = tool.execute()
  ```


pkgId: e965401bbfc15873c71dacec041f2a94fde4ac14bda4d3227ea44aaedc293963
name: python-aiida-aimall
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A plugin to interface AIMAll with AiiDA
url: https://pypi.org/project/aiida-aimall/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiida-aimall-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![ci](https://github.com/kmlefran/aiida-aimall/actions/workflows/ci.yml/badge.svg)](https://github.com/kmlefran/aiida-aimall/actions/workflows/ci.yml)
  [![Coverage Status](https://coveralls.io/repos/github/kmlefran/aiida-aimall/badge.svg?branch=main)](https://coveralls.io/github/kmlefran/aiida-aimall?branch=main)
  [![Documentation Status](https://readthedocs.org/projects/aiida-aimall/badge/?version=latest)](https://aiida-aimall.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/aiida-aimall.svg)](https://badge.fury.io/py/aiida-aimall)



  A plugin to interface AIMAll with AiiDA



  * [`.github/`](.github/): [Github Actions](https://github.com/features/actions) configuration
    * [`workflows/`](.github/workflows/)
      * [`ci.yml`](.github/workflows/ci.yml): runs tests, checks test coverage and continuous integration at every new commit
      * [`publish-on-pypi.yml`](.github/workflows/publish-on-pypi.yml): automatically deploy git tags to PyPI - just generate a [PyPI API token](https://pypi.org/help/#apitoken) for your PyPI account and add it to the `pypi_token` secret of your github repository
    * [`config/`](.github/config) config files for testing/docs environment
      * [`code-aim.yaml`](.github/config/code-aim.yaml) config file for building precommit and test envs
      * [`code-gwfx.yaml`](.github/config/code-gwfx.yaml) config file for building precommit and test envs
      * [`profile.yaml`](.github/config/profile.yaml) config file for aiida profile
      * [`localhost-config.yaml`](.github/config/localhost-config.yaml) config file for localhost computer
      * [`localhost-setup.yaml`](.github/config/localhost-setup.yaml) setup file for localhost computer
  * [`aiida_aimall/`](src/aiida_aimall/): The main source code of the plugin package
    * [`data.py`](src/aiida_aimall/data.py): A new `AimqbParameters` data class, used as input to the `AimqbCalculation` `CalcJob` class
    * [`calculations.py`](src/aiida_aimall/calculations.py): A new `AimqbCalculation` `CalcJob` class
    * [`parsers.py`](src/aiida_aimall/parsers.py): Two parsers (`AimqbBaseParser` and `AimqbGroupParser`) for `AimqbCalculation` results
    * [`workchains/`](src/aiida_aimall/workchains/): New `WorkChains`.
      * [`calcfunctions.py`](src/aiida_aimall/workchains/calcfunctions.py): `calcfunction`s that are used in the workchains
      * [`input.py`](src/aiida_aimall/workchains/input.py): `BaseInputWorkChain` that is used in other workchains to validate multiple input options
      * [`param_parts.py`](src/aiida_aimall/workchains/param_parts.py): `SmilesToGaussianWorkChain` and `AIMAllReorWorkChain`: two workchains representing individual steps of the `SubstituentParameterWorkchain`
      * [`qc_programs.py`](src/aiida_aimall/workchains/qc_programs.py): `QMToAIMWorkChain` and `GaussianToAIMWorkChain` linking quantum chemical software output to an AIMQB calculation
      * [`subparam.py`](src/aiida_aimall/workchains/subparam.py): `SubstituentParameterWorkchain` to automate calculation substituent properties in a multistep calculation.
  * [`controllers.py`](src/aiida_aimall/controllers.py): Workflow controllers to limit number of running jobs on localhost computers.
    * `AimReorSubmissionController` to control `AimReorWorkChain`s. These use `parent_group_label` for the wavefunction file nodes from `GaussianWFXCalculation`s
    * `AimAllSubmissionController` to control `AimqbCalculations``. These use `parent_group_label` for the wavefunction file nodes from `GaussianWFXCalculation`s
    * `GaussianSubmissionController` to control `GaussianWFXCalculations`. This is mostly intended to have a arbitrarily large number of max concurrents and scan for output structures of `AimReorWorkchain`s to submit to a remote cluster
  * [`docs/`](docs/): Source code of documentation for [Read the Docs](http://aiida-diff.readthedocs.io/en/latest/)
  * [`tests/`](tests/): Basic regression tests using the [pytest](https://docs.pytest.org/en/latest/) framework (submitting a calculation, ...). Install `pip install -e .[testing]` and run `pytest`.
    * [`conftest.py`](tests/conftest.py): Configuration of fixtures for [pytest](https://docs.pytest.org/en/latest/)
  * [`.gitignore`](.gitignore): Telling git which files to ignore
  * [`.pre-commit-config.yaml`](.pre-commit-config.yaml): Configuration of [pre-commit hooks](https://pre-commit.com/) that sanitize coding style and check for syntax errors. Enable via `pip install -e .[pre-commit] && pre-commit install`
  * [`.readthedocs.yml`](.readthedocs.yml): Configuration of documentation build for [Read the Docs](https://readthedocs.org/)
  * [`.isort.cfg`](.isort.cfg): Configuration to make isort and black precommit actions compatible
  * [`LICENSE`](LICENSE): License for your plugin
  * [`README.md`](README.md): This file
  * [`pyproject.toml`](pyproject.toml): Python package metadata for registration on [PyPI](https://pypi.org/) and the [AiiDA plugin registry](https://aiidateam.github.io/aiida-registry/) (including entry points)




  Many of the workflows provided are specific to my field of study, but the calculations and parsers should be widely useful. Again, as many things designed here were specific to my usage, there are some quirks that must be used at this time, but as I progress with this, I'll endeavour to replace them as optional parts.

    * Many calculations and parsers store results in groups. I have used this, due to my usage of the FromGroupSubmissionController from aiida-submission-controller. I wrote for wfx files to be stored in a group in a Gaussian calculation because then a submission controller looks for wfx files in that group.
      * What this means for the general user is that currently, some nodes are going to be stored in groups, and some group labels are to be provided to certain CalcJobs
    * For similar reasons as above, many Parsers/CalcJobs add extras to the node, typically SMILES in my case
      * Some calculations then, require an extra label (frag_label or fragment_label) to be provided as input to tag the output



   * AimqbParameters Data class to validate command line parameters used to run AIMAll calculations
      ```python
      AimqbParameters = DataFactory('aimall.aimqb')
      aim_params = AimqbParameters(parameter_dict={"naat": 2, "nproc": 2, "atlaprhocps": True})
      ```
      * will check for instance, that the value supplied for naat (number of atoms at a time) is an integer.
      * Most of the options provided at [AIMQB Command Line](https://aim.tkgristmill.com/manual/aimqb/aimqb.html#AIMQBCommandLine) are defined and validated


   * Run an AIMQB calculation using a valid starting file format (WFN/WFX/FCHK as SinglefileData)
     ```python
     AimqbCalculation = CalculationFactory('aimall.aimqb')
     builder = AimqbCalculation.get_builder()
     builder.parameters = aim_params
     builder.file = SinglefileData('/absolute/path/to/file')
     
     
     submit(builder)
     ```



  Documentation is hosted at [ReadTheDocs](http://aiida-aimall.readthedocs.io/).




  ```shell
  (env) pip install aiida-aimall
  (env) verdi quicksetup  # better to set up a new profile
  (env) verdi plugin list aiida.calculations  # should now show your calclulation plugins
  ```

  If you are using `WorkChain`s that run `GaussianCalculation`s on some computers like Apple M1s, the current release v1.8.1 may result in an error in due to a space in the computer name. The master branch of cclib has been updated to fix this bug. The direct dependency is not allowed on PyPi. If you are in the situation, you can fix it by installing the current version of cclib from the master branch.

  ```shell
  (env) pip install git+https://github.com/cclib/cclib
  ```



  ```shell
  git clone https://github.com/kmlefran/aiida-aimall .
  cd aiida-aimall
  pip install --upgrade pip
  pip install -e .[pre-commit,testing]  # install extra dependencies
  pre-commit install  # install pre-commit hooks
  pytest -v  # discover and run all tests
  ```

  See the [developer guide](http://aiida-aimall.readthedocs.io/en/latest/developer_guide/index.html) for more information.



  The testing and documentation framework is heavily influenced by the infrastructure presented in [aiida-quantumespresso](https://github.com/aiidateam/aiida-quantumespresso).  Copyright (c), 2015-2020, ECOLE POLYTECHNIQUE FEDERALE DE LAUSANNE (Theory and Simulation of Materials (THEOS) and National Centre for
  Computational Design and Discovery of Novel Materials (NCCR MARVEL))



  MIT



  kgagnon@lakeheadu.ca


  [ci-badge]: https://github.com/kmlefran/aiida-aimall/workflows/ci/badge.svg?branch=master
  [ci-link]: https://github.com/kmlefran/aiida-aimall/actions
  [cov-badge]: https://coveralls.io/repos/github/kmlefran/aiida-aimall/badge.svg?branch=master
  [cov-link]: https://coveralls.io/github/kmlefran/aiida-aimall?branch=master
  [docs-badge]: https://readthedocs.org/projects/aiida-aimall/badge
  [docs-link]: http://aiida-aimall.readthedocs.io/
  [pypi-badge]: https://badge.fury.io/py/aiida-aimall.svg
  [pypi-link]: https://badge.fury.io/py/aiida-aimall


pkgId: 3447fde578e29e20fb3cb2e042513a9792e551fb9f0bc8a4379f05d0b8d9ac98
name: python-aiida-aurora
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: AiiDA plugin for the Aurora platform.
url: https://pypi.org/project/aiida-aurora/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiida-aurora-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/EmpaEconversion/aiida-aurora/workflows/ci/badge.svg?branch=main)](https://github.com/EmpaEconversion/aiida-aurora/actions)
  [![Coverage Status](https://coveralls.io/repos/github/EmpaEconversion/aiida-aurora/badge.svg?branch=main)](https://coveralls.io/github/EmpaEconversion/aiida-aurora?branch=main)
  [![Docs status](https://readthedocs.org/projects/aiida-aurora/badge)](http://aiida-aurora.readthedocs.io/)
  [![PyPI version](https://badge.fury.io/py/aiida-aurora.svg)](https://badge.fury.io/py/aiida-aurora)



  AiiDA plugin for the Aurora project (autonomous robotic battery innovation platform).
  A collaboration between EPFL & Empa, within the BIG-MAP Stakeholder Initiative Call 2021-2023.



  - [`.github/`](.github/): [Github Actions](https://github.com/features/actions) configuration
    - [`ci.yml`](.github/workflows/ci.yml): runs tests, checks test coverage and builds documentation at every new commit
    - [`publish-on-pypi.yml`](.github/workflows/publish-on-pypi.yml): automatically deploy git tags to PyPI - just generate a [PyPI API token](https://pypi.org/help/#apitoken) for your PyPI account and add it to the `pypi_token` secret of your github repository
  - [`aiida_aurora/`](aiida_aurora/): The main source code of the plugin package
    - [`data/`](aiida_aurora/data/): A new `DiffParameters` data class, used as input to the `DiffCalculation` `CalcJob` class
    - [`calculations.py`](aiida_aurora/calculations.py): A new `DiffCalculation` `CalcJob` class
    - [`cli.py`](aiida_aurora/cli.py): Extensions of the `verdi data` command line interface for the `DiffParameters` class
    - [`helpers.py`](aiida_aurora/helpers.py): Helpers for setting up an AiiDA code for `diff` automatically
    - [`parsers.py`](aiida_aurora/parsers.py): A new `Parser` for the `DiffCalculation`
  - [`docs/`](docs/): A documentation template ready for publication on [Read the Docs](http://aiida-diff.readthedocs.io/en/latest/)
  - [`examples/`](examples/): An example of how to submit a calculation using this plugin
  - [`tests/`](tests/): Basic regression tests using the [pytest](https://docs.pytest.org/en/latest/) framework (submitting a calculation, ...). Install `pip install -e .[testing]` and run `pytest`.
  - [`.coveragerc`](.coveragerc): Configuration of [coverage.py](https://coverage.readthedocs.io/en/latest) tool reporting which lines of your plugin are covered by tests
  - [`.gitignore`](.gitignore): Telling git which files to ignore
  - [`.pre-commit-config.yaml`](.pre-commit-config.yaml): Configuration of [pre-commit hooks](https://pre-commit.com/) that sanitize coding style and check for syntax errors. Enable via `pip install -e .[pre-commit] && pre-commit install`
  - [`.readthedocs.yml`](.readthedocs.yml): Configuration of documentation build for [Read the Docs](https://readthedocs.org/)
  - [`LICENSE`](LICENSE): License for your plugin
  - [`MANIFEST.in`](MANIFEST.in): Configure non-Python files to be included for publication on [PyPI](https://pypi.org/)
  - [`README.md`](README.md): This file



  ```shell
  pip install aiida-aurora
  verdi quicksetup  # better to set up a new profile
  verdi plugin list aiida.calculations  # should now show your calclulation plugins
  ```



  Here goes a complete example of how to submit a test calculation using this plugin.

  A quick demo of how to submit a calculation:

  ```shell
  verdi daemon start     # make sure the daemon is running
  cd examples
  ./example_01.py        # run test calculation
  verdi process list -a  # check record of calculation
  ```

  The plugin also includes verdi commands to inspect its data types:

  ```shell
  verdi data aurora list
  verdi data aurora export <PK>
  ```



  ```shell
  git clone https://github.com/EmpaEconversion/aiida-aurora .
  cd aiida-aurora
  pip install -e .[pre-commit,testing]  # install extra dependencies
  pre-commit install  # install pre-commit hooks
  pytest -v  # discover and run all tests
  ```

  See the [developer guide](http://aiida-aurora.readthedocs.io/en/latest/developer_guide/index.html) for more information.



  MIT



  This project was supported by the Open Research Data Program of the ETH Board.



  - Edan Bainglass (edan.bainglass@psi.ch)
  - Francisco F. Ramirez (ramirezfranciscof@gmail.com)
  - Loris Ercole (loris.ercole@gmail.com)
  - Giovanni Pizzi (giovanni.pizzi@psi.ch)


pkgId: 33d8c6c17a468a89e7aa6b1c42960052027374f3dfee6d9dd96eb85f0ac00c43
name: python-aiida-codtools
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: The Official AiiDA plugin for the cod-tools package.
url: https://pypi.org/project/aiida-codtools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiida-codtools-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aiida-codtools.svg)](https://badge.fury.io/py/aiida-codtools)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/aiida-codtools.svg)](https://pypi.python.org/pypi/aiida-codtools)
  [![Build Status](https://github.com/aiidateam/aiida-codtools/workflows/aiida-codtools/badge.svg)](https://github.com/aiidateam/aiida-codtools/actions)
  [![Docs status](https://readthedocs.org/projects/aiida-codtools/badge)](http://aiida-codtools.readthedocs.io/)

  This is the official AiiDA plugin for [cod-tools](http://wiki.crystallography.net/cod-tools/).



  The following table shows which versions of `aiida-codtools` are compatible with which versions of AiiDA and Python.

  | Plugin | AiiDA | Python |
  |-|-|-|
  | `v3.0.0 < v4.0.0` | ![Compatibility for v3.0][AiiDA v2.x] |  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/aiida-codtools/3.0.0.svg)](https://pypi.python.org/pypi/aiida-codtools/) |
  | `v2.2.0 < v3.0.0` | ![Compatibility for v2.2][AiiDA v1.x] |  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/aiida-codtools/2.2.0.svg)](https://pypi.python.org/pypi/aiida-codtools/) |
  | `v2.1.0 < v2.2.0` | ![Compatibility for v2.1][AiiDA v1.x] |  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/aiida-codtools/2.1.0.svg)](https://pypi.python.org/pypi/aiida-codtools/) |
  | `v2.0.0 < v2.1.0` | ![Compatibility for v2.0][AiiDA v1.x] |  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/aiida-codtools/2.0.0.svg)](https://pypi.python.org/pypi/aiida-codtools/) |
  | `v1.0.0 < v2.0.0` | ![Compatibility for v1.0][AiiDA v1.x] |  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/aiida-codtools/1.0.0.svg)](https://pypi.python.org/pypi/aiida-codtools/) |



  To install from PyPi, simply execute:

      pip install aiida-codtools

  or when installing from source:

      git clone https://github.com/aiidateam/aiida-codtools
      pip install aiida-codtools


  In order to use `aiida-codtools`, after installing the package, `aiida-core` needs to be setup and configured.
  For instructions please follow the documentation of [`aiida-core`](https://aiida-core.readthedocs.io/en/latest/).

  The package provides a command line script `aiida-codtools` that comes with some useful commands, such as launching calculation or imports CIF files.
  Call the command with the `--help` flag to display its usage:

      Usage: aiida-codtools [OPTIONS] COMMAND [ARGS]...

        CLI for the `aiida-codtools` plugin.

      Options:
        -p, --profile PROFILE  Execute the command for this profile instead of the default profile.
        -h, --help             Show this message and exit.

      Commands:
        calculation  Commands to launch and interact with calculations.
        data         Commands to import, create and inspect data nodes.
        workflow     Commands to launch and interact with workflows.

  Each sub command can have multiple other sub commands.
  To enable tab completion, add the following line to your shell activation script:

      eval "$(_AIIDA_CODTOOLS_COMPLETE=source aiida-codtools)"

  To import 10 random CIF files from the COD database, for example, you can do the following:

      verdi group create cod_cif_raw
      aiida-codtools data cif import -d cod -G cod_cif_raw -M 10

  After you have configured a computer and a code, you can also easily launch a `cod-tools` calculation through AiiDA:

      aiida-codtools calculation launch cod-tools -X cif-filter -N 10

  Here `cif-filter` is the label of the code that you have configured and `10` is the pk of a `CifData` node.
  These will most likely be different for your database, so change them accordingly.



  The documentation for this package can be found on [readthedocs](http://aiida-codtools.readthedocs.io/en/latest/).



  This work is supported in part by the [swissuniversities P-5 project "Materials Cloud"](https://www.materialscloud.org/swissuniversities).

  ![swissuniversities](docs/source/images/swissuniversities.png)

  [AiiDA v2.x]: https://img.shields.io/badge/AiiDA->=2.0,<3.0-007ec6.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACMAAAAhCAYAAABTERJSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAFhgAABYYBG6Yz4AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAUbSURBVFiFzZhrbFRVEMd%2Fc%2B5uu6UUbIFC%2FUAUVEQCLbQJBIiBDyiImJiIhmohYNCkqJAQxASLF8tDgYRHBLXRhIcKNtFEhVDgAxBJqgmVh4JEKg3EIn2QYqBlt917xg%2BFss%2ByaDHOtzsz5z%2B%2FuZl7ztmF%2F5HJvxVQN6cPYX8%2FPLnOmsvNAvqfwuib%2FbNIk9cQeQnLcKRL5xLIV%2Fic9eJeunjPYbRs4FjQSpTB3aS1IpRKeeOOewajy%2FKKEO8Q0DuVdKy8IqsbPulxGHUfCBBu%2BwUYGuFuBTK7wQnht6PEbf4tlRomVRjCbXNjQEB0AyrFQOL5ENIJm7dTLZE6DPJCnEtFZVXDLny%2B4Sjv0PmmYu1ZdUek9RiMgoDmJ8V0L7XJqsZ3UW8YsBOwEeHeeFce7jEYXBy0m9m4BbXqSj2%2Bxnkg26MCVrN6DEZcwggtd8pTFx%2Fh3B9B50YLaFOPwXQKUt0tBLegtSomfBlfY13PwijbEnhztGzgJsK5h9W9qeWwBqjvyhB2iBs1Qz0AU974DciRGO8CVN8AJhAeMAdA3KbrKEtvxhsI%2B9emWiJlGBEU680Cfk%2BSsVqXZvcFYGXjF8ABVJ%2BTNfVXehyms1zzn1gmIOxLEB6E31%2FWBe5rnCarmo7elf7dJEeaLh80GasliI5F6Q9cAz1GY1OJVNDxTzQTw7iY%2FHEZRQY7xqJ9RU2LFe%2FYqakdP911ha0XhjjiTVAkDwgatWfCGeYocx8M3glG8g8EXhSrLrHnEFJ5Ymow%2FkhIYv6ttYUW1iFmEqqxdVoUs9FmsDYSqmtmJh3Cl1%2BVtl2s7owDUdocR5bceiyoSivGTT5vzpbzL1uoBpmcAAQgW7ArnKD9ng9rc%2BNgrobSNwpSkkhcRN%2BvmXLjIsDovYHHEfmsYFygPAnIDEQrQPzJYCOaLHLUfIt7Oq0LJn9fxkSgNCb1qEIQ5UKgT%2Fs6gJmVOOroJhQBXVqw118QtWLdyUxEP45sUpSzqP7RDdFYMyB9UReMiF1MzPwoUqHt8hjGFFeP5wZAbZ%2F0%2BcAtAAcji6LeSq%2FMYiAvSsdw3GtrfVSVFUBbIhwRWYR7yOcr%2FBi%2FB1MSJZ16JlgH1AGM3EO2QnmMyrSbTSiACgFBv4yCUapZkt9qwWVL7aeOyHvArJjm8%2Fz9BhdI4XcZgz2%2FvRALosjsk1ODOyMcJn9%2FYI6IrkS5vxMGdUwou2YKfyVqJpn5t9aNs3gbQMbdbkxnGdsr4bTHm2AxWo9yNZK4PXR3uzhAh%2BM0AZejnCrGdy0UvJxl0oMKgWSLR%2B1LH2aE9ViejiFs%2BXn6bTjng3MlIhJ1I1TkuLdg6OcAbD7Xx%2Bc3y9TrWAiSHqVkbZ2v9ilCo6s4AjwZCzFyD9mOL305nV9aonvsQeT2L0gVk4OwOJqXXVRW7naaxswDKVdlYLyMXAnntteYmws2xcVVZzq%2BtHPAooQggmJkc6TLSusOiL4RKgwzzYU1iFQgiUBA1H7E8yPau%2BZl9P7AblVNebtHqTgxLfRqrNvZWjsHZFuqMqKcDWdlFjF7UGvX8Jn24DyEAykJwNcdg0OvJ4p5pQ9tV6SMlP4A0PNh8aYze1ArROyUNTNouy8tNF3Rt0CSXb6bRFl4%2FIfQzNMjaE9WwpYOWQnOdEF%2BTdJNO0iFh7%2BI0kfORzQZb6P2kymS9oTxzBiM9rUqLWr1WE5G6ODhycQd%2FUnNVeMbcH68hYkGycNoUNWc8fxaxfwhDbHpfwM5oeTY7rUX8QAAAABJRU5ErkJggg%3D%3D

  [AiiDA v1.x]: https://img.shields.io/badge/AiiDA->=1.0,<2.0-007ec6.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACMAAAAhCAYAAABTERJSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAFhgAABYYBG6Yz4AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAUbSURBVFiFzZhrbFRVEMd%2Fc%2B5uu6UUbIFC%2FUAUVEQCLbQJBIiBDyiImJiIhmohYNCkqJAQxASLF8tDgYRHBLXRhIcKNtFEhVDgAxBJqgmVh4JEKg3EIn2QYqBlt917xg%2BFss%2ByaDHOtzsz5z%2B%2FuZl7ztmF%2F5HJvxVQN6cPYX8%2FPLnOmsvNAvqfwuib%2FbNIk9cQeQnLcKRL5xLIV%2Fic9eJeunjPYbRs4FjQSpTB3aS1IpRKeeOOewajy%2FKKEO8Q0DuVdKy8IqsbPulxGHUfCBBu%2BwUYGuFuBTK7wQnht6PEbf4tlRomVRjCbXNjQEB0AyrFQOL5ENIJm7dTLZE6DPJCnEtFZVXDLny%2B4Sjv0PmmYu1ZdUek9RiMgoDmJ8V0L7XJqsZ3UW8YsBOwEeHeeFce7jEYXBy0m9m4BbXqSj2%2Bxnkg26MCVrN6DEZcwggtd8pTFx%2Fh3B9B50YLaFOPwXQKUt0tBLegtSomfBlfY13PwijbEnhztGzgJsK5h9W9qeWwBqjvyhB2iBs1Qz0AU974DciRGO8CVN8AJhAeMAdA3KbrKEtvxhsI%2B9emWiJlGBEU680Cfk%2BSsVqXZvcFYGXjF8ABVJ%2BTNfVXehyms1zzn1gmIOxLEB6E31%2FWBe5rnCarmo7elf7dJEeaLh80GasliI5F6Q9cAz1GY1OJVNDxTzQTw7iY%2FHEZRQY7xqJ9RU2LFe%2FYqakdP911ha0XhjjiTVAkDwgatWfCGeYocx8M3glG8g8EXhSrLrHnEFJ5Ymow%2FkhIYv6ttYUW1iFmEqqxdVoUs9FmsDYSqmtmJh3Cl1%2BVtl2s7owDUdocR5bceiyoSivGTT5vzpbzL1uoBpmcAAQgW7ArnKD9ng9rc%2BNgrobSNwpSkkhcRN%2BvmXLjIsDovYHHEfmsYFygPAnIDEQrQPzJYCOaLHLUfIt7Oq0LJn9fxkSgNCb1qEIQ5UKgT%2Fs6gJmVOOroJhQBXVqw118QtWLdyUxEP45sUpSzqP7RDdFYMyB9UReMiF1MzPwoUqHt8hjGFFeP5wZAbZ%2F0%2BcAtAAcji6LeSq%2FMYiAvSsdw3GtrfVSVFUBbIhwRWYR7yOcr%2FBi%2FB1MSJZ16JlgH1AGM3EO2QnmMyrSbTSiACgFBv4yCUapZkt9qwWVL7aeOyHvArJjm8%2Fz9BhdI4XcZgz2%2FvRALosjsk1ODOyMcJn9%2FYI6IrkS5vxMGdUwou2YKfyVqJpn5t9aNs3gbQMbdbkxnGdsr4bTHm2AxWo9yNZK4PXR3uzhAh%2BM0AZejnCrGdy0UvJxl0oMKgWSLR%2B1LH2aE9ViejiFs%2BXn6bTjng3MlIhJ1I1TkuLdg6OcAbD7Xx%2Bc3y9TrWAiSHqVkbZ2v9ilCo6s4AjwZCzFyD9mOL305nV9aonvsQeT2L0gVk4OwOJqXXVRW7naaxswDKVdlYLyMXAnntteYmws2xcVVZzq%2BtHPAooQggmJkc6TLSusOiL4RKgwzzYU1iFQgiUBA1H7E8yPau%2BZl9P7AblVNebtHqTgxLfRqrNvZWjsHZFuqMqKcDWdlFjF7UGvX8Jn24DyEAykJwNcdg0OvJ4p5pQ9tV6SMlP4A0PNh8aYze1ArROyUNTNouy8tNF3Rt0CSXb6bRFl4%2FIfQzNMjaE9WwpYOWQnOdEF%2BTdJNO0iFh7%2BI0kfORzQZb6P2kymS9oTxzBiM9rUqLWr1WE5G6ODhycQd%2FUnNVeMbcH68hYkGycNoUNWc8fxaxfwhDbHpfwM5oeTY7rUX8QAAAABJRU5ErkJggg%3D%3D

  [AiiDA v0.x]: https://img.shields.io/badge/AiiDA->=0.12,<1.0-007ec6.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACMAAAAhCAYAAABTERJSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAFhgAABYYBG6Yz4AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAUbSURBVFiFzZhrbFRVEMd%2Fc%2B5uu6UUbIFC%2FUAUVEQCLbQJBIiBDyiImJiIhmohYNCkqJAQxASLF8tDgYRHBLXRhIcKNtFEhVDgAxBJqgmVh4JEKg3EIn2QYqBlt917xg%2BFss%2ByaDHOtzsz5z%2B%2FuZl7ztmF%2F5HJvxVQN6cPYX8%2FPLnOmsvNAvqfwuib%2FbNIk9cQeQnLcKRL5xLIV%2Fic9eJeunjPYbRs4FjQSpTB3aS1IpRKeeOOewajy%2FKKEO8Q0DuVdKy8IqsbPulxGHUfCBBu%2BwUYGuFuBTK7wQnht6PEbf4tlRomVRjCbXNjQEB0AyrFQOL5ENIJm7dTLZE6DPJCnEtFZVXDLny%2B4Sjv0PmmYu1ZdUek9RiMgoDmJ8V0L7XJqsZ3UW8YsBOwEeHeeFce7jEYXBy0m9m4BbXqSj2%2Bxnkg26MCVrN6DEZcwggtd8pTFx%2Fh3B9B50YLaFOPwXQKUt0tBLegtSomfBlfY13PwijbEnhztGzgJsK5h9W9qeWwBqjvyhB2iBs1Qz0AU974DciRGO8CVN8AJhAeMAdA3KbrKEtvxhsI%2B9emWiJlGBEU680Cfk%2BSsVqXZvcFYGXjF8ABVJ%2BTNfVXehyms1zzn1gmIOxLEB6E31%2FWBe5rnCarmo7elf7dJEeaLh80GasliI5F6Q9cAz1GY1OJVNDxTzQTw7iY%2FHEZRQY7xqJ9RU2LFe%2FYqakdP911ha0XhjjiTVAkDwgatWfCGeYocx8M3glG8g8EXhSrLrHnEFJ5Ymow%2FkhIYv6ttYUW1iFmEqqxdVoUs9FmsDYSqmtmJh3Cl1%2BVtl2s7owDUdocR5bceiyoSivGTT5vzpbzL1uoBpmcAAQgW7ArnKD9ng9rc%2BNgrobSNwpSkkhcRN%2BvmXLjIsDovYHHEfmsYFygPAnIDEQrQPzJYCOaLHLUfIt7Oq0LJn9fxkSgNCb1qEIQ5UKgT%2Fs6gJmVOOroJhQBXVqw118QtWLdyUxEP45sUpSzqP7RDdFYMyB9UReMiF1MzPwoUqHt8hjGFFeP5wZAbZ%2F0%2BcAtAAcji6LeSq%2FMYiAvSsdw3GtrfVSVFUBbIhwRWYR7yOcr%2FBi%2FB1MSJZ16JlgH1AGM3EO2QnmMyrSbTSiACgFBv4yCUapZkt9qwWVL7aeOyHvArJjm8%2Fz9BhdI4XcZgz2%2FvRALosjsk1ODOyMcJn9%2FYI6IrkS5vxMGdUwou2YKfyVqJpn5t9aNs3gbQMbdbkxnGdsr4bTHm2AxWo9yNZK4PXR3uzhAh%2BM0AZejnCrGdy0UvJxl0oMKgWSLR%2B1LH2aE9ViejiFs%2BXn6bTjng3MlIhJ1I1TkuLdg6OcAbD7Xx%2Bc3y9TrWAiSHqVkbZ2v9ilCo6s4AjwZCzFyD9mOL305nV9aonvsQeT2L0gVk4OwOJqXXVRW7naaxswDKVdlYLyMXAnntteYmws2xcVVZzq%2BtHPAooQggmJkc6TLSusOiL4RKgwzzYU1iFQgiUBA1H7E8yPau%2BZl9P7AblVNebtHqTgxLfRqrNvZWjsHZFuqMqKcDWdlFjF7UGvX8Jn24DyEAykJwNcdg0OvJ4p5pQ9tV6SMlP4A0PNh8aYze1ArROyUNTNouy8tNF3Rt0CSXb6bRFl4%2FIfQzNMjaE9WwpYOWQnOdEF%2BTdJNO0iFh7%2BI0kfORzQZb6P2kymS9oTxzBiM9rUqLWr1WE5G6ODhycQd%2FUnNVeMbcH68hYkGycNoUNWc8fxaxfwhDbHpfwM5oeTY7rUX8QAAAABJRU5ErkJggg%3D%3D


pkgId: ae66d9364d6dac8bf7242302309198b2e9707632b1ff6ca83777eace3a1f4262
name: python-aiida-crystal17
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: AiiDA plugin for running the CRYSTAL17 code
url: https://github.com/chrisjsewell/aiida-crystal17
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiida-crystal17-0.11.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/aiidaplugins/aiida-crystal17/workflows/CI/badge.svg)](https://github.com/aiidaplugins/aiida-crystal17)
  [![Coverage Status](https://codecov.io/gh/aiidaplugins/aiida-crystal17/branch/master/graph/badge.svg)](https://codecov.io/gh/aiidaplugins/aiida-crystal17)
  [![Docs status](https://readthedocs.org/projects/aiida-crystal17/badge)](http://aiida-crystal17.readthedocs.io/)
  [![PyPI](https://img.shields.io/pypi/v/aiida-crystal17.svg)](https://pypi.python.org/pypi/aiida-crystal17/)
  [![Conda](https://anaconda.org/conda-forge/aiida-crystal17/badges/version.svg)](https://anaconda.org/conda-forge/aiida-crystal17)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3357615.svg)](https://doi.org/10.5281/zenodo.3357615)

  AiiDA plugin for running the [CRYSTAL17](http://www.crystal.unito.it/) code.
  The code is principally tested against CRYSTAL17,
  but the output parsing has also been tested against CRYSTAL14.

  **Documentation**: https://readthedocs.org/projects/aiida-crystal17



  To install from Conda (recommended)::

  ```shell
  >> conda install -c conda-forge aiida-crystal17 aiida-core.services
  ```

  To install from pypi::

  ```shell
  >> pip install aiida-crystal17
  ```

  To install the development version:

  ```shell
  >> git clone https://github.com/aiidaplugins/aiida-crystal17 .
  >> cd aiida-crystal17
  >> pip install -e .  # also installs aiida, if missing (but not postgres)
  >> #pip install -e .[pre-commit,testing] # install extras for more features
  >> verdi quicksetup  # set up a new profile
  >> verdi calculation plugins  # should now show the calclulation plugins (with prefix crystal17.)
  ```





  Because CRYSTAL17 is a licensed software, it is not possible to source a copy of the executable on Travis CI.
  Therefore, a mock executable (`mock_runcry17`) has been created for testing purposes (which also speeds up test runs).

  This executable computes the md5 hash of the supplied input file and tries to match it against a dictionary of
  precomputed hashes. If found, the executable will write the matching output (from `test/output_files`) to stdout.

  The following will discover and run all unit test:

  ```shell
  >> pip install -e .[testing]
  >> reentry scan -r aiida
  >> pytest -v
  ```

  To omit tests which call external executables (like `crystal17`):

  ```shell
  >> pytest --cry17-skip-exec
  ```

  To call the actual executables (e.g. `crystal17` instead of `mock_crystal17`):

  ```shell
  >> pytest --cry17-no-mock
  ```

  To output the results of calcjob executions to a specific directory:

  ```shell
  >> pytest --cry17-workdir "test_workdir"
  ```



  The code style is tested using [flake8](http://flake8.pycqa.org),
  with the configuration set in `.flake8`, and code should be formatted with [yapf](https://github.com/google/yapf) (configuration set in `.style.yapf`).

  Installing with `aiida-crystal17[code_style]` makes the [pre-commit](https://pre-commit.com/)
  package available, which will ensure these tests are passed by reformatting the code
  and testing for lint errors before submitting a commit.
  It can be setup by:

  ```shell
  >> cd aiida-crystal17
  >> pre-commit install
  ```

  Optionally you can run `yapf` and `flake8` separately:

  ```shell
  >> yapf -r -i .  # recrusively find and format files in-place
  >> flake8
  ```

  Editors like VS Code also have automatic code reformat utilities, which can adhere to this standard.



  To set up local version of CRYSTAL17 on a mac (after downloading a copy from the distributor), I had to:

  1. Remove the quarantine from the executable permissions:

      ```shell
      xattr -c crystal
      xattr -c properties
      ```

  2. Create versions of the lapack/blas libraries in the expected folders:

      ```shell
      sudo port install lapack
      sudo cp /opt/local/lib/lapack/liblapack.3.dylib /usr/local/opt/lapack/lib/liblapack.3.dylib
      sudo cp /opt/local/lib/lapack/libblas.3.dylib /usr/local/opt/lapack/lib/libblas.3.dylib
      ```

  3. Define environmental variables in `~/.bashrc`, as detailed in `cry17_scripts/cry17.bashrc`
  4. Copy or symlink the `cry17_scripts/runcry17` script into `/usr/local/bin/`



  See ``LICENSE`` file



  chrisj_sewell@hotmail.com


pkgId: a43caed93182a140ec27fe4f6776360521f8e82136b9fd8d293a8c18b0aeff44
name: python-aiida-export-migration-tests
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Export archives for migration tests for AiiDA
url: https://github.com/aiidateam/aiida-export-migration-tests
rpm_license: MIT Licence
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aiida-export-migration-tests-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Test modules for migration of [AiiDA](http://www.aiida.net) export files.

  Can be installed by adding `testing` package, when installing AiiDA:

  ```shell
  pip install aiida-core[testing]
  ```

  > **Note**: This only works for AiiDA *v1.0.0* and newer.

  Historical table of version comparisons between releases of this module and AiiDA, including when tests for the different export versions are first included.

  | This module | AiiDA | Export versions (when first included) |
  | ----------- | ----- | ------------------------------------- |
  | [0.9.0](https://github.com/aiidateam/aiida-export-migration-tests/releases/tag/v0.9.0) | to be released | 0.9 |
  | [0.8.0](https://github.com/aiidateam/aiida-export-migration-tests/releases/tag/v0.8.0) | [1.0.1](https://github.com/aiidateam/aiida-core/releases/tag/v1.0.1) | 0.8 |
  | [0.7.0](https://github.com/aiidateam/aiida-export-migration-tests/releases/tag/v0.7.0) | [1.0.0b4](https://github.com/aiidateam/aiida-core/releases/tag/v1.0.0b4) | 0.6, 0.7 |
  | 0.6.0 | [1.0.0b4](https://github.com/aiidateam/aiida-core/releases/tag/v1.0.0b4) | |
  | [0.5.2](https://github.com/aiidateam/aiida-export-migration-tests/releases/tag/v0.5.2) | [1.0.0b3](https://github.com/aiidateam/aiida-core/releases/tag/v1.0.0b3) | |
  | [0.5.1](https://github.com/aiidateam/aiida-export-migration-tests/releases/tag/v0.5.1) | [1.0.0b3](https://github.com/aiidateam/aiida-core/releases/tag/v1.0.0b3) | |
  | [0.5.0](https://github.com/aiidateam/aiida-export-migration-tests/releases/tag/v0.5.0) | [1.0.0b3](https://github.com/aiidateam/aiida-core/releases/tag/v1.0.0b3) | 0.4 -> 0.5 |
  | [0.1.1](https://github.com/aiidateam/aiida-export-migration-tests/releases/tag/v0.1.1) | [1.0.0b2](https://github.com/aiidateam/aiida-core/releases/tag/v1.0.0b2) | |
  | [0.1.0](https://github.com/aiidateam/aiida-export-migration-tests/releases/tag/v0.1.0) | [1.0.0b2](https://github.com/aiidateam/aiida-core/releases/tag/v1.0.0b2) | 0.1 -> 0.2 ; 0.2 -> 0.3 ; 0.3 -> 0.4 |



  **Q: Why not include these test archives in the core of AiiDA?**
  **A:** In order to not take up unneccesary disk space, when installing AiiDA, these test archives have been separated out of [aiida-core](https://github.com/aiidateam/aiida-core).
  Furthermore, the legacy export versions will never change, i.e., the incremental migration functions need only be thoroughly tested once, and will therefore not be affected by changes to the core of the AiiDA code in any way.

  **Q: What happens when the export version is upped?**
  **A:** A new export archive file will be added to this repo as well as a new test-filled file (to [aiida-core](https://github.com/aiidateam/aiida-core) under `tests.tools.importexport.migration.`).

  **Q: What if the import system changes in AiiDA core?**
  **A:** This repo is only for storing the export archives and their creation workflows for different export versions.
  All tests can be found in [aiida-core](https://github.com/aiidateam/aiida-core).





  **AiiDA version**: _To be released_

  Update repository with export archive for export version 0.9.
  The file follows the naming of previous export version files having the suffix `_manual`, since it was not produced properly, i.e., through a new workflow run in AiiDA.
  Instead, the export file `export_v0.8_manual.aiida` has been the unpacked, updated manually, and repacked.
  This means the latest "proper" export file is `export_v0.4.aiida`.

  Changes are expected to be released with AiiDA version 1.2.0.

  *New file*: `export_v0.9_manual.aiida`



  **AiiDA version**: _1.0.0_

  Update repository with export archive for export version 0.8.
  The file follows the naming of previous export version files having the suffix `_manual`, since it was not produced properly, i.e., through a new workflow run in AiiDA.
  Instead, the export file `export_v0.7_manual.aiida` has been the unpacked, updated manually, and repacked.
  This means the latest "proper" export file is `export_v0.4.aiida`.

  Changes are expected to be released with AiiDA version 1.0.1.

  *New file*: `export_v0.8_manual.aiida`



  **AiiDA version**: _1.0.0b4_

  Update repository with export archive for export versions 0.6 and 0.7.
  These files are named differently, having the suffix `_manual`, since they were not produced properly, i.e., through a new workflow run in AiiDA.
  Instead, the export file `export_v0.4.aiida` has been the unpacked, updated manually, and repacked.

  The file `export_v0.5.aiida` has also been made this way, and will therefore have its name changed accordingly.

  *New files*:

  - `export_v0.5_manual.aiida` (only the filename has been altered)
  - `export_v0.6_manual.aiida`
  - `export_v0.7_manual.aiida`



  **AiiDA version**: _1.0.0b4_

  This version was never released.



  **AiiDA version**: _1.0.0b3_

  Remove test files according to issue [#6](https://github.com/aiidateam/aiida-export-migration-tests/issues/6).
  The files have been moved to [aiida-core](https://github.com/aiidateam/aiida-core) under `aiida.backends.tests.tools.importexport.migration.`.
  As explained in the issue, the problem of having tests that concern files in [aiida-core](https://github.com/aiidateam/aiida-core), is that they cannot be skipped with a helpful message using `unittest.skip(<message>)`.

  This repository has now become the keeper of the export archives and the workflows that created them.
  Hence, it should only ever be touched, when a new export version is introduced in AiiDA, and a new archive must be added.



  **AiiDA version**: _1.0.0b3_

  Update imports from aiida-core in accordance with the restructuring of the import/export-module.
  For a reference, this was done in aiida-core PR [#3052](https://github.com/aiidateam/aiida-core/pull/3052).



  **AiiDA version**: _1.0.0b3_

  Update version number of this repository to reflect the current `EXPORT_VERSION` in `aiida-core`.
  The version number is now as follows: `<EXPORT_VERSION>.<patch>`

  Implement initial change related to the update of `EXPORT_VERSION` from 0.4 to 0.5:

  - _Migration [0034](https://github.com/aiidateam/aiida-core/blob/b8eaffca3c448d1242eded845aa118b4bc1ae1a9/aiida/backends/djsite/db/migrations/0034_drop_node_columns_nodeversion_public.py)_: Remove fields/columns `"nodeversion"` and `"public"` from the `DbNode` model.
  - _Migration [0036](https://github.com/aiidateam/aiida-core/blob/af56391b5bdfbbc3e1d0ef7d36180128bb28f695/aiida/backends/djsite/db/migrations/0036_drop_computer_transport_params.py)_: Remove field/column `"transport_params"` from the `DbComputer` model.

  _Note_: The newly created `export_v0.5.aiida` under `/aiida-export-migration-tests/archives` is _not_ actually created from an AiiDA workflow, but instead a migration of `export_v0.4.aiida`.
  This is because the changes between the versions are insignificant for the outcome of the workflow, and that only very minor changes have occurred.



  **AiiDA version**: _1.0.0b2_

  Minor fixes due to changes in [aiida-core](https://github.com/aiidateam/aiida-core).

  Folder `fixtures` changes name to `archives` to match the same change happening for aiida-core.
  The simple AiiDA export archives in aiida-core representing the different export versions have changed names:

  - `export_v0.1_no_UPF.aiida` -> `export_v0.1_simple.aiida`
  - `export_v0.2_no_UPF.aiida` -> `export_v0.2_simple.aiida`
  - `export_v0.3_no_UPF.aiida` -> `export_v0.3_simple.aiida`
  - `export_v0.4_no_UPF.aiida` -> `export_v0.4_simple.aiida`

  A change in the conversion message included in `metadata.json` files, when a migration has been successfully performed, introduces the version of AiiDA into the message. In order to have the tests be version-agnostic, the `conversion_info` key has to be handled specially in the relevant tests.
  When migrating an archive, it is asserted that the correct conversion message appears in the migrated archive, and the `conversion_info` item is then popped from both the migrated archive and the archive imported for comparison.



  **AiiDA version**: _1.0.0b2_

  First release.

  Tests for step-wise export migrations from versions 0.1, 0.2, and 0.3.
  Representative export files created in specialized [Quantum Mobile](https://materialscloud.org/work/quantum-mobile) virtual machines by @yakutovicha to test currently known migrations from the basis of what could be exported at the time of the different export versions.

  Table of version comparisons (similar to the one in [aiida-core](https://github.com/aiidateam/aiida-core) PR [#2478](https://github.com/aiidateam/aiida-core/pull/2478)).

  | Export version | AiiDA version | AiiDA version release date | Found changed in commit |
  | -------------- | ------------- | -------------------------- | ----------------------- |
  | ~~v0.1~~* | ~~0.6.0.1~~ | ~~01.03.2016~~ | ~~as exported by 0.6.0~~ |
  | v0.2 | 0.9.1 | 01.09.2017 | [189e29fea4c7f4213d0be0914d55cccaa581c364](https://github.com/aiidateam/aiida-core/commit/189e29fea4c7f4213d0be0914d55cccaa581c364) (v0.7.0) |
  | v0.3 | 0.12.3 | 04.03.2019 | [788d3206e0eaaf062d1a13710aaa64a18a0bbbcd](https://github.com/aiidateam/aiida-core/commit/788d3206e0eaaf062d1a13710aaa64a18a0bbbcd) (v0.10.0rc1) |
  | v0.4 | 1.0.0b2 | 09.04.2019 | [1673ec28e8b594693a0ee4cdec82669e72abcc4c](https://github.com/aiidateam/aiida-core/commit/1673ec28e8b594693a0ee4cdec82669e72abcc4c) (v1.0.0b1) |

  \*Due to the following reasons, we decided **not** to invest an effort in making the representative archive migration for 0.1:

  1. The earliest version released on PyPi is 0.8.0rc1 (22.03.2017).
  1. The previous stable version (AiiDA 0.5.0) was not working in a virtual environment.
  1. The migration from v0.1 to v0.2 is small and quite simple.
     If an export file should be found that cannot be properly migrated, due to this step, it can be migrated manually with little effort.



  To create the representative export files, a simple workflow was developed by @yakutovicha that runs two consequtive [QuantumESPRESSO](https://www.quantum-espresso.org) PW calculations.
  First an SCF calculation, followed by an MD calculation.

  The workflows can be found in the repository's folder `.qm`, and correspond to the following export versions and [Quantum Mobile](https://github.com/marvel-nccr/quantum-mobile/releases/) editions:

  | Export version | Workflow | Run workflow script | Quantum Mobile |
  | -------------- | -------- | ------------------- | -------------- |
  | ~~v0.1~~* | - | - | - |
  | v0.2 | [wf.py](aiida-export-migration-tests/.qm/wf.py) | [run_wf.py](aiida-export-migration-tests/.qm/run_wf.py) | [historical_aiida_0.9.1](https://github.com/marvel-nccr/quantum-mobile/tree/historical_aiida_0.9.1) |
  | v0.3 | [wf.py](aiida-export-migration-tests/.qm/wf.py) | [run_wf.py](aiida-export-migration-tests/.qm/run_wf.py) | [v19.03.0](https://github.com/marvel-nccr/quantum-mobile/releases/tag/19.03.0) |
  | v0.4 | [wf_aiida_1_0.py](aiida-export-migration-tests/.qm/wf_aiida_1_0.py) | [run_wf_aiida_1_0.py](aiida-export-migration-tests/.qm/run_wf_aiida_1_0.py) | _in development_ |

  \*See section _Release notes#0.1.0 (April 2019)_.

  They contain the following AiiDA node types (according to AiiDA **1.0.0**):

  | Node type | Parent-type tree, up to `Node` |
  | --------- | -------- |
  | Float | NumericType -> BaseType/Data -> Node |
  | Int | NumericType -> BaseType/Data -> Node |
  | Dict | Data -> Node |
  | FolderData | Data -> Node |
  | RemoteData | Data -> Node |
  | StructureData | Data -> Node |
  | UpfData | SinglefileData -> Data -> Node |
  | KpointsData | ArrayData -> Data -> Node |
  | BandsData | KpointsData -> ArrayData -> Data -> Node |
  | TrajectoryData | ArrayData -> Data -> Node |
  | Code | Data -> Node |
  | WorkChainNode | WorkflowNode -> ProcessNode -> Node |
  | CalcJobNode | CalculationNode -> ProcessNode -> Node |


