# packages

pkgId: 998b953d2e513d96d5ffe2071b89cd9bb6c11d161944f12cd6a559b9ce780ed8
name: python-autofit
arch: src
version: 2024.11.13.2
epoch: 0
release: 1
summary: Classy Probabilistic Programming
url: https://github.com/rhayes777/PyAutoFit
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autofit-2024.11.13.2-1.src.rpm
checksum_type: sha256
description:
  |binder| |Tests| |Build| |RTD| |JOSS|
  `Installation Guide <https://pyautofit.readthedocs.io/en/latest/installation/overview.html>`_ |
  `readthedocs <https://pyautofit.readthedocs.io/en/latest/index.html>`_ |
  `Introduction on Binder <https://mybinder.org/v2/gh/Jammy2211/autofit_workspace/release?filepath=notebooks/overview/overview_1_the_basics.ipynb>`_ |
  `HowToFit <https://pyautofit.readthedocs.io/en/latest/howtofit/howtofit.html>`_
  **PyAutoFit** is a Python based probabilistic programming language for model fitting and Bayesian inference
  of large datasets.
  The basic **PyAutoFit** API allows us a user to quickly compose a probabilistic model and fit it to data via a
  log likelihood function, using a range of non-linear search algorithms (e.g. MCMC, nested sampling).
  Users can then set up **PyAutoFit** scientific workflow, which enables streamlined modeling of small
  datasets with tools to scale up to large datasets.
  **PyAutoFit** supports advanced statistical methods, most
  notably `a big data framework for Bayesian hierarchical analysis <https://pyautofit.readthedocs.io/en/latest/features/graphical.html>`_.


pkgId: b02719a19b3aac42c71003fe7dce3c0f27e3caed9b55001b3b6455fa6e65a089
name: python-autoflake
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Removes unused imports and unused variables
url: https://www.github.com/PyCQA/autoflake
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoflake-2.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/PyCQA/autoflake/actions/workflows/main.yaml/badge.svg?branch=main)](https://github.com/PyCQA/autoflake/actions/workflows/main.yaml)



  _autoflake_ removes unused imports and unused variables from Python code. It
  makes use of [pyflakes](https://pypi.org/pypi/pyflakes) to do this.

  By default, autoflake only removes unused imports for modules that are part of
  the standard library. (Other modules may have side effects that make them
  unsafe to remove automatically.) Removal of unused variables is also disabled
  by default.

  autoflake also removes useless ``pass`` statements by default.



  Running autoflake on the below example

  ```
  $ autoflake --in-place --remove-unused-variables example.py
  ```

  ```python
  import math
  import re
  import os
  import random
  import multiprocessing
  import grp, pwd, platform
  import subprocess, sys


  def foo():
      from abc import ABCMeta, WeakSet
      try:
          import multiprocessing
          print(multiprocessing.cpu_count())
      except ImportError as exception:
          print(sys.version)
      return math.pi
  ```

  results in

  ```python
  import math
  import sys


  def foo():
      try:
          import multiprocessing
          print(multiprocessing.cpu_count())
      except ImportError:
          print(sys.version)
      return math.pi
  ```




  ```
  $ pip install --upgrade autoflake
  ```




  To allow autoflake to remove additional unused imports (other than
  than those from the standard library), use the ``--imports`` option. It
  accepts a comma-separated list of names:

  ```
  $ autoflake --imports=django,requests,urllib3 <filename>
  ```

  To remove all unused imports (whether or not they are from the standard
  library), use the ``--remove-all-unused-imports`` option.

  To remove unused variables, use the ``--remove-unused-variables`` option.

  Below is the full listing of options:

  ```
  usage: autoflake [-h] [-c | -cd] [-r] [-j n] [--exclude globs] [--imports IMPORTS] [--expand-star-imports] [--remove-all-unused-imports] [--ignore-init-module-imports] [--remove-duplicate-keys] [--remove-unused-variables]
                   [--remove-rhs-for-unused-variables] [--ignore-pass-statements] [--ignore-pass-after-docstring] [--version] [--quiet] [-v] [--stdin-display-name STDIN_DISPLAY_NAME] [--config CONFIG_FILE] [-i | -s]
                   files [files ...]

  Removes unused imports and unused variables as reported by pyflakes.

  positional arguments:
    files                 files to format

  options:
    -h, --help            show this help message and exit
    -c, --check           return error code if changes are needed
    -cd, --check-diff     return error code if changes are needed, also display file diffs
    -r, --recursive       drill down directories recursively
    -j n, --jobs n        number of parallel jobs; match CPU count if value is 0 (default: 0)
    --exclude globs       exclude file/directory names that match these comma-separated globs
    --imports IMPORTS     by default, only unused standard library imports are removed; specify a comma-separated list of additional modules/packages
    --expand-star-imports
                          expand wildcard star imports with undefined names; this only triggers if there is only one star import in the file; this is skipped if there are any uses of `__all__` or `del` in the file
    --remove-all-unused-imports
                          remove all unused imports (not just those from the standard library)
    --ignore-init-module-imports
                          exclude __init__.py when removing unused imports
    --remove-duplicate-keys
                          remove all duplicate keys in objects
    --remove-unused-variables
                          remove unused variables
    --remove-rhs-for-unused-variables
                          remove RHS of statements when removing unused variables (unsafe)
    --ignore-pass-statements
                          ignore all pass statements
    --ignore-pass-after-docstring
                          ignore pass statements after a newline ending on '"""'
    --version             show program's version number and exit
    --quiet               Suppress output if there are no issues
    -v, --verbose         print more verbose logs (you can repeat `-v` to make it more verbose)
    --stdin-display-name STDIN_DISPLAY_NAME
                          the name used when processing input from stdin
    --config CONFIG_FILE  Explicitly set the config file instead of auto determining based on file location
    -i, --in-place        make changes to files instead of printing diffs
    -s, --stdout          print changed text to stdout. defaults to true when formatting stdin, or to false otherwise
  ```

  To ignore the file, you can also add a comment to the top of the file:
  ```python

  import os
  ```



  Configure default arguments using a `pyproject.toml` file:

  ```toml
  [tool.autoflake]
  check = true
  imports = ["django", "requests", "urllib3"]
  ```

  Or a `setup.cfg` file:

  ```ini
  [autoflake]
  check=true
  imports=django,requests,urllib3
  ```

  The name of the configuration parameters match the flags (e.g. use the
  parameter `expand-star-imports` for the flag `--expand-star-imports`).



  To run the unit tests::

  ```
  $ ./test_autoflake.py
  ```

  There is also a fuzz test, which runs against any collection of given Python
  files. It tests autoflake against the files and checks how well it does by
  running pyflakes on the file before and after. The test fails if the pyflakes
  results change for the worse. (This is done in memory. The actual files are
  left untouched.)::

  ```
  $ ./test_fuzz.py --verbose
  ```



  It might be the case that you have some imports for their side effects, even
  if you are not using them directly in that file.

  That is common, for example, in Flask based applications. In where you import
  Python modules (files) that imported a main ``app``, to have them included in
  the routes.

  For example:

  ```python
  from .endpoints import role, token, user, utils
  ```

  As those imports are not being used directly, if you are using the option
  ``--remove-all-unused-imports``, they would be removed.

  To prevent that, without having to exclude the entire file, you can add a
  ``# noqa`` comment at the end of the line, like:

  ```python
  from .endpoints import role, token, user, utils  # noqa
  ```

  That line will instruct ``autoflake`` to let that specific line as is.




  Add the following to your `.pre-commit-config.yaml`

  ```yaml
  -   repo: https://github.com/PyCQA/autoflake
      rev: v2.3.1
      hooks:
      -   id: autoflake
  ```

  When customizing the arguments, make sure you include `--in-place` in the list
  of arguments:

  ```yaml
  -   repo: https://github.com/PyCQA/autoflake
      rev: v2.2.1
      hooks:
      -   id: autoflake
          args: [--remove-all-unused-imports, --in-place]
  ```


pkgId: eca446fa6424077476d2ab07ffef9a72d3b08f4473ab8acd90fa6bc93a121429
name: python-autogen
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A programming framework for agentic AI
url: https://github.com/autogen-ai/autogen
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogen-0.3.1-1.src.rpm
checksum_type: sha256
description:
  <a name="readme-top"></a>

  [![PyPI version](https://badge.fury.io/py/autogen.svg)](https://badge.fury.io/py/autogen)
  [![Build](https://github.com/autogen-ai/autogen/actions/workflows/python-package.yml/badge.svg)](https://github.com/autogen-ai/autogen/actions/workflows/python-package.yml)
  ![Python Version](https://img.shields.io/badge/3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)
  [![Discord](https://img.shields.io/discord/1153072414184452236?logo=discord&style=flat)](https://discord.gg/pAbnFJrkgZ)
  [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/cloudposse.svg?style=social&label=Follow%20%40Chi_Wang_)](https://x.com/Chi_Wang_)

  [![NuGet version](https://badge.fury.io/nu/AutoGen.Core.svg)](https://badge.fury.io/nu/AutoGen.Core)



  [📚 Cite paper](#related-papers).
  <!-- <p align="center">
      <img src="https://github.com/autogen-ai/autogen/blob/main/website/static/img/flaml.svg"  width=200>
      <br>
  </p> -->
  :fire: :tada: Sep 06, 2024: AutoGen now available as `autogen` on PyPI! We're excited to announce a more convenient package name for AutoGen: Starting with version 0.3.0, you can now install AutoGen using:
  ```
  pip install autogen
  ```
  We extend our sincere gratitude to the original owner of `autogen` pypi package for generously transferring it to us.

  **Note:** The previous package name `pyautogen` will remain valid for a transitional period. However, we encourage users to switch to the new, more intuitive `autogen` package name, as `pyautogen` will eventually be deprecated.

  📄 **License Change:**
  With this new release and package name, we are officially switching to the Apache 2.0 license. This enhances our commitment to open-source collaboration while providing additional protections for contributors and users alike.

  :fire: Aug 24, 2024: A new organization [autogen-ai](https://github.com/autogen-ai) is created to host the development of AutoGen and related projects with open governance. We invite collaborators from all organizations and individuals.

  :tada: May 29, 2024: DeepLearning.ai launched a new short course [AI Agentic Design Patterns with AutoGen](https://www.deeplearning.ai/short-courses/ai-agentic-design-patterns-with-autogen), made in collaboration with Microsoft and Penn State University, and taught by AutoGen creators [Chi Wang](https://github.com/sonichi) and [Qingyun Wu](https://github.com/qingyun-wu).

  :tada: May 24, 2024: Foundation Capital published an article on [Forbes: The Promise of Multi-Agent AI](https://www.forbes.com/sites/joannechen/2024/05/24/the-promise-of-multi-agent-ai/?sh=2c1e4f454d97) and a video [AI in the Real World Episode 2: Exploring Multi-Agent AI and AutoGen with Chi Wang](https://www.youtube.com/watch?v=RLwyXRVvlNk).

  :tada: May 13, 2024: [The Economist](https://www.economist.com/science-and-technology/2024/05/13/todays-ai-models-are-impressive-teams-of-them-will-be-formidable) published an article about multi-agent systems (MAS) following a January 2024 interview with [Chi Wang](https://github.com/sonichi).

  :tada: May 11, 2024: [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation](https://openreview.net/pdf?id=uAjxFFing2) received the best paper award at the [ICLR 2024 LLM Agents Workshop](https://llmagents.github.io/).

  :tada: Apr 26, 2024: [AutoGen.NET](https://autogen-ai.github.io/autogen-for-net/) is available for .NET developers!

  :tada: Apr 17, 2024: Andrew Ng cited AutoGen in [The Batch newsletter](https://www.deeplearning.ai/the-batch/issue-245/) and [What's next for AI agentic workflows](https://youtu.be/sal78ACtGTc?si=JduUzN_1kDnMq0vF) at Sequoia Capital's AI Ascent (Mar 26).

  :tada: Mar 3, 2024: What's new in AutoGen? 📰[Blog](https://autogen-ai.github.io/autogen/blog/2024/03/03/AutoGen-Update); 📺[Youtube](https://www.youtube.com/watch?v=j_mtwQiaLGU).

  <!-- :tada: Mar 1, 2024: the first AutoGen multi-agent experiment on the challenging [GAIA](https://huggingface.co/spaces/gaia-benchmark/leaderboard) benchmark achieved the No. 1 accuracy in all the three levels. -->

  <!-- :tada: Jan 30, 2024: AutoGen is highlighted by Peter Lee in Microsoft Research Forum [Keynote](https://t.co/nUBSjPDjqD). -->

  :tada: Dec 31, 2023: [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework](https://arxiv.org/abs/2308.08155) is selected by [TheSequence: My Five Favorite AI Papers of 2023](https://thesequence.substack.com/p/my-five-favorite-ai-papers-of-2023).

  <!-- :fire: Nov 24: pyautogen [v0.2](https://github.com/microsoft/autogen/releases/tag/v0.2.0) is released with many updates and new features compared to v0.1.1. It switches to using openai-python v1. Please read the [migration guide](https://autogen-ai.github.io/autogen/docs/Installation#python). -->

  <!-- :fire: Nov 11: OpenAI's Assistants are available in AutoGen and interoperatable with other AutoGen agents! Checkout our [blogpost](https://autogen-ai.github.io/autogen/blog/2023/11/13/OAI-assistants) for details and examples. -->

  :tada: Nov 8, 2023: AutoGen is selected into [Open100: Top 100 Open Source achievements](https://www.benchcouncil.org/evaluation/opencs/annual.html) 35 days after spinoff from [FLAML](https://github.com/microsoft/FLAML).

  <!-- :tada: Nov 6, 2023: AutoGen is mentioned by Satya Nadella in a [fireside chat](https://youtu.be/0pLBvgYtv6U). -->

  <!-- :tada: Nov 1, 2023: AutoGen is the top trending repo on GitHub in October 2023. -->

  <!-- :tada: Oct 03, 2023: AutoGen spins off from [FLAML](https://github.com/microsoft/FLAML) on GitHub. -->

  <!-- :tada: Aug 16: Paper about AutoGen on [arxiv](https://arxiv.org/abs/2308.08155). -->

  :tada: Mar 29, 2023: AutoGen is first created in [FLAML](https://github.com/microsoft/FLAML).

  <!--
  :fire: FLAML is highlighted in OpenAI's [cookbook](https://github.com/openai/openai-cookbook#related-resources-from-around-the-web).

  :fire: [autogen](https://autogen-ai.github.io/autogen/) is released with support for ChatGPT and GPT-4, based on [Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference](https://arxiv.org/abs/2303.04673).

  :fire: FLAML supports Code-First AutoML & Tuning – Private Preview in [Microsoft Fabric Data Science](https://learn.microsoft.com/en-us/fabric/data-science/). -->



  AutoGen is an open-source programming framework for building AI agents and facilitating cooperation among multiple agents to solve tasks. AutoGen aims to streamline the development and research of agentic AI, much like PyTorch does for Deep Learning. It offers features such as agents capable of interacting with each other, facilitates the use of various large language models (LLMs) and tool use support, autonomous and human-in-the-loop workflows, and multi-agent conversation patterns.

  **Open Source Statement**: The project welcomes contributions from developers and organizations worldwide. Our goal is to foster a collaborative and inclusive community where diverse perspectives and expertise can drive innovation and enhance the project's capabilities. Whether you are an individual contributor or represent an organization, we invite you to join us in shaping the future of this project. Together, we can build something truly remarkable.

  The project is currently maintained by a [dynamic group of volunteers](https://butternut-swordtail-8a5.notion.site/410675be605442d3ada9a42eb4dfef30?v=fa5d0a79fd3d4c0f9c112951b2831cbb&pvs=4) from several different organizations. Contact project administrators Chi Wang and Qingyun Wu via auto-gen@outlook.com if you are interested in becoming a maintainer.


  ![AutoGen Overview](https://github.com/autogen-ai/autogen/blob/main/website/static/img/autogen_agentchat.png)

  <!--
  - AutoGen enables building next-gen LLM applications based on [multi-agent conversations](https://autogen-ai.github.io/autogen/docs/Use-Cases/agent_chat) with minimal effort. It simplifies the orchestration, automation, and optimization of a complex LLM workflow. It maximizes the performance of LLM models and overcomes their weaknesses.
  - It supports [diverse conversation patterns](https://autogen-ai.github.io/autogen/docs/Use-Cases/agent_chat#supporting-diverse-conversation-patterns) for complex workflows. With customizable and conversable agents, developers can use AutoGen to build a wide range of conversation patterns concerning conversation autonomy,
    the number of agents, and agent conversation topology.
  - It provides a collection of working systems with different complexities. These systems span a [wide range of applications](https://autogen-ai.github.io/autogen/docs/Use-Cases/agent_chat#diverse-applications-implemented-with-autogen) from various domains and complexities. This demonstrates how AutoGen can easily support diverse conversation patterns.
  - AutoGen provides [enhanced LLM inference](https://autogen-ai.github.io/autogen/docs/Use-Cases/enhanced_inference#api-unification). It offers utilities like API unification and caching, and advanced usage patterns, such as error handling, multi-config inference, context programming, etc.
  -->
  AutoGen is created out of collaborative [research](https://autogen-ai.github.io/autogen/docs/Research) from Microsoft, Penn State University, and the University of Washington.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>

  <!--

  -->


  The easiest way to start playing is
  1. Click below to use the GitHub Codespace

      [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/autogen-ai/autogen?quickstart=1)

   2. Copy OAI_CONFIG_LIST_sample to ./notebook folder, name to OAI_CONFIG_LIST, and set the correct configuration.
   3. Start playing with the notebooks!

  *NOTE*: OAI_CONFIG_LIST_sample lists GPT-4 as the default model, as this represents our current recommendation, and is known to work well with AutoGen. If you use a model other than GPT-4, you may need to revise various system prompts (especially if using weaker models like GPT-3.5-turbo). Moreover, if you use models other than those hosted by OpenAI or Azure, you may incur additional risks related to alignment and safety. Proceed with caution if updating this default.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>




  Find detailed instructions for users [here](https://autogen-ai.github.io/autogen/docs/installation/Docker#step-1-install-docker), and for developers [here](https://autogen-ai.github.io/autogen/docs/Contribute#docker-for-development).



  AutoGen requires **Python version >= 3.8, < 3.13**. It can be installed from pip:

  ```bash
  pip install autogen
  ```

  Minimal dependencies are installed without extra options. You can install extra options based on the feature you need.

  <!-- For example, use the following to install the dependencies needed by the [`blendsearch`](https://microsoft.github.io/FLAML/docs/Use-Cases/Tune-User-Defined-Function#blendsearch-economical-hyperparameter-optimization-with-blended-search-strategy) option.
  ```bash
  pip install "autogen[blendsearch]"
  ``` -->

  Find more options in [Installation](https://autogen-ai.github.io/autogen/docs/Installation#option-2-install-autogen-locally-using-virtual-environment).

  <!-- Each of the [`notebook examples`](https://github.com/autogen-ai/autogen/tree/main/notebook) may require a specific option to be installed. -->

  Even if you are installing and running AutoGen locally outside of docker, the recommendation and default behavior of agents is to perform [code execution](https://autogen-ai.github.io/autogen/docs/FAQ/#code-execution) in docker. Find more instructions and how to change the default behaviour [here](https://autogen-ai.github.io/autogen/docs/Installation#code-execution-with-docker-(default)).

  For LLM inference configurations, check the [FAQs](https://autogen-ai.github.io/autogen/docs/FAQ#set-your-api-endpoints).

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Autogen enables the next-gen LLM applications with a generic [multi-agent conversation](https://autogen-ai.github.io/autogen/docs/Use-Cases/agent_chat) framework. It offers customizable and conversable agents that integrate LLMs, tools, and humans.
  By automating chat among multiple capable agents, one can easily make them collectively perform tasks autonomously or with human feedback, including tasks that require using tools via code.

  Features of this use case include:

  - **Multi-agent conversations**: AutoGen agents can communicate with each other to solve tasks. This allows for more complex and sophisticated applications than would be possible with a single LLM.
  - **Customization**: AutoGen agents can be customized to meet the specific needs of an application. This includes the ability to choose the LLMs to use, the types of human input to allow, and the tools to employ.
  - **Human participation**: AutoGen seamlessly allows human participation. This means that humans can provide input and feedback to the agents as needed.

  For [example](https://github.com/autogen-ai/autogen/blob/main/test/twoagent.py),

  ```python
  from autogen import AssistantAgent, UserProxyAgent, config_list_from_json



  config_list = config_list_from_json(env_or_file="OAI_CONFIG_LIST")

  assistant = AssistantAgent("assistant", llm_config={"config_list": config_list})
  user_proxy = UserProxyAgent("user_proxy", code_execution_config={"work_dir": "coding", "use_docker": False}) # IMPORTANT: set to True to run code in docker, recommended
  user_proxy.initiate_chat(assistant, message="Plot a chart of NVDA and TESLA stock price change YTD.")

  ```

  This example can be run with

  ```python
  python test/twoagent.py
  ```

  After the repo is cloned.
  The figure below shows an example conversation flow with AutoGen.
  ![Agent Chat Example](https://github.com/autogen-ai/autogen/blob/main/website/static/img/chat_example.png)

  Alternatively, the [sample code](https://github.com/autogen-ai/build-with-autogen/blob/main/samples/simple_chat.py) here allows a user to chat with an AutoGen agent in ChatGPT style.
  Please find more [code examples](https://autogen-ai.github.io/autogen/docs/Examples#automated-multi-agent-chat) for this feature.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Autogen also helps maximize the utility out of the expensive LLMs such as ChatGPT and GPT-4. It offers [enhanced LLM inference](https://autogen-ai.github.io/autogen/docs/Use-Cases/enhanced_inference#api-unification) with powerful functionalities like caching, error handling, multi-config inference and templating.

  <!-- For example, you can optimize generations by LLM with your own tuning data, success metrics, and budgets.

  ```python

  config, analysis = autogen.Completion.tune(
      data=tune_data,
      metric="success",
      mode="max",
      eval_func=eval_func,
      inference_budget=0.05,
      optimization_budget=3,
      num_samples=-1,
  )

  response = autogen.Completion.create(context=test_instance, **config)
  ```

  Please find more [code examples](https://autogen-ai.github.io/autogen/docs/Examples#tune-gpt-models) for this feature. -->

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  You can find detailed documentation about AutoGen [here](https://autogen-ai.github.io/autogen/).

  In addition, you can find:

  - [Research](https://autogen-ai.github.io/autogen/docs/Research), [blogposts](https://autogen-ai.github.io/autogen/blog) around AutoGen, and [Transparency FAQs](https://github.com/autogen-ai/autogen/blob/main/TRANSPARENCY_FAQS.md)

  - [Discord](https://discord.gg/pAbnFJrkgZ)

  - [Contributing guide](https://autogen-ai.github.io/autogen/docs/Contribute)

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Explore detailed implementations with sample code and applications to help you get started with AutoGen.
  [Cookbook](https://github.com/autogen-ai/build-with-autogen)




  [AutoGen](https://arxiv.org/abs/2308.08155)

  ```
  @inproceedings{wu2023autogen,
        title={AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework},
        author={Qingyun Wu and Gagan Bansal and Jieyu Zhang and Yiran Wu and Beibin Li and Erkang Zhu and Li Jiang and Xiaoyun Zhang and Shaokun Zhang and Jiale Liu and Ahmed Hassan Awadallah and Ryen W White and Doug Burger and Chi Wang},
        year={2023},
        eprint={2308.08155},
        archivePrefix={arXiv},
        primaryClass={cs.AI}
  }
  ```

  [EcoOptiGen](https://arxiv.org/abs/2303.04673)

  ```
  @inproceedings{wang2023EcoOptiGen,
      title={Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference},
      author={Chi Wang and Susan Xueqing Liu and Ahmed H. Awadallah},
      year={2023},
      booktitle={AutoML'23},
  }
  ```

  [MathChat](https://arxiv.org/abs/2306.01337)

  ```
  @inproceedings{wu2023empirical,
      title={An Empirical Study on Challenging Math Problem Solving with GPT-4},
      author={Yiran Wu and Feiran Jia and Shaokun Zhang and Hangyu Li and Erkang Zhu and Yue Wang and Yin Tat Lee and Richard Peng and Qingyun Wu and Chi Wang},
      year={2023},
      booktitle={ArXiv preprint arXiv:2306.01337},
  }
  ```

  [AgentOptimizer](https://arxiv.org/pdf/2402.11359)

  ```
  @article{zhang2024training,
    title={Training Language Model Agents without Modifying Language Models},
    author={Zhang, Shaokun and Zhang, Jieyu and Liu, Jiale and Song, Linxin and Wang, Chi and Krishna, Ranjay and Wu, Qingyun},
    journal={ICML'24},
    year={2024}
  }
  ```

  [StateFlow](https://arxiv.org/abs/2403.11322)
  ```
  @article{wu2024stateflow,
    title={StateFlow: Enhancing LLM Task-Solving through State-Driven Workflows},
    author={Wu, Yiran and Yue, Tianwei and Zhang, Shaokun and Wang, Chi and Wu, Qingyun},
    journal={arXiv preprint arXiv:2403.11322},
    year={2024}
  }
  ```

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


  <a href="https://github.com/autogen-ai/autogen/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=autogen-ai/autogen&max=204" />
  </a>

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


  This project is licensed under the [Apache License, Version 2.0 (Apache-2.0)](./LICENSE).

  This project is a fork of https://github.com/microsoft/autogen and contains code under two licenses:

  - The original code from https://github.com/microsoft/autogen is licensed under the MIT License.  See the [LICENSE_original_MIT](./license_original/LICENSE_original_MIT) file for details.

  - Modifications and additions made in this fork are licensed under the Apache License, Version 2.0. See the  [LICENSE](./LICENSE) file for the full license text.

  We have documented these changes for clarity and to ensure transparency with our user and contributor community. For more details, please see the [NOTICE](./NOTICE.md) file.


pkgId: 95909007a9503fc5c360618b52c251200b822c7518abba70b13649456c1f8da6
name: python-autogen
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: A programming framework for agentic AI
url: https://github.com/ag2ai/ag2
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogen-0.3.2-1.src.rpm
checksum_type: sha256
description:
  <a name="readme-top"></a>

  [![PyPI version](https://badge.fury.io/py/autogen.svg)](https://badge.fury.io/py/autogen)
  [![Build](https://github.com/ag2ai/ag2/actions/workflows/python-package.yml/badge.svg)](https://github.com/ag2ai/ag2/actions/workflows/python-package.yml)
  ![Python Version](https://img.shields.io/badge/3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)
  [![Discord](https://img.shields.io/discord/1153072414184452236?logo=discord&style=flat)](https://discord.gg/pAbnFJrkgZ)
  [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/cloudposse.svg?style=social&label=Follow%20%40ag2ai)](https://x.com/ag2ai)

  <!-- [![NuGet version](https://badge.fury.io/nu/AutoGen.Core.svg)](https://badge.fury.io/nu/AutoGen.Core) -->



  [📚 Cite paper](#related-papers).
  <!-- <p align="center">
      <img src="https://github.com/ag2ai/ag2/blob/main/website/static/img/flaml.svg"  width=200>
      <br>
  </p> -->

  > [!IMPORTANT]
  >
  > :fire: :tada: Nov 11, 2024: We are evolving AutoGen into AG2! A new organization [ag2ai](https://github.com/ag2ai) is created to host the development of AG2 and related projects with open governance. We invite collaborators from all organizations and individuals to join the development.


  :fire: :tada: AG2 is available via `ag2` (or its alias  `autogen` or  `pyautogen`)  on PyPI! Starting with version 0.3.2, you can now install AG2 using:
  ```
  pip install ag2
  ```
  or
  ```
  pip install pyautogen
  ```
  or
  ```
  pip install autogen
  ```


  📄 **License:**
  We adopt the Apache 2.0 license from v0.3. This enhances our commitment to open-source collaboration while providing additional protections for contributors and users alike.


  :tada: May 29, 2024: DeepLearning.ai launched a new short course [AI Agentic Design Patterns with AutoGen](https://www.deeplearning.ai/short-courses/ai-agentic-design-patterns-with-autogen), made in collaboration with Microsoft and Penn State University, and taught by AutoGen creators [Chi Wang](https://github.com/sonichi) and [Qingyun Wu](https://github.com/qingyun-wu).

  :tada: May 24, 2024: Foundation Capital published an article on [Forbes: The Promise of Multi-Agent AI](https://www.forbes.com/sites/joannechen/2024/05/24/the-promise-of-multi-agent-ai/?sh=2c1e4f454d97) and a video [AI in the Real World Episode 2: Exploring Multi-Agent AI and AutoGen with Chi Wang](https://www.youtube.com/watch?v=RLwyXRVvlNk).

  :tada: May 13, 2024: [The Economist](https://www.economist.com/science-and-technology/2024/05/13/todays-ai-models-are-impressive-teams-of-them-will-be-formidable) published an article about multi-agent systems (MAS) following a January 2024 interview with [Chi Wang](https://github.com/sonichi).

  :tada: May 11, 2024: [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation](https://openreview.net/pdf?id=uAjxFFing2) received the best paper award at the [ICLR 2024 LLM Agents Workshop](https://llmagents.github.io/).

  <!-- :tada: Apr 26, 2024: [AutoGen.NET](https://ag2ai.github.io/ag2-for-net/) is available for .NET developers! -->

  :tada: Apr 17, 2024: Andrew Ng cited AutoGen in [The Batch newsletter](https://www.deeplearning.ai/the-batch/issue-245/) and [What's next for AI agentic workflows](https://youtu.be/sal78ACtGTc?si=JduUzN_1kDnMq0vF) at Sequoia Capital's AI Ascent (Mar 26).

  :tada: Mar 3, 2024: What's new in AutoGen? 📰[Blog](https://ag2ai.github.io/ag2/blog/2024/03/03/AutoGen-Update); 📺[Youtube](https://www.youtube.com/watch?v=j_mtwQiaLGU).

  <!-- :tada: Mar 1, 2024: the first AutoGen multi-agent experiment on the challenging [GAIA](https://huggingface.co/spaces/gaia-benchmark/leaderboard) benchmark achieved the No. 1 accuracy in all the three levels. -->

  <!-- :tada: Jan 30, 2024: AutoGen is highlighted by Peter Lee in Microsoft Research Forum [Keynote](https://t.co/nUBSjPDjqD). -->

  :tada: Dec 31, 2023: [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework](https://arxiv.org/abs/2308.08155) is selected by [TheSequence: My Five Favorite AI Papers of 2023](https://thesequence.substack.com/p/my-five-favorite-ai-papers-of-2023).

  <!-- :fire: Nov 24: pyautogen [v0.2](https://github.com/microsoft/autogen/releases/tag/v0.2.0) is released with many updates and new features compared to v0.1.1. It switches to using openai-python v1. Please read the [migration guide](https://ag2ai.github.io/ag2/docs/Installation#python). -->

  <!-- :fire: Nov 11: OpenAI's Assistants are available in AutoGen and interoperatable with other AutoGen agents! Checkout our [blogpost](https://ag2ai.github.io/ag2/blog/2023/11/13/OAI-assistants) for details and examples. -->

  :tada: Nov 8, 2023: AutoGen is selected into [Open100: Top 100 Open Source achievements](https://www.benchcouncil.org/evaluation/opencs/annual.html) 35 days after spinoff from [FLAML](https://github.com/microsoft/FLAML).

  <!-- :tada: Nov 6, 2023: AutoGen is mentioned by Satya Nadella in a [fireside chat](https://youtu.be/0pLBvgYtv6U). -->

  <!-- :tada: Nov 1, 2023: AutoGen is the top trending repo on GitHub in October 2023. -->

  <!-- :tada: Oct 03, 2023: AutoGen spins off from [FLAML](https://github.com/microsoft/FLAML) on GitHub. -->

  <!-- :tada: Aug 16: Paper about AutoGen on [arxiv](https://arxiv.org/abs/2308.08155). -->

  :tada: Mar 29, 2023: AutoGen is first created in [FLAML](https://github.com/microsoft/FLAML).

  <!--
  :fire: FLAML is highlighted in OpenAI's [cookbook](https://github.com/openai/openai-cookbook#related-resources-from-around-the-web).

  :fire: [autogen](https://ag2ai.github.io/ag2/) is released with support for ChatGPT and GPT-4, based on [Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference](https://arxiv.org/abs/2303.04673).

  :fire: FLAML supports Code-First AutoML & Tuning – Private Preview in [Microsoft Fabric Data Science](https://learn.microsoft.com/en-us/fabric/data-science/). -->



  AG2 (formally AutoGen) is an open-source programming framework for building AI agents and facilitating cooperation among multiple agents to solve tasks. AG2 aims to streamline the development and research of agentic AI, much like PyTorch does for Deep Learning. It offers features such as agents capable of interacting with each other, facilitates the use of various large language models (LLMs) and tool use support, autonomous and human-in-the-loop workflows, and multi-agent conversation patterns.

  **Open Source Statement**: The project welcomes contributions from developers and organizations worldwide. Our goal is to foster a collaborative and inclusive community where diverse perspectives and expertise can drive innovation and enhance the project's capabilities. Whether you are an individual contributor or represent an organization, we invite you to join us in shaping the future of this project. Together, we can build something truly remarkable.

  The project is currently maintained by a [dynamic group of volunteers](MAINTAINERS.md) from several organizations. Contact project administrators Chi Wang and Qingyun Wu via [support@ag2.ai](mailto:support@ag2.ai) if you are interested in becoming a maintainer.


  ![AutoGen Overview](./website/static/img/autogen_agentchat.png)



  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>

  <!--

  -->


  The easiest way to start playing is
  1. Click below to use the GitHub Codespace

      [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/ag2ai/ag2?quickstart=1)

   2. Copy OAI_CONFIG_LIST_sample to ./notebook folder, name to OAI_CONFIG_LIST, and set the correct configuration.
   3. Start playing with the notebooks!

  *NOTE*: OAI_CONFIG_LIST_sample lists gpt-4o as the default model. If you use a different model, you may need to revise various system prompts (especially if using weaker models like gpt-4o-mini). Proceed with caution when updating this default and be aware of additional risks related to alignment and safety.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>





  Find detailed instructions for users [here](https://ag2ai.github.io/ag2/docs/installation/Docker#step-1-install-docker), and for developers [here](https://ag2ai.github.io/ag2/docs/Contribute#docker-for-development).



  AG2 requires **Python version >= 3.8, < 3.13**. It can be installed from pip:

  ```bash
  pip install ag2
  ```

  Minimal dependencies are installed without extra options. You can install extra options based on the feature you need.

  <!-- For example, use the following to install the dependencies needed by the [`blendsearch`](https://microsoft.github.io/FLAML/docs/Use-Cases/Tune-User-Defined-Function#blendsearch-economical-hyperparameter-optimization-with-blended-search-strategy) option.
  ```bash
  pip install "autogen[blendsearch]"
  ``` -->

  Find more options in [Installation](https://ag2ai.github.io/ag2/docs/Installation#option-2-install-autogen-locally-using-virtual-environment).

  <!-- Each of the [`notebook examples`](https://github.com/ag2ai/ag2/tree/main/notebook) may require a specific option to be installed. -->

  Even if you are installing and running AG2 locally outside of docker, the recommendation and default behavior of agents is to perform [code execution](https://ag2ai.github.io/ag2/docs/FAQ/#code-execution) in docker. Find more instructions and how to change the default behaviour [here](https://ag2ai.github.io/ag2/docs/Installation#code-execution-with-docker-(default)).

  For LLM inference configurations, check the [FAQs](https://ag2ai.github.io/ag2/docs/FAQ#set-your-api-endpoints).

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  AG2 enables the next-gen LLM applications with a generic [multi-agent conversation](https://ag2ai.github.io/ag2/docs/Use-Cases/agent_chat) framework. It offers customizable and conversable agents that integrate LLMs, tools, and humans.
  By automating chat among multiple capable agents, one can easily make them collectively perform tasks autonomously or with human feedback, including tasks that require using tools via code.

  Features of this use case include:

  - **Multi-agent conversations**: AG2 agents can communicate with each other to solve tasks. This allows for more complex and sophisticated applications than would be possible with a single LLM.
  - **Customization**: AG2 agents can be customized to meet the specific needs of an application. This includes the ability to choose the LLMs to use, the types of human input to allow, and the tools to employ.
  - **Human participation**: AG2 seamlessly allows human participation. This means that humans can provide input and feedback to the agents as needed.

  For [example](https://github.com/ag2ai/ag2/blob/main/test/twoagent.py),

  ```python
  from autogen import AssistantAgent, UserProxyAgent, config_list_from_json



  config_list = config_list_from_json(env_or_file="OAI_CONFIG_LIST")

  assistant = AssistantAgent("assistant", llm_config={"config_list": config_list})
  user_proxy = UserProxyAgent("user_proxy", code_execution_config={"work_dir": "coding", "use_docker": False}) # IMPORTANT: set to True to run code in docker, recommended
  user_proxy.initiate_chat(assistant, message="Plot a chart of NVDA and TESLA stock price change YTD.")

  ```

  This example can be run with

  ```python
  python test/twoagent.py
  ```

  After the repo is cloned.
  The figure below shows an example conversation flow with AG2.

  ![Agent Chat Example](./website/static/img/chat_example.png)


  Alternatively, the [sample code](https://github.com/ag2ai/build-with-autogen/blob/main/samples/simple_chat.py) here allows a user to chat with an AG2 agent in ChatGPT style.
  Please find more [code examples](https://ag2ai.github.io/ag2/docs/Examples#automated-multi-agent-chat) for this feature.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  AG2 also helps maximize the utility out of the expensive LLMs such as gpt-4o. It offers [enhanced LLM inference](https://ag2ai.github.io/ag2/docs/Use-Cases/enhanced_inference#api-unification) with powerful functionalities like caching, error handling, multi-config inference and templating.

  <!-- For example, you can optimize generations by LLM with your own tuning data, success metrics, and budgets.

  ```python

  config, analysis = autogen.Completion.tune(
      data=tune_data,
      metric="success",
      mode="max",
      eval_func=eval_func,
      inference_budget=0.05,
      optimization_budget=3,
      num_samples=-1,
  )

  response = autogen.Completion.create(context=test_instance, **config)
  ```

  Please find more [code examples](https://ag2ai.github.io/ag2/docs/Examples#tune-gpt-models) for this feature. -->

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  You can find detailed documentation about AG2 [here](https://ag2ai.github.io/ag2/).

  In addition, you can find:

  - [Research](https://ag2ai.github.io/ag2/docs/Research), [blogposts](https://ag2ai.github.io/ag2/blog) around AG2, and [Transparency FAQs](https://github.com/ag2ai/ag2/blob/main/TRANSPARENCY_FAQS.md)

  - [Discord](https://discord.gg/pAbnFJrkgZ)

  - [Contributing guide](https://ag2ai.github.io/ag2/docs/Contribute)

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Explore detailed implementations with sample code and applications to help you get started with AG2.
  [Cookbook](https://github.com/ag2ai/build-with-autogen)




  [AG2](https://arxiv.org/abs/2308.08155)

  ```
  @inproceedings{wu2023autogen,
        title={AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework},
        author={Qingyun Wu and Gagan Bansal and Jieyu Zhang and Yiran Wu and Beibin Li and Erkang Zhu and Li Jiang and Xiaoyun Zhang and Shaokun Zhang and Jiale Liu and Ahmed Hassan Awadallah and Ryen W White and Doug Burger and Chi Wang},
        year={2023},
        eprint={2308.08155},
        archivePrefix={arXiv},
        primaryClass={cs.AI}
  }
  ```

  [EcoOptiGen](https://arxiv.org/abs/2303.04673)

  ```
  @inproceedings{wang2023EcoOptiGen,
      title={Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference},
      author={Chi Wang and Susan Xueqing Liu and Ahmed H. Awadallah},
      year={2023},
      booktitle={AutoML'23},
  }
  ```

  [MathChat](https://arxiv.org/abs/2306.01337)

  ```
  @inproceedings{wu2023empirical,
      title={An Empirical Study on Challenging Math Problem Solving with GPT-4},
      author={Yiran Wu and Feiran Jia and Shaokun Zhang and Hangyu Li and Erkang Zhu and Yue Wang and Yin Tat Lee and Richard Peng and Qingyun Wu and Chi Wang},
      year={2023},
      booktitle={ArXiv preprint arXiv:2306.01337},
  }
  ```

  [AgentOptimizer](https://arxiv.org/pdf/2402.11359)

  ```
  @article{zhang2024training,
    title={Training Language Model Agents without Modifying Language Models},
    author={Zhang, Shaokun and Zhang, Jieyu and Liu, Jiale and Song, Linxin and Wang, Chi and Krishna, Ranjay and Wu, Qingyun},
    journal={ICML'24},
    year={2024}
  }
  ```

  [StateFlow](https://arxiv.org/abs/2403.11322)
  ```
  @article{wu2024stateflow,
    title={StateFlow: Enhancing LLM Task-Solving through State-Driven Workflows},
    author={Wu, Yiran and Yue, Tianwei and Zhang, Shaokun and Wang, Chi and Wu, Qingyun},
    journal={arXiv preprint arXiv:2403.11322},
    year={2024}
  }
  ```

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


  <a href="https://github.com/ag2ai/ag2/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=ag2ai/ag2&max=204" />
  </a>

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


  This project is licensed under the [Apache License, Version 2.0 (Apache-2.0)](./LICENSE).

  This project is a spin-off of https://github.com/microsoft/autogen and contains code under two licenses:

  - The original code from https://github.com/microsoft/autogen is licensed under the MIT License.  See the [LICENSE_original_MIT](./license_original/LICENSE_original_MIT) file for details.

  - Modifications and additions made in this fork are licensed under the Apache License, Version 2.0. See the  [LICENSE](./LICENSE) file for the full license text.

  We have documented these changes for clarity and to ensure transparency with our user and contributor community. For more details, please see the [NOTICE](./NOTICE.md) file.


pkgId: 4fea8d09597eb2a1dfd2c711d90b2733fb770b01b251aa29e013575eef53d86c
name: python-autogen-agentchat
arch: src
version: 0.2.38
epoch: 0
release: 1
summary: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework
url: https://github.com/microsoft/autogen
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogen-agentchat-0.2.38-1.src.rpm
checksum_type: sha256
description:
  <a name="readme-top"></a>


  <div align="center">

  <img src="https://microsoft.github.io/autogen/0.2/img/ag.svg" alt="AutoGen Logo" width="100">

  ![Python Version](https://img.shields.io/badge/3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue) [![PyPI - Version](https://img.shields.io/pypi/v/autogen-agentchat)](https://pypi.org/project/autogen-agentchat/)
  [![NuGet version](https://badge.fury.io/nu/AutoGen.Core.svg)](https://badge.fury.io/nu/AutoGen.Core)

  [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/cloudposse.svg?style=social&label=Follow%20%40pyautogen)](https://twitter.com/pyautogen)

  </div>



  AutoGen is an open-source programming framework for building AI agents and facilitating cooperation among multiple agents to solve tasks. AutoGen aims to streamline the development and research of agentic AI, much like PyTorch does for Deep Learning. It offers features such as agents capable of interacting with each other, facilitates the use of various large language models (LLMs) and tool use support, autonomous and human-in-the-loop workflows, and multi-agent conversation patterns.

  > [!IMPORTANT]
  > In order to better align with a new multi-packaging structure we have coming very soon, AutoGen is now available on PyPi as [`autogen-agentchat`](https://pypi.org/project/autogen-agentchat/) as of version `0.2.36`. This is the official package for the AutoGen project.


  > [!NOTE]
  > *Note for contributors and users*</b>: [microsoft/autogen](https://aka.ms/autogen-gh) is the original repository of AutoGen project and it is under active development and maintenance under MIT license. We welcome contributions from developers and organizations worldwide. Our goal is to foster a collaborative and inclusive community where diverse perspectives and expertise can drive innovation and enhance the project's capabilities. We acknowledge the invaluable contributions from our existing contributors, as listed in [contributors.md](./CONTRIBUTORS.md). Whether you are an individual contributor or represent an organization, we invite you to join us in shaping the future of this project. For further information please also see [Microsoft open-source contributing guidelines](https://github.com/microsoft/autogen?tab=readme-ov-file#contributing).
  >
  > -_Maintainers (Sept 6th, 2024)_


  ![AutoGen Overview](https://github.com/microsoft/autogen/blob/0.2/website/static/img/autogen_agentchat.png)

  - AutoGen enables building next-gen LLM applications based on [multi-agent conversations](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat) with minimal effort. It simplifies the orchestration, automation, and optimization of a complex LLM workflow. It maximizes the performance of LLM models and overcomes their weaknesses.
  - It supports [diverse conversation patterns](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat#supporting-diverse-conversation-patterns) for complex workflows. With customizable and conversable agents, developers can use AutoGen to build a wide range of conversation patterns concerning conversation autonomy,
    the number of agents, and agent conversation topology.
  - It provides a collection of working systems with different complexities. These systems span a [wide range of applications](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat#diverse-applications-implemented-with-autogen) from various domains and complexities. This demonstrates how AutoGen can easily support diverse conversation patterns.
  - AutoGen provides [enhanced LLM inference](https://microsoft.github.io/autogen/docs/Use-Cases/enhanced_inference#api-unification). It offers utilities like API unification and caching, and advanced usage patterns, such as error handling, multi-config inference, context programming, etc.

  AutoGen was created out of collaborative [research](https://microsoft.github.io/autogen/docs/Research) from Microsoft, Penn State University, and the University of Washington.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>




  <details>

  <summary>Expand</summary>

  :fire: June 6, 2024: WIRED publishes a new article on AutoGen: [Chatbot Teamwork Makes the AI Dream Work](https://www.wired.com/story/chatbot-teamwork-makes-the-ai-dream-work/) based on interview with [Adam Fourney](https://github.com/afourney).

  :fire: June 4th, 2024: Microsoft Research Forum publishes new update and video on [AutoGen and Complex Tasks](https://www.microsoft.com/en-us/research/video/autogen-update-complex-tasks-and-agents/) presented by [Adam Fourney](https://github.com/afourney).

  :fire: May 29, 2024: DeepLearning.ai launched a new short course [AI Agentic Design Patterns with AutoGen](https://www.deeplearning.ai/short-courses/ai-agentic-design-patterns-with-autogen), made in collaboration with Microsoft and Penn State University, and taught by AutoGen creators [Chi Wang](https://github.com/sonichi) and [Qingyun Wu](https://github.com/qingyun-wu).

  :fire: May 24, 2024: Foundation Capital published an article on [Forbes: The Promise of Multi-Agent AI](https://www.forbes.com/sites/joannechen/2024/05/24/the-promise-of-multi-agent-ai/?sh=2c1e4f454d97) and a video [AI in the Real World Episode 2: Exploring Multi-Agent AI and AutoGen with Chi Wang](https://www.youtube.com/watch?v=RLwyXRVvlNk).

  :fire: May 13, 2024: [The Economist](https://www.economist.com/science-and-technology/2024/05/13/todays-ai-models-are-impressive-teams-of-them-will-be-formidable) published an article about multi-agent systems (MAS) following a January 2024 interview with [Chi Wang](https://github.com/sonichi).

  :fire: May 11, 2024: [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation](https://openreview.net/pdf?id=uAjxFFing2) received the best paper award at the [ICLR 2024 LLM Agents Workshop](https://llmagents.github.io/).

  :fire: Apr 26, 2024: [AutoGen.NET](https://microsoft.github.io/autogen-for-net/) is available for .NET developers! Thanks [XiaoYun Zhang](https://www.linkedin.com/in/xiaoyun-zhang-1b531013a/)

  :fire: Apr 17, 2024: Andrew Ng cited AutoGen in [The Batch newsletter](https://www.deeplearning.ai/the-batch/issue-245/) and [What's next for AI agentic workflows](https://youtu.be/sal78ACtGTc?si=JduUzN_1kDnMq0vF) at Sequoia Capital's AI Ascent (Mar 26).

  :fire: Mar 3, 2024: What's new in AutoGen? 📰[Blog](https://microsoft.github.io/autogen/blog/2024/03/03/AutoGen-Update); 📺[Youtube](https://www.youtube.com/watch?v=j_mtwQiaLGU).

  :fire: Mar 1, 2024: the first AutoGen multi-agent experiment on the challenging [GAIA](https://huggingface.co/spaces/gaia-benchmark/leaderboard) benchmark achieved the No. 1 accuracy in all the three levels.

  <!-- :tada: Jan 30, 2024: AutoGen is highlighted by Peter Lee in Microsoft Research Forum [Keynote](https://t.co/nUBSjPDjqD). -->

  :tada: Dec 31, 2023: [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework](https://arxiv.org/abs/2308.08155) is selected by [TheSequence: My Five Favorite AI Papers of 2023](https://thesequence.substack.com/p/my-five-favorite-ai-papers-of-2023).

  <!-- :fire: Nov 24: pyautogen [v0.2](https://github.com/microsoft/autogen/releases/tag/v0.2.0) is released with many updates and new features compared to v0.1.1. It switches to using openai-python v1. Please read the [migration guide](https://microsoft.github.io/autogen/docs/Installation#python). -->

  <!-- :fire: Nov 11: OpenAI's Assistants are available in AutoGen and interoperatable with other AutoGen agents! Checkout our [blogpost](https://microsoft.github.io/autogen/blog/2023/11/13/OAI-assistants) for details and examples. -->

  :tada: Nov 8, 2023: AutoGen is selected into [Open100: Top 100 Open Source achievements](https://www.benchcouncil.org/evaluation/opencs/annual.html) 35 days after spinoff from [FLAML](https://github.com/microsoft/FLAML).

  <!-- :tada: Nov 6, 2023: AutoGen is mentioned by Satya Nadella in a [fireside chat](https://youtu.be/0pLBvgYtv6U). -->

  <!-- :tada: Nov 1, 2023: AutoGen is the top trending repo on GitHub in October 2023. -->

  <!-- :tada: Oct 03, 2023: AutoGen spins off from [FLAML](https://github.com/microsoft/FLAML) on GitHub. -->

  <!-- :tada: Aug 16: Paper about AutoGen on [arxiv](https://arxiv.org/abs/2308.08155). -->

  :tada: Mar 29, 2023: AutoGen is first created in [FLAML](https://github.com/microsoft/FLAML).

  <!--
  :fire: FLAML is highlighted in OpenAI's [cookbook](https://github.com/openai/openai-cookbook#related-resources-from-around-the-web).

  :fire: [autogen](https://microsoft.github.io/autogen/) is released with support for ChatGPT and GPT-4, based on [Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference](https://arxiv.org/abs/2303.04673).

  :fire: FLAML supports Code-First AutoML & Tuning – Private Preview in [Microsoft Fabric Data Science](https://learn.microsoft.com/en-us/fabric/data-science/). -->

  </details>



  To see what we are working on and what we plan to work on, please check our
  [Roadmap Issues](https://aka.ms/autogen-roadmap).

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


  The easiest way to start playing is
  1. Click below to use the GitHub Codespace

      [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/microsoft/autogen?quickstart=1)

   2. Copy OAI_CONFIG_LIST_sample to ./notebook folder, name to OAI_CONFIG_LIST, and set the correct configuration.
   3. Start playing with the notebooks!

  *NOTE*: OAI_CONFIG_LIST_sample lists GPT-4 as the default model, as this represents our current recommendation, and is known to work well with AutoGen. If you use a model other than GPT-4, you may need to revise various system prompts (especially if using weaker models like GPT-3.5-turbo). Moreover, if you use models other than those hosted by OpenAI or Azure, you may incur additional risks related to alignment and safety. Proceed with caution if updating this default.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>




  Find detailed instructions for users [here](https://microsoft.github.io/autogen/docs/installation/Docker#step-1-install-docker), and for developers [here](https://microsoft.github.io/autogen/docs/Contribute#docker-for-development).



  AutoGen requires **Python version >= 3.8, < 3.13**. It can be installed from pip:

  ```bash
  pip install autogen-agentchat~=0.2
  ```

  Minimal dependencies are installed without extra options. You can install extra options based on the feature you need.

  <!-- For example, use the following to install the dependencies needed by the [`blendsearch`](https://microsoft.github.io/FLAML/docs/Use-Cases/Tune-User-Defined-Function#blendsearch-economical-hyperparameter-optimization-with-blended-search-strategy) option.
  ```bash
  pip install "autogen-agentchat[blendsearch]~=0.2"
  ``` -->

  Find more options in [Installation](https://microsoft.github.io/autogen/docs/Installation#option-2-install-autogen-locally-using-virtual-environment).

  <!-- Each of the [`notebook examples`](https://github.com/microsoft/autogen/tree/main/notebook) may require a specific option to be installed. -->

  Even if you are installing and running AutoGen locally outside of docker, the recommendation and default behavior of agents is to perform [code execution](https://microsoft.github.io/autogen/docs/FAQ/#code-execution) in docker. Find more instructions and how to change the default behaviour [here](https://microsoft.github.io/autogen/docs/Installation#code-execution-with-docker-(default)).

  For LLM inference configurations, check the [FAQs](https://microsoft.github.io/autogen/docs/FAQ#set-your-api-endpoints).

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Autogen enables the next-gen LLM applications with a generic [multi-agent conversation](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat) framework. It offers customizable and conversable agents that integrate LLMs, tools, and humans.
  By automating chat among multiple capable agents, one can easily make them collectively perform tasks autonomously or with human feedback, including tasks that require using tools via code.

  Features of this use case include:

  - **Multi-agent conversations**: AutoGen agents can communicate with each other to solve tasks. This allows for more complex and sophisticated applications than would be possible with a single LLM.
  - **Customization**: AutoGen agents can be customized to meet the specific needs of an application. This includes the ability to choose the LLMs to use, the types of human input to allow, and the tools to employ.
  - **Human participation**: AutoGen seamlessly allows human participation. This means that humans can provide input and feedback to the agents as needed.

  For [example](https://github.com/microsoft/autogen/blob/0.2/test/twoagent.py),

  ```python
  from autogen import AssistantAgent, UserProxyAgent, config_list_from_json



  config_list = config_list_from_json(env_or_file="OAI_CONFIG_LIST")

  assistant = AssistantAgent("assistant", llm_config={"config_list": config_list})
  user_proxy = UserProxyAgent("user_proxy", code_execution_config={"work_dir": "coding", "use_docker": False}) # IMPORTANT: set to True to run code in docker, recommended
  user_proxy.initiate_chat(assistant, message="Plot a chart of NVDA and TESLA stock price change YTD.")

  ```

  This example can be run with

  ```python
  python test/twoagent.py
  ```

  After the repo is cloned.
  The figure below shows an example conversation flow with AutoGen.
  ![Agent Chat Example](https://github.com/microsoft/autogen/blob/0.2/website/static/img/chat_example.png)

  Alternatively, the [sample code](https://github.com/microsoft/autogen/blob/0.2/samples/simple_chat.py) here allows a user to chat with an AutoGen agent in ChatGPT style.
  Please find more [code examples](https://microsoft.github.io/autogen/docs/Examples#automated-multi-agent-chat) for this feature.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Autogen also helps maximize the utility out of the expensive LLMs such as ChatGPT and GPT-4. It offers [enhanced LLM inference](https://microsoft.github.io/autogen/docs/Use-Cases/enhanced_inference#api-unification) with powerful functionalities like caching, error handling, multi-config inference and templating.

  <!-- For example, you can optimize generations by LLM with your own tuning data, success metrics, and budgets.

  ```python

  config, analysis = autogen.Completion.tune(
      data=tune_data,
      metric="success",
      mode="max",
      eval_func=eval_func,
      inference_budget=0.05,
      optimization_budget=3,
      num_samples=-1,
  )

  response = autogen.Completion.create(context=test_instance, **config)
  ```

  Please find more [code examples](https://microsoft.github.io/autogen/docs/Examples#tune-gpt-models) for this feature. -->

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  You can find detailed documentation about AutoGen [here](https://microsoft.github.io/autogen/).

  In addition, you can find:

  - [Research](https://microsoft.github.io/autogen/docs/Research), [blogposts](https://microsoft.github.io/autogen/blog) around AutoGen, and [Transparency FAQs](https://github.com/microsoft/autogen/blob/0.2/TRANSPARENCY_FAQS.md)

  - [Contributing guide](https://microsoft.github.io/autogen/docs/Contribute)

  - [Roadmap](https://github.com/orgs/microsoft/projects/989/views/3)

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  [AutoGen Studio](https://www.microsoft.com/en-us/research/publication/autogen-studio-a-no-code-developer-tool-for-building-and-debugging-multi-agent-systems/)

  ```
  @inproceedings{dibia2024studio,
        title={AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems},
        author={Victor Dibia and Jingya Chen and Gagan Bansal and Suff Syed and Adam Fourney and Erkang (Eric) Zhu and Chi Wang and Saleema Amershi},
        year={2024},
        booktitle={Pre-Print}
  }
  ```

  [AutoGen](https://aka.ms/autogen-pdf)

  ```
  @inproceedings{wu2023autogen,
        title={AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework},
        author={Qingyun Wu and Gagan Bansal and Jieyu Zhang and Yiran Wu and Beibin Li and Erkang Zhu and Li Jiang and Xiaoyun Zhang and Shaokun Zhang and Jiale Liu and Ahmed Hassan Awadallah and Ryen W White and Doug Burger and Chi Wang},
        year={2024},
        booktitle={COLM},
  }
  ```

  [EcoOptiGen](https://arxiv.org/abs/2303.04673)

  ```
  @inproceedings{wang2023EcoOptiGen,
      title={Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference},
      author={Chi Wang and Susan Xueqing Liu and Ahmed H. Awadallah},
      year={2023},
      booktitle={AutoML'23},
  }
  ```

  [MathChat](https://arxiv.org/abs/2306.01337)

  ```
  @inproceedings{wu2023empirical,
      title={An Empirical Study on Challenging Math Problem Solving with GPT-4},
      author={Yiran Wu and Feiran Jia and Shaokun Zhang and Hangyu Li and Erkang Zhu and Yue Wang and Yin Tat Lee and Richard Peng and Qingyun Wu and Chi Wang},
      year={2023},
      booktitle={ArXiv preprint arXiv:2306.01337},
  }
  ```

  [AgentOptimizer](https://arxiv.org/pdf/2402.11359)

  ```
  @article{zhang2024training,
    title={Training Language Model Agents without Modifying Language Models},
    author={Zhang, Shaokun and Zhang, Jieyu and Liu, Jiale and Song, Linxin and Wang, Chi and Krishna, Ranjay and Wu, Qingyun},
    journal={ICML'24},
    year={2024}
  }
  ```

  [StateFlow](https://arxiv.org/abs/2403.11322)
  ```
  @article{wu2024stateflow,
    title={StateFlow: Enhancing LLM Task-Solving through State-Driven Workflows},
    author={Wu, Yiran and Yue, Tianwei and Zhang, Shaokun and Wang, Chi and Wu, Qingyun},
    journal={arXiv preprint arXiv:2403.11322},
    year={2024}
  }
  ```

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  This project welcomes contributions and suggestions. Most contributions require you to agree to a
  Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
  the rights to use your contribution. For details, visit <https://cla.opensource.microsoft.com>.

  If you are new to GitHub, [here](https://opensource.guide/how-to-contribute/#how-to-submit-a-contribution) is a detailed help source on getting involved with development on GitHub.

  When you submit a pull request, a CLA bot will automatically determine whether you need to provide
  a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
  provided by the bot. You will only need to do this once across all repos using our CLA.

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

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


  <a href="https://github.com/microsoft/autogen/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=microsoft/autogen&max=204" />
  </a>

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>



  Microsoft and any contributors grant you a license to the Microsoft documentation and other content
  in this repository under the [Creative Commons Attribution 4.0 International Public License](https://creativecommons.org/licenses/by/4.0/legalcode),
  see the [LICENSE](LICENSE) file, and grant you a license to any code in the repository under the [MIT License](https://opensource.org/licenses/MIT), see the
  [LICENSE-CODE](LICENSE-CODE) file.

  Microsoft, Windows, Microsoft Azure, and/or other Microsoft products and services referenced in the documentation
  may be either trademarks or registered trademarks of Microsoft in the United States and/or other countries.
  The licenses for this project do not grant you rights to use any Microsoft names, logos, or trademarks.
  Microsoft's general trademark guidelines can be found at http://go.microsoft.com/fwlink/?LinkID=254653.

  Privacy information can be found at https://go.microsoft.com/fwlink/?LinkId=521839

  Microsoft and any contributors reserve all other rights, whether under their respective copyrights, patents,
  or trademarks, whether by implication, estoppel, or otherwise.

  <p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
    <a href="#readme-top" style="text-decoration: none; color: blue; font-weight: bold;">
      ↑ Back to Top ↑
    </a>
  </p>


pkgId: 27961534a09ffef6de3254b9f08f145140fb577fb27eea9cf035fc8314ce0c41
name: python-autogen-openaiext-client
arch: src
version: 0.0.1.dev1
epoch: 0
release: 1
summary: This is an autogen>=0.4 extension for integrating external models through the OpenAI API.
url: https://pypi.org/project/autogen-openaiext-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogen-openaiext-client-0.0.1.dev1-1.src.rpm
checksum_type: sha256
description:
  This Autogen client is to help interface with non-OpenAI LLMs through the OpenAI API.



  ```python
  from autogen_openaiext_client import GeminiChatCompletionClient
  import asyncio


  client = GeminiChatCompletionClient(model="gemini-1.5-flash", api_key=os.environ["GEMINI_API_KEY"])


  result = asyncio.run(
      client.create(
          [UserMessage(content="What is the capital of France?", source="user")]
      )
  )
  print(result.content)

  ```

  Currently, `Gemini`, `TogetherAI` and `Groq` clients are supported through the `GeminiChatCompletionClient`, `TogetherAIChatCompletionClient` and `GroqChatCompletionClient` respectively.

  Install [Magentic-One](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-magentic-one) and run `python examples/magentic_coder_example.py` for a sample usage with other autogen-based frameworks.





  1. Tool calling in Gemini through OpenAI API runs into issues.



  This is a community project for Autogen. Feel free to contribute via issues and PRs and I will try my best to get to it every 3 days.

rpm_license:
  MIT License  Copyright (c) 2024 Vaibhav Balloli  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: 924a1da7cb5036661d48609c395d9bc17bc034547e46ca4dc6e4377577c96e3d
name: python-autogen-watsonx-client
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: This is an autogen>=0.4 extension for watsonx client integration.
description: This is an autogen>=0.4 extension for watsonx client integration.
url: https://pypi.org/project/autogen-watsonx-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogen-watsonx-client-0.0.2-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 tsinggggg  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: 99a301719b530287017cfe475b4720650e3e23e85a53c9f62c4a6d24235a4a8c
name: python-autogen-watsonx-client
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: This is an autogen>=0.4 extension for watsonx client integration.
url: https://pypi.org/project/autogen-watsonx-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogen-watsonx-client-0.0.3-1.src.rpm
checksum_type: sha256
description:
  This is an autogen>=0.4 extension for watsonx client integration.



  - This is a community extension for the [Autogen](https://github.com/microsoft/autogen) project, specifically for the new [Autogen](https://microsoft.github.io/autogen/0.2/blog/2024/10/02/new-autogen-architecture-preview) architecture. The goal is to support IBM Watsonx.ai hosted LLMs in the Autogen framework.
  - This project is still in a very early stage under development, please create issues in this github repo for bug reports.
  - This project is a personal endeavor and is not affiliated with, endorsed by, or connected to any organization/employer in any way. The views, ideas, and opinions expressed in this project are solely my own and do not reflect those of others.




  - create a python environment with version `3.10` or above
  - `pip install --upgrade autogen-watsonx-client`
  - `pip install --upgrade autogen-agentchat>=0.4 --pre`
  - access to a watsonx.ai instance, setting up environment variables `WATSONX_API_KEY`, one of `WATSONX_SPACE_ID` or `WATSONX_PROJECT_ID`, optionally `WATSONX_URL`




  Importing dependencies:

  ```python
  import os

  from autogen_agentchat.agents import AssistantAgent
  from autogen_agentchat.task import Console, TextMentionTermination
  from autogen_agentchat.teams import RoundRobinGroupChat
  from autogen_watsonx_client.client import WatsonXChatCompletionClient
  from autogen_watsonx_client.config import WatsonxClientConfiguration
  ```

  Create a watsonx client

  ```python
  wx_config = WatsonxClientConfiguration(
      model_id="meta-llama/llama-3-2-90b-vision-instruct",  # pick a model you have access to on wx.ai here
      api_key=os.environ.get("WATSONX_API_KEY"),
      url=os.environ.get("WATSONX_URL"),
      space_id=os.environ.get("WATSONX_SPACE_ID"),
      project_id=os.environ.get("WATSONX_PROJECT_ID"),
  )

  wx_client = WatsonXChatCompletionClient(**wx_config)
  ```

  Define an agent using the watsonx client and register a dummy tool for querying weather

  ```python

  async def get_weather(city: str) -> str:
      return f"The weather in {city} is 73 degrees and Sunny."


  async def main() -> None:
      
      weather_agent = AssistantAgent(
          name="weather_agent",
          model_client=wx_client,
          tools=[get_weather],
      )

      
      termination = TextMentionTermination("TERMINATE")

      
      agent_team = RoundRobinGroupChat([weather_agent], termination_condition=termination)

      
      stream = agent_team.run_stream(task="What is the weather in New York?")
      await Console(stream)



  await main()
  ```

  Refer to [here](doc/README.md) for more detailed examples.

rpm_license:
  MIT License  Copyright (c) 2024 tsinggggg  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: ee16de29b075718a364e26bb8e8f26e4cbf8826d90ac260750006bd963810ae7
name: python-autogen-xai-client
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/autogen-xai-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogen-xai-client-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This is an autogen>=0.4 extension for xai client integration.



  - This project is still in a very early stage under development, please create issues in this github repo for bug reports.
  - This project is a personal endeavor and is not affiliated with, endorsed by, or connected to any organization/employer in any way. The views, ideas, and opinions expressed in this project are solely my own and do not reflect those of others.




  - create a python environment with version `3.10` or above
  - `pip install --upgrade autogen-xai-client`




  Importing dependencies:

  ```python
  import os

  from autogen_agentchat.agents import AssistantAgent
  from autogen_agentchat.task import Console, TextMentionTermination
  from autogen_agentchat.teams import RoundRobinGroupChat
  from autogen_xai_client import XAIChatCompletionClient
  from autogen_xai_client.config import XAIClientConfiguration
  ```

  Create a xai client

  ```python
  xai_client = XAIChatCompletionClient(
      base_url="https://api.x.ai/v1",
      model="grok-beta",
      api_key="<api_key>",
  )
  ```

  Define an agent using the xai client and register a dummy tool for querying weather

  ```python

  async def get_weather(city: str) -> str:
      return f"The weather in {city} is 73 degrees and Sunny."


  async def main() -> None:
      
      weather_agent = AssistantAgent(
          name="weather_agent",
          model_client=wx_client,
          tools=[get_weather],
      )

      
      termination = TextMentionTermination("TERMINATE")

      
      agent_team = RoundRobinGroupChat([weather_agent], termination_condition=termination)

      
      stream = agent_team.run_stream(task="What is the weather in New York?")
      await Console(stream)



  await main()
  ```


pkgId: e44355a856bf9a6b025dc6d26a9c56b5a3e6bd0ef3740d71292903c377cbef2d
name: python-autogenbench
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: AutoGen Testbed Tools
url: https://github.com/microsoft/autogen
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogenbench-0.0.3-1.src.rpm
checksum_type: sha256
description:
  AutoGenBench is a tool for repeatedly running a set of pre-defined AutoGen tasks in a setting with tightly-controlled initial conditions. With each run, AutoGenBench will start from a blank slate. The agents being evaluated will need to work out what code needs to be written, and what libraries or dependencies to install, to solve tasks. The results of each run are logged, and can be ingested by analysis or metrics scripts (such as `autogenbench tabulate`). By default, all runs are conducted in freshly-initialized docker containers, providing the recommended level of consistency and safety.

  AutoGenBench works with all AutoGen 0.1.*, and 0.2.* versions.



  If you are already an AutoGenBench pro, and want the full technical specifications, please review the [contributor's guide](CONTRIBUTING.md).



  AutoGenBench also requires Docker (Desktop or Engine). **It will not run in GitHub codespaces**, unless you opt for native execution (with is strongly discouraged). To install Docker Desktop see [https://www.docker.com/products/docker-desktop/](https://www.docker.com/products/docker-desktop/).



  **To get the most out of AutoGenBench, the `autogenbench` package should be installed**. At present, the easiest way to do this is to install it via `pip`:

  ```
  pip install autogenbench
  ```

  If you would prefer working from source code (e.g., for development, or to utilize an alternate branch), simply clone the [AutoGen](https://github.com/microsoft/autogen) repository, then install `autogenbench` via:

  ```
  pip install -e autogen/samples/tools/autogenbench
  ```

  After installation, you must configure your API keys. As with other AutoGen applications, AutoGenBench will look for the OpenAI keys in the OAI_CONFIG_LIST file in the current working directory, or the OAI_CONFIG_LIST environment variable. This behavior can be overridden using a command-line parameter described later.

  If you will be running multiple benchmarks, it is often most convenient to leverage the environment variable option. You can load your keys into the environment variable by executing:

  ```
  export OAI_CONFIG_LIST=$(cat ./OAI_CONFIG_LIST)
  ```

  If an OAI_CONFIG_LIST is *not* provided (by means of file or environment variable), AutoGenBench will use the OPENAI_API_KEY environment variable instead.


  For some benchmark scenarios, additional keys may be required (e.g., keys for the Bing Search API). These can be added to an `ENV.json` file in the current working folder. An example `ENV.json` file is provided below:

  ```
  {
      "BING_API_KEY": "xxxyyyzzz"
  }
  ```


  Once AutoGenBench and necessary keys are installed, a typical session will look as follows:

  ```
  autogenbench clone HumanEval
  cd HumanEval
  autogenbench run Tasks/r_human_eval_two_agents.jsonl
  autogenbench tabulate results/r_human_eval_two_agents
  ```

  Where:
  - `autogenbench clone HumanEval` downloads and expands the HumanEval benchmark scenario.
  - `autogenbench run Tasks/r_human_eval_two_agents.jsonl` runs the tasks defined in `Tasks/r_human_eval_two_agents.jsonl`
  - `autogenbench tablue results/r_human_eval_two_agents` tabulates the results of the run

  Each of these commands has extensive in-line help via:

  - `autogenbench --help`
  - `autogenbench clone --help`
  - `autogenbench run --help`
  - `autogenbench tabulate --help`

  **NOTE:** If you are running `autogenbench` from within the repository, you don’t need to run `autogenbench clone`. Instead, navigate to the appropriate scenario folder (e.g., `scenarios/HumanEval`) and run the `Scripts/init_tasks.py` file.

  More details of each command are provided in the sections that follow.


  To clone an existing benchmark, simply run:
  ```
  autogenbench clone [BENCHMARK]
  ```

  For example,

  ```
  autogenbench clone HumanEval
  ```

  To see which existing benchmarks are available to clone, run:

  ```
  autogenbench clone --list
  ```



  To run a benchmark (which executes the tasks, but does not compute metrics), simply execute:
  ```
  cd [BENCHMARK]
  autogenbench run Tasks
  ```

  For example,
  ```
  cd HumanEval
  autogenbench run Tasks
  ```

  The default is to run each task once. To run each scenario 10 times, use:

  ```
  autogenbench run --repeat 10 Tasks
  ```

  The `autogenbench` command-line tool allows a number of command-line arguments to control various parameters of execution. Type ``autogenbench -h`` to explore these options:

  ```
  'autogenbench run' will run the specified autogen scenarios for a given number of repetitions and record all logs and trace information. When running in a Docker environment (default), each run will begin from a common, tightly controlled, environment. The resultant logs can then be further processed by other scripts to produce metrics.

  positional arguments:
    scenario      The JSONL scenario file to run. If a directory is specified,
                  then all JSONL scenarios in the directory are run. (default:
                  ./scenarios)

  options:
    -h, --help            show this help message and exit
    -c CONFIG, --config CONFIG
                          The environment variable name or path to the OAI_CONFIG_LIST (default: OAI_CONFIG_LIST).
    -r REPEAT, --repeat REPEAT
                          The number of repetitions to run for each scenario (default: 1).
    -s SUBSAMPLE, --subsample SUBSAMPLE
                          Run on a subsample of the tasks in the JSONL file(s). If a decimal value is specified, then run on
                          the given proportion of tasks in each file. For example "0.7" would run on 70% of tasks, and "1.0"
                          would run on 100% of tasks. If an integer value is specified, then randomly select *that* number of
                          tasks from each specified JSONL file. For example "7" would run tasks, while "1" would run only 1
                          task from each specified JSONL file. (default: 1.0; which is 100%)
    -m MODEL, --model MODEL
                          Filters the config_list to include only models matching the provided model name (default: None, which
                          is all models).
    --requirements REQUIREMENTS
                          The requirements file to pip install before running the scenario.
    -d DOCKER_IMAGE, --docker-image DOCKER_IMAGE
                          The Docker image to use when running scenarios. Can not be used together with --native. (default:
                          'autogenbench:default', which will be created if not present)
    --native              Run the scenarios natively rather than in docker. NOTE: This is not advisable, and should be done
                          with great caution.
  ```



  By default, the AutoGenBench stores results in a folder hierarchy with the following template:

  ``./results/[scenario]/[task_id]/[instance_id]``

  For example, consider the following folders:

  ``./results/default_two_agents/two_agent_stocks/0``
  ``./results/default_two_agents/two_agent_stocks/1``

  ...

  ``./results/default_two_agents/two_agent_stocks/9``

  This folder holds the results for the ``two_agent_stocks`` task of the ``default_two_agents`` tasks file. The ``0`` folder contains the results of the first instance / run. The ``1`` folder contains the results of the second run, and so on. You can think of the _task_id_ as mapping to a prompt, or a unique set of parameters, while the _instance_id_ defines a specific attempt or run.

  Within each folder, you will find the following files:

  - *timestamp.txt*: records the date and time of the run, along with the version of the pyautogen library installed
  - *console_log.txt*: all console output produced by Docker when running AutoGen. Read this like you would a regular console.
  - *[agent]_messages.json*: for each Agent, a log of their messages dictionaries
  - *./coding*: A directory containing all code written by AutoGen, and all artifacts produced by that code.



  If you would like to develop -- or even contribute -- your own tasks or benchmarks, please review the [contributor's guide](CONTRIBUTING.md) for complete technical details.


pkgId: ce21a04418024546a479ff04b1ed03ed0a6f3f0a8a20f651ceda77edd4c1fb3c
name: python-autogenerated-api
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: Get Autogenerated Serializers and APi End Points
url: https://github.com/djangoconfire/autogenerated_api.git
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogenerated-api-1.2.6-1.src.rpm
checksum_type: sha256
description:
  Get Autogenerated Serializers and API EndPoints


  ```
  - django
  - djangorestframework
  ```

  ```
  Tested with all Django versions from `1.8.x to 2.x.x`
  ```




  ```
  For Django==1.8.x
  	- djangorestframework==3.4.2
  ```



  autogenerated-api built for django.

  ```bash
  pip install autogenerated_api
  ```



  ```pyhton
  django_app architecture looks like
  - app_name
  	- __init__.py
  	- admin.py
  	- models.py
  	- serializers.py
  	- tests.py
  	- views.py
  ```



  ```python
  from .models import ModelName
  from autogenerated_api.serializers import DeadlySerializerFactory
  ModelNameDeadlySerializer = DeadlySerializerFactory(modelName)
  - DeadlySerializerFactory `Optional Paramaters`
  	- nest = ["field_1","field_2"]
  	- nested_fields = {"field_name_in_releation" : ["related_model_field_1","related_model_field_2"]}
  	- if you want to get all fields of model while is in relation
  		- nested_fields = {"field_name_in_reletion" : ["*"]}
  	- exclude = ["field_1","field_2"] : fields that you want to exclude

  ModelNameDeadlySerializer = DeadlySerializerFactory(modelName,nest,nested_fields,exclude)
  ```



  ```python
  import app_name.models
  import app_name.serializers
  from autogenerated_api.autogeneration import make_all_viewsets

  make_all_viewsets(__name__)
  ```



  Main project folder Architecture
  ```python
  - main_proj_name
  	- __init__.py
  	- settings.py
  	- urls.py
  	- wsgi.py
  	- api_urls.py
  ```


  ```python
  import app_name.views
  from django.urls import path, re_path , include

  from autogenerated_api import autogenerated_urls
  urlpatterns = autogenerated_urls.urlpatterns

  urlpatterns += []

  ```



  Add the Below `urls.py`

  ```python
  import django
  dj_version = django.get_version()

  from django.contrib import admin
  try:
      from django.urls import path, include , re_path
  except ImportError:
      from django.conf.urls import include, url

  try:
      from django.core.urlresolvers import reverse
  except ImportError:
      from django.urls import reverse

  import re

  if re.search('^2[\d.]+',str(dj_version)):
      urlpatterns = [
              re_path(r'^api/', include(('main_proj_name.api_urls', 'main_proj_name') , namespace="api")),
      ]
  else:
      urlpatterns = [
          url(r'^admin/', include(admin.site.urls)),
          url(r'^api/', include('main_proj_name.api_urls' , namespace="api")),
      ]
  ```



  ```python
  AUTOGENERATE_APPS = ["app_name"]
  ```



  ```
  - Autogenerated End Points
  	- `/api/model_name_in_lower/` :  list out all the model_instance
  	- `/api/model_name_in_lower/<instance_id>` : you will get detail of instance of given id
  ```



  Through `autogenerated_api` module , you can directly create serializers coresponding to each model and can also access the all fields value of model which are in relation `(m2m or foreignkey relationship)`.

  To get the list of  model instance , You  have to write an api end points , like `ListAPiView` and for getting the detail of model instance, have to implement  `DetailAPIView or RetrieveApiView` end points.

  Now , You don't have to create these APi-end points and get worry about the serailizers . This module will take care. Just , follow the steps that i mentioned above.


  	- Module with more functionality and more autogenerated end points.


  ``` I will really appreciate if you support the project by clicking the star button on Github repository ```


pkgId: 23629b27e276e3e14f8bd7f2a0f27de075ec4f6b174503b0a00fa708d5c84dbe
name: python-autogenra
arch: src
version: 0.0.10a0
epoch: 0
release: 1
summary: Autogen Assistant UI
url: https://github.com/microsoft/autogen
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogenra-0.0.10a0-1.src.rpm
checksum_type: sha256
description:
  ![ARA](./docs/ara_stockprices.png)

  AutoGen Assistant is an Autogen-powered AI app (user interface) that can converse with you to help you conduct research, write and execute code, run saved skills, create new skills (explicitly and by demonstration), and adapt in response to your interactions.



  Some of the capabilities supported by the app frontend include the following:

  - [x] Select fron a list of agents (current support for two agent workflows - `UserProxyAgent` and `AssistantAgent`)
  - [x] Modify agent configuration (e.g. temperature, model, agent system message, model etc) and chat with updated agent configurations.
  - [x] View agent messages and output files in the UI from agent runs.
  - [ ] Support for more complex agent workflows (e.g. `GroupChat` workflows)
  - [ ] Improved user experience (e.g., streaming intermediate model output, better summarization of agent responses, etc)

  Project Structure:

  - _autogenra/_ code for the backend classes and web api (FastAPI)
  - _frontend/_ code for the webui, built with Gatsby and Tailwind



  1.  **Install from PyPi**

      We recommend using a virtual environment (e.g., conda) to avoid conflicts with existing Python packages. With Python 3.10 or newer active in your virtual environment, use pip to install AutoGen Assistant:

      ```bash
      pip install autogenra
      ```

  2.  **Install from Source**

      > Note: This approach requires some familiarity with building interfaces in React.

      If you prefer to install from source, ensure you have Python 3.10+ and Node.js (version above 14.15.0) installed. Here's how you get started:

      - Clone the AutoGen Assistant repository and install its Python dependencies:

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

      - Navigate to the `samples/apps/autogen-assistant/frontend` directory, install dependencies, and build the UI:

        ```bash
        npm install -g gatsby-cli
        npm install --global yarn
        cd frontend
        yarn install
        yarn build
        ```

      For Windows users, to build the frontend, you may need alternative commands to build the frontend.

          ```bash

          gatsby clean && rmdir /s /q ..\\autogenra\\web\\ui && (set \"PREFIX_PATH_VALUE=\" || ver>nul) && gatsby build --prefix-paths && xcopy /E /I /Y public ..\\autogenra\\web\\ui

          ````



  Once installed, run the web UI by entering the following in your terminal:

  ```bash
  autogenra ui --port 8081
  ```

  This will start the application on the specified port. Open your web browser and go to `http://localhost:8081/` to begin using AutoGen Assistant.

  Now that you have AutoGen Assistant installed and running, you are ready to explore its capabilities, including defining and modifying agent workflows, interacting with agents and sessions, and expanding agent skills.



  This demo focuses on the research assistant use case with some generalizations:

  - **Skills**: The agent is provided with a list of skills that it can leverage while attempting to address a user's query. Each skill is a python function that may be in any file in a folder made availabe to the agents. We separate the concept of global skills available to all agents `backend/files/global_utlis_dir` and user level skills `backend/files/user/<user_hash>/utils_dir`, relevant in a multi user environment. Agents are aware skills as they are appended to the system message. A list of example skills is available in the `backend/global_utlis_dir` folder. Modify the file or create a new file with a function in the same directory to create new global skills.

  - **Conversation Persistence**: Conversation history is persisted in an sqlite database `database.sqlite`.

  - **Default Agent Workflow**: The default a sample workflow with two agents - a user proxy agent and an assistant agent.



  Let us use a simple query demonstrating the capabilities of the research assistant.

  ```
  Plot a chart of NVDA and TESLA stock price YTD. Save the result to a file named nvda_tesla.png
  ```

  The agents responds by _writing and executing code_ to create a python program to generate the chart with the stock prices.

  > Note than there could be multiple turns between the `AssistantAgent` and the `UserProxyAgent` to produce and execute the code in order to complete the task.

  ![ARA](./docs/ara_stockprices.png)

  > Note: You can also view the debug console that generates useful information to see how the agents are interacting in the background.

  <!-- ![ARA](./docs/ara_console.png) -->



  **Q: How can I add more skills to the AutoGen Assistant?**
  A: You can extend the capabilities of your agents by adding new Python functions. The AutoGen Assistant interface also lets you directly paste functions that can be reused in the agent workflow.

  **Q: Where can I adjust the agent configurations and settings?**
  A: You can modify agent configurations directly from the UI or by editing the default configurations in the `utils.py` file under the `get_default_agent_config()` method (assuming you are building your own UI).

  **Q: If I want to reset the conversation with an agent, how do I go about it?**
  A: To reset your conversation history, you can delete the `database.sqlite` file. If you need to clear user-specific data, remove the relevant `autogenra/web/files/user/<user_id_md5hash>` folder.

  **Q: Is it possible to view the output and messages generated by the agents during interactions?**
  A: Yes, you can view the generated messages in the debug console of the web UI, providing insights into the agent interactions. Alternatively, you can inspect the `database.sqlite` file for a comprehensive record of messages.



  AutoGen assistant is Based on the [AutoGen](https://microsoft.github.io/autogen) project. It is adapted in October 2023 from a research prototype (original credits: Gagan Bansal, Adam Fourney, Victor Dibia, Piali Choudhury, Saleema Amershi, Ahmed Awadallah, Chi Wang)


pkgId: 1936282c200c1f4a580769f52be4963d8861fe8f8e37e04cfcad48357f767555
name: python-autogenstudio
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: AutoGen Studio
url: https://github.com/microsoft/autogen
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogenstudio-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/autogenstudio.svg)](https://badge.fury.io/py/autogenstudio)
  [![Downloads](https://static.pepy.tech/badge/autogenstudio/week)](https://pepy.tech/project/autogenstudio)

  ![ARA](./docs/ara_stockprices.png)

  AutoGen Studio is an AutoGen-powered AI app (user interface) to help you rapidly prototype AI agents, enhance them with skills, compose them into workflows and interact with them to accomplish tasks. It is built on top of the [AutoGen](https://microsoft.github.io/autogen) framework, which is a toolkit for building AI agents.

  Code for AutoGen Studio is on GitHub at [microsoft/autogen](https://github.com/microsoft/autogen/tree/main/samples/apps/autogen-studio)

  > **Note**: AutoGen Studio is meant to help you rapidly prototype multi-agent workflows and demonstrate an example of end user interfaces built with AutoGen. It is not meant to be a production-ready app.

  > [!WARNING]
  > AutoGen Studio is currently under active development and we are iterating quickly. Kindly consider that we may introduce breaking changes in the releases during the upcoming weeks, and also the `README` might be outdated. Please see the AutoGen Studio [docs](https://microsoft.github.io/autogen/docs/autogen-studio/getting-started) page for the most up-to-date information.

  **Updates**

  > April 17: AutoGen Studio database layer is now rewritten to use [SQLModel](https://sqlmodel.tiangolo.com/) (Pydantic + SQLAlchemy). This provides entity linking (skills, models, agents and workflows are linked via association tables) and supports multiple [database backend dialects](https://docs.sqlalchemy.org/en/20/dialects/) supported in SQLAlchemy (SQLite, PostgreSQL, MySQL, Oracle, Microsoft SQL Server). The backend database can be specified a `--database-uri` argument when running the application. For example, `autogenstudio ui --database-uri sqlite:///database.sqlite` for SQLite and `autogenstudio ui --database-uri postgresql+psycopg://user:password@localhost/dbname` for PostgreSQL.

  > March 12: Default directory for AutoGen Studio is now /home/<user>/.autogenstudio. You can also specify this directory using the `--appdir` argument when running the application. For example, `autogenstudio ui --appdir /path/to/folder`. This will store the database and other files in the specified directory e.g. `/path/to/folder/database.sqlite`. `.env` files in that directory will be used to set environment variables for the app.

  Project Structure:

  - _autogenstudio/_ code for the backend classes and web api (FastAPI)
  - _frontend/_ code for the webui, built with Gatsby and TailwindCSS



  There are two ways to install AutoGen Studio - from PyPi or from source. We **recommend installing from PyPi** unless you plan to modify the source code.

  1.  **Install from PyPi**

      We recommend using a virtual environment (e.g., conda) to avoid conflicts with existing Python packages. With Python 3.10 or newer active in your virtual environment, use pip to install AutoGen Studio:

      ```bash
      pip install autogenstudio
      ```

  2.  **Install from Source**

      > Note: This approach requires some familiarity with building interfaces in React.

      If you prefer to install from source, ensure you have Python 3.10+ and Node.js (version above 14.15.0) installed. Here's how you get started:

      - Clone the AutoGen Studio repository and install its Python dependencies:

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

      - Navigate to the `samples/apps/autogen-studio/frontend` directory, install dependencies, and build the UI:

        ```bash
        npm install -g gatsby-cli
        npm install --global yarn
        cd frontend
        yarn install
        yarn build
        ```

  For Windows users, to build the frontend, you may need alternative commands to build the frontend.

  ```bash

    gatsby clean && rmdir /s /q ..\\autogenstudio\\web\\ui 2>nul & (set \"PREFIX_PATH_VALUE=\" || ver>nul) && gatsby build --prefix-paths && xcopy /E /I /Y public ..\\autogenstudio\\web\\ui

  ```



  Once installed, run the web UI by entering the following in your terminal:

  ```bash
  autogenstudio ui --port 8081
  ```

  This will start the application on the specified port. Open your web browser and go to `http://localhost:8081/` to begin using AutoGen Studio.

  AutoGen Studio also takes several parameters to customize the application:

  - `--host <host>` argument to specify the host address. By default, it is set to `localhost`. Y
  - `--appdir <appdir>` argument to specify the directory where the app files (e.g., database and generated user files) are stored. By default, it is set to the a `.autogenstudio` directory in the user's home directory.
  - `--port <port>` argument to specify the port number. By default, it is set to `8080`.
  - `--reload` argument to enable auto-reloading of the server when changes are made to the code. By default, it is set to `False`.
  - `--database-uri` argument to specify the database URI. Example values include `sqlite:///database.sqlite` for SQLite and `postgresql+psycopg://user:password@localhost/dbname` for PostgreSQL. If this is not specified, the database URIL defaults to a `database.sqlite` file in the `--appdir` directory.

  Now that you have AutoGen Studio installed and running, you are ready to explore its capabilities, including defining and modifying agent workflows, interacting with agents and sessions, and expanding agent skills.



  We welcome contributions to AutoGen Studio. We recommend the following general steps to contribute to the project:

  - Review the overall AutoGen project [contribution guide](https://github.com/microsoft/autogen?tab=readme-ov-file#contributing)
  - Please review the AutoGen Studio [roadmap](https://github.com/microsoft/autogen/issues/737) to get a sense of the current priorities for the project. Help is appreciated especially with Studio issues tagged with `help-wanted`
  - Please initiate a discussion on the roadmap issue or a new issue to discuss your proposed contribution.
  - Please review the autogenstudio dev branch here [dev branch](https://github.com/microsoft/autogen/tree/autogenstudio) and use as a base for your contribution. This way, your contribution will be aligned with the latest changes in the AutoGen Studio project.
  - Submit a pull request with your contribution!
  - If you are modifying AutoGen Studio, it has its own devcontainer. See instructions in `.devcontainer/README.md` to use it
  - Please use the tag `studio` for any issues, questions, and PRs related to Studio



  Please refer to the AutoGen Studio [FAQs](https://microsoft.github.io/autogen/docs/autogen-studio/faqs) page for more information.



  AutoGen Studio is Based on the [AutoGen](https://microsoft.github.io/autogen) project. It was adapted from a research prototype built in October 2023 (original credits: Gagan Bansal, Adam Fourney, Victor Dibia, Piali Choudhury, Saleema Amershi, Ahmed Awadallah, Chi Wang).


pkgId: bb768ad8b19959e3fe7ee5331de379f29076d5b99258614872398c00644e61e1
name: python-autogluon.assistant
arch: src
version: 0.0.1.dev20241119
epoch: 0
release: 1
summary: ML Assistant for Competitive Machine Learning
url: https://github.com/autogluon/autogluon-assistant
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogluon.assistant-0.0.1.dev20241119-1.src.rpm
checksum_type: sha256
description:
  [![Python Versions](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue)](https://pypi.org/project/autogluon-assistant/)
  [![GitHub license](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
  [![Continuous Integration](https://github.com/autogluon/autogluon-assistant/actions/workflows/lint.yml/badge.svg)](https://github.com/autogluon/autogluon-assistant/actions/workflows/lint.yml)

  AutoGluon Assistant (AG-A) provides users a simple interface where they can input their data, describe their problem, and receive a highly accurate and competitive ML solution — without writing any code. By leveraging the state-of-the-art AutoML capabilities of AutoGluon and integrating them with a Large Language Model (LLM), AG-A automates the entire data science pipeline. AG-A takes AutoGluon’s automation from three lines of code to zero, enabling users to solve new supervised learning tabular problems using only natural language descriptions.



  Installing from source:

  ```bash

  conda create -n aga python=3.10
  conda activate aga


  git clone https://github.com/autogluon/autogluon-assistant.git
  cd autogluon-assistant && pip install -e "." && cd ..
  ```

  or simply:

  ```bash
  pip install autogluon.assistant
  ```



  AG-A now supports automatic feature generation as part of its beta features. To enable these features, please install the beta version dependencies using the following command:

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




  AG-A supports using both AWS Bedrock and OpenAI as LLM model providers. You will need to set up API keys for the respective provider you choose. By default, AG-A uses AWS Bedrock for its language models.


  AG-A integrates with AWS Bedrock by default. To use AWS Bedrock, you will need to configure your AWS credentials and region settings:

  ```bash
  export AWS_DEFAULT_REGION="<your-region>"
  export AWS_ACCESS_KEY_ID="<your-access-key>"
  export AWS_SECRET_ACCESS_KEY="<your-secret-key>"
  ```

  Ensure you have an active AWS account and appropriate permissions set up for using Bedrock models. You can manage your AWS credentials through the AWS Management Console. See [Bedrock supported AWS regions](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html)



  To use OpenAI, you'll need to set your OpenAI API key as an environment variable:

  ```bash
  export OPENAI_API_KEY="sk-..."
  ```

  You can sign up for an OpenAI account [here](https://platform.openai.com/) and manage your API keys [here](https://platform.openai.com/account/api-keys).

  Important: Free-tier OpenAI accounts may be subject to rate limits, which could affect AG-A's performance. We recommend using a paid OpenAI API key for seamless functionality.




  We support two ways of using AutoGluon Assistant: WebUI and CLI.


  AutoGluon Assistant Web UI allows users to leverage the capabilities of AG-A through an intuitive web interface.

  The web UI enables users to upload datasets, configure AG-A runs with customized settings, preview data, monitor execution progress, view and download results, and supports secure, isolated sessions for concurrent users.



  ```bash
  aga ui




  aga ui --port 8888
  ```

  AG-A Web UI should now be accessible in your web browser at `http://localhost:8501` or the specified port.




  Before launching AG-A CLI, prepare your data files in the following structure:

  ```
  └── data # Data files directory
      ├── train.[ext] # Training dataset (required)
      ├── test.[ext]  # Test dataset (required)
      └── description.txt # Dataset and task description (recommended)
  ```

  Note:
  - The training and test files can be in any tabular data format (e.g., csv, parquet, xlsx)
  - While there are no strict naming requirements, we recommend using clear, descriptive filenames
  - The description file is optional but recommended for better model selection and optimization. It can include:
    - Dataset description
    - Problem context
    - Evaluation metrics
    - Any other relevant information

  Now you can launch the AutoGluon Assistant run using the following command:

  ```bash
  aga run [NAME_OF_DATA_DIR] --presets [PRESET_QUALITY]

  ```

  We support three presets, including `medium_quality`, `high_quality` and `best_quality`. We use `best_quality` as a default setting.

  After the run is complete, model predictions on test dataset are saved into the `aga-output-<timestamp>.csv` file. It will be formatted according to optional `sample_submission.csv` file if provided.



  You can override specific settings in the YAML configuration defined in the [config folder](https://github.com/autogluon/autogluon-assistant/tree/main/src/autogluon/assistant/configs) using
  the `config_overrides` parameter with format `"key1=value1, key2.nested=value2"` from the command line.


  Here are some example commands on using configuration overrides:

  ```bash
  aga run toy_data --config_overrides "feature_transformers.enabled_models=None, time_limit=3600"



  aga run toy_data --config_overrides "feature_transformers.enabled_models=None" --config_overrides "time_limit=3600"
  ```


pkgId: 0201eae880e6994b643b8fd6d6bdda5e5637e516ed7d26a358f9acd2d7d2935b
name: python-autogluon.cloud
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Train and deploy AutoGluon backed models on the cloud
url: https://github.com/autogluon/autogluon-cloud
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogluon.cloud-0.4.1-1.src.rpm
checksum_type: sha256
description:
  <div align="left">
    <img src="https://user-images.githubusercontent.com/16392542/77208906-224aa500-6aba-11ea-96bd-e81806074030.png" width="350">
  </div>



  [![Continuous Integration](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml)

  [AutoGluon-Cloud Documentation](https://auto.gluon.ai/cloud/stable/index.html) | [AutoGluon Documentation](https://auto.gluon.ai)

  AutoGluon-Cloud aims to provide user tools to train, fine-tune and deploy [AutoGluon](https://auto.gluon.ai/stable/index.html) backed models on the cloud. With just a few lines of codes, users could train a model and perform inference on the cloud without worrying about MLOps details such as resource management.

  Currently, AutoGluon-Cloud supports [AWS SageMaker](https://aws.amazon.com/sagemaker/) as the cloud backend.


  ```bash
  pip install -U pip
  pip install -U setuptools wheel
  pip install autogluon.cloud
  ```


  ```python

  from autogluon.cloud import TabularCloudPredictor
  import pandas as pd
  train_data = pd.read_csv("https://autogluon.s3.amazonaws.com/datasets/Inc/train.csv")
  test_data = pd.read_csv("https://autogluon.s3.amazonaws.com/datasets/Inc/test.csv")
  test_data.drop(columns=['class'], inplace=True)
  predictor_init_args = {"label": "class"}  # init args you would pass to AG TabularPredictor
  predictor_fit_args = {"train_data": train_data, "time_limit": 120}  # fit args you would pass to AG TabularPredictor
  cloud_predictor = TabularCloudPredictor(cloud_output_path='YOUR_S3_BUCKET_PATH')
  cloud_predictor.fit(predictor_init_args=predictor_init_args, predictor_fit_args=predictor_fit_args)
  cloud_predictor.deploy()
  result = cloud_predictor.predict_real_time(test_data)
  cloud_predictor.cleanup_deployment()

  result = cloud_predictor.predict(test_data)
  ```


pkgId: ace3141473ebd5f50bc9bc59e4d38ce68e936e6fc793ae8fd33e6d670ee56238
name: python-autograd
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Efficiently computes derivatives of NumPy code.
url: https://pypi.org/project/autograd/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autograd-1.7.0-1.src.rpm
checksum_type: sha256
description:
  [publish-badge]: https://github.com/HIPS/autograd/actions/workflows/publish.yml/badge.svg
  [checks-badge]: https://github.com/HIPS/autograd/actions/workflows/check.yml/badge.svg
  [tests-badge]: https://github.com/HIPS/autograd/actions/workflows/test.yml/badge.svg
  [asv-badge]: http://img.shields.io/badge/benchmarked%20by-asv-green.svg?style=flat
  [publish-url]: https://github.com/HIPS/autograd/actions/workflows/publish.yml
  [checks-url]: https://github.com/HIPS/autograd/actions/workflows/check.yml
  [tests-url]: https://github.com/HIPS/autograd/actions/workflows/test.yml

  Autograd can automatically differentiate native Python and Numpy code. It can
  handle a large subset of Python's features, including loops, ifs, recursion and
  closures, and it can even take derivatives of derivatives of derivatives. It
  supports reverse-mode differentiation (a.k.a. backpropagation), which means it
  can efficiently take gradients of scalar-valued functions with respect to
  array-valued arguments, as well as forward-mode differentiation, and the two can
  be composed arbitrarily. The main intended application of Autograd is
  gradient-based optimization. For more information, check out the
  [tutorial](docs/tutorial.md) and the [examples directory](examples/).

  Example use:

  ```python
  >>> import autograd.numpy as np  # Thinly-wrapped numpy
  >>> from autograd import grad    # The only autograd function you may ever need
  >>>
  >>> def tanh(x):                 # Define a function
  ...     y = np.exp(-2.0 * x)
  ...     return (1.0 - y) / (1.0 + y)
  ...
  >>> grad_tanh = grad(tanh)       # Obtain its gradient function
  >>> grad_tanh(1.0)               # Evaluate the gradient at x = 1.0
  0.41997434161402603
  >>> (tanh(1.0001) - tanh(0.9999)) / 0.0002  # Compare to finite differences
  0.41997434264973155
  ```

  We can continue to differentiate as many times as we like, and use numpy's
  vectorization of scalar-valued functions across many different input values:

  ```python
  >>> from autograd import elementwise_grad as egrad  # for functions that vectorize over inputs
  >>> import matplotlib.pyplot as plt
  >>> x = np.linspace(-7, 7, 200)
  >>> plt.plot(x, tanh(x),
  ...          x, egrad(tanh)(x),                                     # first  derivative
  ...          x, egrad(egrad(tanh))(x),                              # second derivative
  ...          x, egrad(egrad(egrad(tanh)))(x),                       # third  derivative
  ...          x, egrad(egrad(egrad(egrad(tanh))))(x),                # fourth derivative
  ...          x, egrad(egrad(egrad(egrad(egrad(tanh)))))(x),         # fifth  derivative
  ...          x, egrad(egrad(egrad(egrad(egrad(egrad(tanh))))))(x))  # sixth  derivative
  >>> plt.show()
  ```

  <img src="examples/tanh.png" width="600">

  See the [tanh example file](examples/tanh.py) for the code.



  You can find a tutorial [here.](docs/tutorial.md)



  * [Simple neural net](examples/neural_net.py)
  * [Convolutional neural net](examples/convnet.py)
  * [Recurrent neural net](examples/rnn.py)
  * [LSTM](examples/lstm.py)
  * [Neural Turing Machine](https://github.com/DoctorTeeth/diffmem/blob/512aadeefd6dbafc1bdd253a64b6be192a435dc3/ntm/ntm.py)
  * [Backpropagating through a fluid simulation](examples/fluidsim/fluidsim.py)

  <img src="examples/fluidsim/animated.gif" width="400">

  * [Variational inference in Bayesian neural network](examples/bayesian_neural_net.py)
  * [Gaussian process regression](examples/gaussian_process.py)
  * [Sampyl, a pure Python MCMC package with HMC and NUTS](https://github.com/mcleonard/sampyl)



  Install Autograd using Pip:

  ```shell
  pip install autograd
  ```

  Some features require SciPy, which you can install separately or as an
  optional dependency along with Autograd:

  ```shell
  pip install "autograd[scipy]"
  ```



  Autograd was written by [Dougal Maclaurin](https://dougalmaclaurin.com),
  [David Duvenaud](https://www.cs.toronto.edu/~duvenaud/),
  [Matt Johnson](http://people.csail.mit.edu/mattjj/),
  [Jamie Townsend](https://github.com/j-towns)
  and many other contributors. The package is currently being maintained by
  [Agriya Khetarpal](https://github.com/agriyakhetarpal),
  [Fabian Joswig](https://github.com/fjosw) and
  [Jamie Townsend](https://github.com/j-towns).
  Please feel free to submit any bugs or
  feature requests. We'd also love to hear about your experiences with Autograd
  in general. Drop us an email!

  We want to thank Jasper Snoek and the rest of the HIPS group (led by Prof. Ryan
  P. Adams) for helpful contributions and advice; Barak Pearlmutter for
  foundational work on automatic differentiation and for guidance on our
  implementation; and Analog Devices Inc. (Lyric Labs) and Samsung Advanced Institute
  of Technology for their generous support.

rpm_license:
  The MIT License (MIT)  Copyright (c) 2014 by the President and Fellows of Harvard University  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: 30b81f2f8fee188e9e2a1f3a556cf72cff104f5a73b799d5d62040e42effabba
name: python-autograd-gamma
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Autograd compatible approximations to the gamma family of functions
url: https://github.com/CamDavidsonPilon/autograd-gamma
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autograd-gamma-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/autograd-gamma.svg)](https://badge.fury.io/py/autograd-gamma)


  [autograd](https://github.com/HIPS/autograd) compatible approximations to the derivatives of the Gamma-family of functions.




  ```python
  from autograd import grad
  from autograd_gamma import gammainc, gammaincc, gammaincln, gammainccln


  grad(gammainc, argnum=0)(1., 2.)
  grad(gammaincc, argnum=0)(1., 2.)


  grad(gammaincln, argnum=0)(1., 2.)
  grad(gammainccln, argnum=0)(1., 2.)



  from autograd_gamma import betainc, betaincln

  grad(betainc, argnum=0)(1., 2., 0.5)
  grad(betainc, argnum=1)(1., 2., 0.5)


  grad(betaincln, argnum=0)(1., 2., 0.5)
  grad(betaincln, argnum=1)(1., 2., 0.5)

  ```




  Build and improve upon the derivative of the upper and lower incomplete gamma functions. Eventually, if we have a fast analytical solution, we will merge into the autograd library.


pkgId: 7265e1e512cdf21d98d0ff883d558e4ab665b4f6a2d45b1e72b0187b1a8ce824
name: python-autogram
arch: src
version: 3.6.1
epoch: 0
release: 1
summary: An easily extensible telegram API wrapper
url: https://github.com/drui9/autogram
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autogram-3.6.1-1.src.rpm
checksum_type: sha256
description:
  <p style="text-align: center;">
      <img src="https://raw.githubusercontent.com/drui9/autogram/main/autogram.png" align="middle" alt="Autogram">
  <p>

  Autogram is a telegram bot-API wrapper written in python3, with a keen focus on remaining stupidly simple.


  `pip install autogram`
  - Copy either the Functional or OOP example below.
  - Run the bot the first time to generate `project-name.json` config template
  - Add your telegram bot token in the config, (from telegram:BotFather chat)
  - Ready to run.
  - Add your own logic and handler methods. `core.telegram.org` manual is your friend.


  The name implies automated-telegram. I needed a framework that is easy and intuitive to work with.


  ```python
  from autogram import Autogram
  from autogram.config import Start


  @Autogram.add('message')
  def message(bot, update):
      print('message:', update)


  @Autogram.add('callback_query')
  def callback_query(bot, update):
      print('callback_query:', update)


  @Start(config_file='web-auto.json')
  def main(config):
      bot = Autogram(config)
      bot.run() # every call fetches updates, and updates internal offset

  ```

  ```python
  import time
  from loguru import logger
  from autogram import Autogram, Start


  class ExampleBot(Autogram):
      def __init__(self, config):
          super().__init__(config)

      def run(self):
          """Custom implementation of bot.poll()"""
          super().run() # initializes bot info, abstractmethod
          for _ in range(10): # should be endless loop
              offset = self.data('offset')
              for rep in self.poll(offset=offset).json()['result']:
                self.data('offset', rep.pop('update_id') + 1)
                with self.register['lock']:
                  if handler := self.register['handlers'].get(list(rep.keys())[-1]):
                    handler(self, self, rep)
              time.sleep(5)

      @Autogram.add('message')
      def message(self, bot: Autogram, update):
          logger.debug(update['message']['text'])
          chat_id = update['message']['chat']['id']
          keyb = [[{'text': 'The armpit', 'callback_data': 'tickled'}]]
          data = {
              'reply_markup': bot.getInlineKeyboardMarkup(keyb)
          }
          bot.sendMessage(chat_id, 'Tickle me!', **data)

      
      @Autogram.add('callback_query')
      def callback_query(self, bot: Autogram, update):
          callback_id = update['callback_query']['id']
          bot.answerCallbackQuery(callback_id, 'Ha-ha-ha')


  @Start()
  def main(config):
      bot = ExampleBot(config)
      bot.run()

  ```
  If you have a url-endpoint, call bot.setWebhook(url), then run some sort of webserver in bot.run.


  - Add webhook example.
  - Extend coverage of the API.


  - Invalid `TELEGRAM_TOKEN` return 404 through `bot.getMe()`
  - Thread safety is not guaranteed for calls from multiple threads to: `bot.data, bot.settings`. Prefferably, handle the bot in a single thread, as handlers use these methods to persist data.
  - Don't run multiple bots with the same `TOKEN` as this will cause update problems
  - Sending unescaped special characters when using MarkdownV2 will return HTTP400
  - Have `fun` with whatever you're building `;)`

rpm_license:
  MIT License  Copyright (c) 2022-2024 drui9  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: 9492b3bb3eee8a358dacabbf4f628aa9731cb0c6c0e8e642103de69f32cfb8fa
name: python-autograms
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A framework for programming stateful LLM based chatbots.
url: https://github.com/autograms/autograms
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autograms-0.5.0-1.src.rpm
checksum_type: sha256
description:
  - **Continuously Running Programs**: AutoGRAMS lets you write chatbots as Python programs that maintain their state across interactions. Each user input resumes the program exactly where it left off, enabling highly dynamic, context-aware conversations.
  - **Save and Resume Program State**: Serialize the program’s entire state, including call stack, variables, and control flow. Reload it later to continue the program (and conversation) from its exact state.
  - **Dynamic Control Flow**: Use advanced constructs like `GOTO` to move between different parts of your program that represent different states of your chatbot. This allows complex, non-linear dialogue paths that adapt dynamically to user inputs and decisions.
  - **LLM-Driven Decisions**: Integrate decision-making powered by LLMs to dynamically guide conversations based on user input, enabling sophisticated branching of the program
  - **Memory Management**: AutoGRAMS automatically manages memory, ensuring that variables and conversation history persist across turns.
  - **Visualize Conversation Flow**: Compile detailed graphs of your chatbot’s states and logic, helping you design, debug, and understand the flow of conversation at a glance.
  AutoGRAMS accomplishes many of these behaviors using a special @autograms_function decorator that enables non-standard python functionality such as saving and loading the state of a program mid-execution and jumping to a predefined location in the code.
  The full documentation and tutorials are available in our [web docs](https://autograms.github.io/autograms).

  You can install AutoGRAMS via pip:
  ```
  pip install autograms
  ```
  If you make local modifications, you can install them with:
  ```
  git clone https://github.com/autograms/autograms.git
  cd autograms
  pip install .
  ```
  To visualize AutoGRAMS graphs, install Graphviz. On Linux:
  ```
  sudo apt install graphviz
  ```
  Python >=3.9 is required. If you plan to use OpenAI models or other LLM APIs, ensure you set up the necessary dependencies and keys.

  AutoGRAMS makes it easy to build structured, stateful chatbots. To get started with a recruiter chatbot demo, you can run:
  ```
  python run_autogram.py --api_key_file api_keys.json --example_name recruiter
  ```
  This will launch an interactive chatbot in the terminal, simulating a virtual recruiter.

  To use OpenAI or other API-driven models, set your API key as an environment variable:
  ```
  export OPENAI_API_KEY=<your key>
  ```
  Alternatively, you can store your API key in `api_keys.json`. Simply change `"load_from_env"` to `false` and set the `"openai"` key to your API key.

  AutoGRAMS includes tools to visualize the conversational flow as an interactive graph. For example, you can generate visualizations for the recruiter chatbot with:
  ```
  python visualize_autogram.py --example_name recruiter --save_folder recruiter_graph
  ```
  This will create both a static and interactive graph in the specified folder. You can explore the chatbot flow and decision points by clicking on nodes in the interactive graph.

  Explore the `/examples` folder for more sample autograms. Each example demonstrates different capabilities of AutoGRAMS, from simple branching dialogues to complex, stateful agents.
  To run a demo:
  ```
  python run_autogram.py --api_key_file api_keys.json --example_name <example_name>
  ```
  Replace `<example_name>` with the desired example (e.g., `simple_example`, `fraction_tutor`, `general_tutor`, or `recruiter`).

  If you use this work in research, please cite the following paper:
  ```
  @article{krause2024autograms,
    title={AutoGRAMS: Autonomous Graphical Agent Modeling Software},
    author={Krause, Ben and Chen, Lucia and Kahembwe, Emmanuel},
    journal={arXiv preprint arXiv:2407.10049},
    year={2024}
  }
  ```


pkgId: c52b360d2862093ae1517ab8c265beb90e8ff33f3a3cbf917e97096e2c83b0c6
name: python-autoguard
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Configuration setup for sentry
url: https://github.com/Polyconseil/autoguard
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoguard-0.3.4-1.src.rpm
checksum_type: sha256
description:
  The ``autoguard`` project enables a Sentry server to use REMOTE_USER authentication.
  It's mostly a special sentry configuration file, modified to hook authentication
  backends and Django middlewares to the proper RemoteUser classes.
  It also uses getconf_ to read settings from INI configuration files.


pkgId: 0657081d98b3b9ecc264cf106f11b04bb1bf5da472df6d236606bd81dc463b30
name: python-autohack
arch: src
version: 0.130
epoch: 0
release: 1
summary: This package does automated vulnerability enumeration and recommends exploits.
url: https://github.com/sudouser2010/autohack
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autohack-0.130-1.src.rpm
checksum_type: sha256
description:
  * Install AutoHack Python Package
      ```
      pip install autohack
      ```
  * Run AutoHack
    ```
    autohack -i <some ip address>
    ```


pkgId: 6eca11294c70fdd438eba059d4536221d18cc96a64af8ade91286cbab225c2f3
name: python-autohooks
arch: src
version: 24.2.0
epoch: 0
release: 1
summary: Library for managing git hooks
url: https://github.com/greenbone/autohooks/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autohooks-24.2.0-1.src.rpm
checksum_type: sha256
description:
  ![Greenbone Logo](https://www.greenbone.net/wp-content/uploads/gb_new-logo_horizontal_rgb_small.png)


  [![PyPI release](https://img.shields.io/pypi/v/autohooks.svg)](https://pypi.org/project/autohooks/)
  [![Build and test Python package](https://github.com/greenbone/autohooks/actions/workflows/ci-python.yml/badge.svg)](https://github.com/greenbone/autohooks/actions/workflows/ci-python.yml)
  [![codecov](https://codecov.io/gh/greenbone/autohooks/branch/main/graph/badge.svg?token=9IX7ucaFwj)](https://codecov.io/gh/greenbone/autohooks)

  Library for managing and writing [git hooks](https://git-scm.com/docs/githooks)
  in Python using `pyproject.toml` for its settings.

  Looking for automatic formatting and linting, e.g., with [black] and [ruff],
  while creating a git commit using a pure Python implementation? Do you just want
  to have your git hook settings in the `pyproject.toml` file too?

  Welcome to **autohooks**!

  - [Why?](#why)
  - [Solution](#solution)
  - [Requirements](#requirements)
  - [Plugins](#plugins)
  - [Installing autohooks](#installing-autohooks)
  - [Command Completion](#command-completion)
    - [Setup for bash](#setup-for-bash)
    - [Setup for zsh](#setup-for-zsh)
  - [Maintainer](#maintainer)
  - [Contributing](#contributing)
  - [License](#license)



  Several outstanding libraries for managing and executing git hooks exist already.
  To name a few: [husky](https://github.com/typicode/husky),
  [lint-staged](https://github.com/okonet/lint-staged),
  [precise-commits](https://github.com/nrwl/precise-commits) or
  [pre-commit](https://github.com/pre-commit/pre-commit).

  However, they need another interpreter besides python (like husky), require a
  different config file besides `pyproject.toml` or are too ambiguous (like
  pre-commit). pre-commit is written in python but has support hooks written in
  all kind of languages. Additionally, it maintains the dependencies by itself and
  does not install them in the current environment.



  autohooks is a pure python library that installs a minimal
  [executable git hook](https://github.com/greenbone/autohooks/blob/main/autohooks/precommit/template).
  It allows the decision of how to maintain the hook dependencies
  by supporting different modes and stores its settings in the well known
  `pyproject.toml` file.

  ![Autohooks](https://raw.githubusercontent.com/greenbone/autohooks/main/autohooks.gif)



  Python 3.9+ is required for autohooks.



  * Python code formatting via [black](https://github.com/greenbone/autohooks-plugin-black)

  * Python code formatting via [autopep8](https://github.com/LeoIV/autohooks-plugin-autopep8)

  * Python code linting via [ruff](https://github.com/greenbone/autohooks-plugin-ruff)

  * Python code linting via [pylint](https://github.com/greenbone/autohooks-plugin-pylint)

  * Python code linting via [flake8](https://github.com/greenbone/autohooks-plugin-flake8)

  * Python code linting via [mypy](https://github.com/greenbone/autohooks-plugin-mypy)

  * Python import sorting via [isort](https://github.com/greenbone/autohooks-plugin-isort)

  * Running tests via [pytest](https://github.com/greenbone/autohooks-plugin-pytest/)



  Quick installation of [ruff] and [black] plugins using [poetry]:

  ```shell
  poetry add --dev autohooks autohooks-plugin-black autohooks-plugin-ruff
  poetry run autohooks activate --mode poetry
  poetry run autohooks plugins add autohooks.plugins.black autohooks.plugins.ruff
  ```

  The output of `autohooks activate` should be similar to
  ```
   ✓ autohooks pre-commit hook installed at /autohooks-test/.git/hooks/pre-commit using poetry mode.
  ```

  Autohooks has an extensible plugin model. Each plugin provides different
  functionality which often requires to install additional dependencies.

  For managing these dependencies currently three modes are supported by
  autohooks:

  * `pythonpath` for dependency management via [pip]
  * `poetry` for dependency management via [poetry] (recommended)
  * `pipenv` for dependency management via [pipenv]

  These modes handle how autohooks, the plugins and their dependencies are loaded
  during git hook execution.

  If no mode is specified in the [`pyproject.toml` config file](#configure-mode-and-plugins-to-be-run)
  and no mode is set during [activation](#activating-the-git-hooks), autohooks
  will use the [pythonpath mode](#pythonpath-mode) by default.

  For more details on using [pip], [poetry] or [pipenv] in conjunction with these
  modes see the [documentation](https://greenbone.github.io/autohooks).



  `autohooks` comes with support for command line completion in bash
  and zsh.



  ```bash
  echo "source ~/.autohooks-complete.bash" >> ~/.bashrc
  autohooks --print-completion bash > ~/.autohooks-complete.bash
  ```

  Alternatively, you can use the result of the completion command directly with
  the eval function of your bash shell:

  ```bash
  eval "$(autohooks --print-completion bash)"
  ```



  ```zsh
  echo 'fpath=("$HOME/.zsh.d" $fpath)' >> ~/.zsh
  mkdir -p ~/.zsh.d/
  autohooks --print-completion zsh > ~/.zsh.d/_autohooks
  ```

  Alternatively, you can use the result of the completion command directly with
  the eval function of your zsh shell:

  ```bash
  eval "$(autohooks --print-completion zsh)"
  ```



  This project is maintained by [Greenbone AG](https://www.greenbone.net/).



  Your contributions are highly appreciated. Please
  [create a pull request](https://github.com/greenbone/autohooks/pulls)
  on GitHub. Bigger changes need to be discussed with the development team via the
  [issues section at GitHub](https://github.com/greenbone/autohooks/issues)
  first.



  Copyright (C) 2019 - 2024 [Greenbone AG](https://www.greenbone.net/)

  Licensed under the [GNU General Public License v3.0 or later](LICENSE).

  [black]: https://black.readthedocs.io/en/stable/
  [pip]: https://pip.pypa.io/en/stable/
  [pipenv]: https://pipenv.readthedocs.io/en/latest/
  [poetry]: https://python-poetry.org/
  [pylint]: https://pylint.readthedocs.io/en/latest/
  [ruff]: https://docs.astral.sh/ruff/


pkgId: d46b2fbf7ad1dd10c14d633f74a3f8e67f7803dba9ae7051b13c46b519e24788
name: python-autohooks-plugin-black
arch: src
version: 23.10.0
epoch: 0
release: 1
summary: An autohooks plugin for python code formatting via black
url: https://github.com/greenbone/autohooks-plugin-black
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autohooks-plugin-black-23.10.0-1.src.rpm
checksum_type: sha256
description:
  ![Greenbone Logo](https://www.greenbone.net/wp-content/uploads/gb_new-logo_horizontal_rgb_small.png)



  [![PyPI release](https://img.shields.io/pypi/v/autohooks-plugin-black.svg)](https://pypi.org/project/autohooks-plugin-black/)

  An [autohooks](https://github.com/greenbone/autohooks) plugin for python code
  formatting via [black](https://github.com/ambv/black).





  You can install the latest stable release of autohooks-plugin-black from the
  Python Package Index using [pip](https://pip.pypa.io/):

      python3 -m pip install autohooks-plugin-black



  It is highly encouraged to use [poetry](https://python-poetry.org) for
  maintaining your project's dependencies. Normally autohooks-plugin-black is
  installed as a development dependency.

      poetry add --dev autohooks-plugin-black



  To activate the black autohooks plugin please add the following setting to your
  *pyproject.toml* file.

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.black"]
  ```

  By default, autohooks plugin black checks all files with a *.py* ending. If only
  files in a sub-directory or files with different endings should be formatted,
  just add the following setting:

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.black"]

  [tool.autohooks.plugins.black]
  include = ['foo/*.py', '*.foo']
  ```

  Also by default, autohooks plugin black executes black with the `-q` argument.
  If e.g. the generated patch should be shown the following setting can be used:

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.black"]

  [tool.autohooks.plugins.black]
  arguments = ["-q", "--diff"]
  ```



  This project is maintained by [Greenbone AG](https://www.greenbone.net/).



  Your contributions are highly appreciated. Please
  [create a pull request](https://github.com/greenbone/autohooks-plugin-black/pulls)
  on GitHub. Bigger changes need to be discussed with the development team via the
  [issues section at GitHub](https://github.com/greenbone/autohooks-plugin-black/issues)
  first.



  Copyright (C) 2019-2023 [Greenbone AG](https://www.greenbone.net/)

  Licensed under the [GNU General Public License v3.0 or later](LICENSE).


pkgId: 27a735792591b8a6138420b7a50ce8c2512afcd2d1b71c4e2ce26879686dd0d2
name: python-autohooks-plugin-flake8
arch: src
version: 23.10.0
epoch: 0
release: 1
summary: An autohooks plugin for python code linting via flake8.
url: https://github.com/greenbone/autohooks-plugin-flake8
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autohooks-plugin-flake8-23.10.0-1.src.rpm
checksum_type: sha256
description:
  ![Greenbone Logo](https://www.greenbone.net/wp-content/uploads/gb_new-logo_horizontal_rgb_small.png)



  [![PyPI release](https://img.shields.io/pypi/v/autohooks-plugin-flake8.svg)](https://pypi.org/project/autohooks-plugin-flake8/)

  An [autohooks](https://github.com/greenbone/autohooks) plugin for python code
  linting via [flake8](https://github.com/PyCQA/flake8).





  You can install the latest stable release of autohooks-plugin-flake8 from the
  Python Package Index using [pip](https://pip.pypa.io/):

      python3 -m pip install autohooks-plugin-flake8



  It is highly encouraged to use [poetry](https://python-poetry.org) for
  maintaining your project's dependencies. Normally autohooks-plugin-flake8 is
  installed as a development dependency.

      poetry install



  To activate the flake8 autohooks plugin please add the following setting to your
  *pyproject.toml* file.

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.flake8"]
  ```

  By default, autohooks plugin flake8 checks all files with a *.py* ending. If
  only files in a sub-directory or files with different endings should be
  formatted, just add the following setting:

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.flake8"]

  [tool.autohooks.plugins.flake8]
  include = ['foo/*.py', '*.foo']
  ```

  To configure flake8 you can specify command-line options in the default flake8
  configuration file *.flake8* in the root directory of the git repository.
  To learn more about flake8 configuration see the configuration file or
  the flake8 documentation. You can specify your own configuration file using

  ```
  arguments = ["--config=/path/to/flake8config"]
  ```

  inside the `[tool.autohooks.plugins.flake8]` section of your projects `pyproject.toml`.

  See `flake8 --help` for more details.



  This project is maintained by [Greenbone AG](https://www.greenbone.net/).



  Your contributions are highly appreciated. Please
  [create a pull request](https://github.com/greenbone/autohooks-plugin-flake8/pulls)
  on GitHub. Bigger changes need to be discussed with the development team via the
  [issues section at GitHub](https://github.com/greenbone/autohooks-plugin-flake8/issues)
  first.



  Copyright (C) 2019 - 2023 [Greenbone AG](https://www.greenbone.net/)

  Licensed under the [GNU General Public License v3.0 or later](LICENSE).

  SPDX-License-Identifier: GPL-3.0-or-later


pkgId: 846c47dbe93c37f12660215cd1316ea10e45a54eab537f091c5e80890a2f7850
name: python-autohooks-plugin-isort
arch: src
version: 23.10.0
epoch: 0
release: 1
summary: An autohooks plugin for python code formatting via isort
url: https://github.com/greenbone/autohooks-plugin-isort
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autohooks-plugin-isort-23.10.0-1.src.rpm
checksum_type: sha256
description:
  ![Greenbone Logo](https://www.greenbone.net/wp-content/uploads/gb_new-logo_horizontal_rgb_small.png)



  [![PyPI release](https://img.shields.io/pypi/v/autohooks-plugin-isort.svg)](https://pypi.org/project/autohooks-plugin-isort/)

  An [autohooks](https://github.com/greenbone/autohooks) plugin for Python code
  formatting via [isort](https://github.com/timothycrosley/isort).





  You can install the latest stable release of autohooks-plugin-isort from the
  Python Package Index using [pip](https://pip.pypa.io/):

      python3 -m pip install autohooks-plugin-isort



  It is highly encouraged to use [poetry](https://python-poetry.org) for
  maintaining your project's dependencies. Normally autohooks-plugin-isort is
  installed as a development dependency.

      poetry add --dev autohooks-plugin-isort

      poetry install



  To activate the isort autohooks plugin please add the following setting to your
  *pyproject.toml* file.

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.isort"]
  ```

  By default, autohooks plugin isort checks all files with a *.py* ending. If only
  the imports of files in a sub-directory or files with different endings should
  be sorted, just add the following setting:

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.isort"]

  [tool.autohooks.plugins.isort]
  include = ['foo/*.py', '*.foo']
  ```

  When using `autohooks-plugins-isort` in combination with
  [autohooks-plugin-black](https://github.com/greenbone/autohooks-plugin-black),
  the following configuration is recommended to ensure a consistent formatting:

  ```toml
  [tool.isort]
  profile = "black"
  ```



  This project is maintained by [Greenbone AG](https://www.greenbone.net/).



  Your contributions are highly appreciated. Please
  [create a pull request](https://github.com/greenbone/autohooks-plugin-isort/pulls)
  on GitHub. Bigger changes need to be discussed with the development team via the
  [issues section at GitHub](https://github.com/greenbone/autohooks-plugin-isort/issues)
  first.



  Copyright (C) 2019 - 2023 [Greenbone AG](https://www.greenbone.net/)

  Licensed under the [GNU General Public License v3.0 or later](LICENSE).


pkgId: 9dec1e30081409ff60803570f501fadc11c80995fb9251a97e895f706983d755
name: python-autohooks-plugin-mypy
arch: src
version: 23.10.0
epoch: 0
release: 1
summary: An autohooks plugin for python code static typing check with mypy
url: https://github.com/greenbone/autohooks-plugin-mypy
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autohooks-plugin-mypy-23.10.0-1.src.rpm
checksum_type: sha256
description:
  ![Greenbone Logo](https://www.greenbone.net/wp-content/uploads/gb_new-logo_horizontal_rgb_small.png)



  [![GitHub releases](https://img.shields.io/github/release/greenbone/autohooks-plugin-mypy.svg)](https://github.com/greenbone/autohooks-plugin-mypy/releases)
  [![PyPI release](https://img.shields.io/pypi/v/autohooks-plugin-mypy.svg)](https://pypi.org/project/autohooks-plugin-mypy/)
  [![code test coverage](https://codecov.io/gh/greenbone/autohooks-plugin-mypy/branch/main/graph/badge.svg)](https://codecov.io/gh/greenbone/autohooks-plugin-mypy)
  [![Build and test](https://github.com/greenbone/autohooks-plugin-mypy/actions/workflows/ci-python.yml/badge.svg)](https://github.com/greenbone/autohooks-plugin-mypy/actions/workflows/ci-python.yml)

  An [autohooks](https://github.com/greenbone/autohooks) plugin for python code
  static typing check via [mypy](https://github.com/python/mypy).





  You can install the latest stable release of autohooks-plugin-mypy from the
  Python Package Index using [pip](https://pip.pypa.io/):

      python3 -m pip install autohooks-plugin-mypy



  It is highly encouraged to use [poetry](https://python-poetry.org) for
  maintaining your project's dependencies. Normally autohooks-plugin-mypy is
  installed as a development dependency.

      poetry install



  To activate the mypy autohooks plugin please add the following setting to your
  *pyproject.toml* file.

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.mypy"]
  ```

  By default, autohooks plugin mypy checks all files with a *.py* ending. If
  only files in a sub-directory or files with different endings should be
  formatted, just add the following setting:

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.mypy"]

  [tool.autohooks.plugins.mypy]
  include = ['foo/*.py', '*.foo']
  ```

  By default, autohooks plugin mypy executes mypy without any arguments.
  To change specific settings or to define a mypy config file the following plugin configuration can be used:

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.mypy"]

  [tool.autohooks.plugins.mypy]
  arguments = ["--ignore-missing-imports", "--config-file=/path/to/.mypy.ini"]
  ```



  This project is maintained by [Greenbone AG](https://www.greenbone.net/).



  Your contributions are highly appreciated. Please
  [create a pull request](https://github.com/greenbone/autohooks-plugin-mypy/pulls)
  on GitHub. Bigger changes need to be discussed with the development team via the
  [issues section at GitHub](https://github.com/greenbone/autohooks-plugin-mypy/issues)
  first.



  Copyright (C) 2021 [Vincent Texier](https://gitlab.com/VictorIndiaTango).
  Copyright (C) 2023 [Greenbone AG](https://www.greenbone.net/)

  Licensed under the [GNU General Public License v3.0 or later](LICENSE).


pkgId: 6e7ac22cc932e41825c45ef54662f22e9afe69fd1b7db23dfc787790a8af604f
name: python-autohooks-plugin-pylint
arch: src
version: 23.10.0
epoch: 0
release: 1
summary: An autohooks plugin for python code linting via pylint
url: https://github.com/greenbone/autohooks-plugin-pylint
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autohooks-plugin-pylint-23.10.0-1.src.rpm
checksum_type: sha256
description:
  ![Greenbone Logo](https://www.greenbone.net/wp-content/uploads/gb_new-logo_horizontal_rgb_small.png)



  [![PyPI release](https://img.shields.io/pypi/v/autohooks-plugin-pylint.svg)](https://pypi.org/project/autohooks-plugin-pylint/)

  An [autohooks](https://github.com/greenbone/autohooks) plugin for python code
  linting via [pylint](https://github.com/PyCQA/pylint).





  You can install the latest stable release of autohooks-plugin-pylint from the
  Python Package Index using [pip](https://pip.pypa.io/):

      python3 -m pip install autohooks-plugin-pylint



  It is highly encouraged to use [poetry](https://python-poetry.org) for
  maintaining your project's dependencies. Normally autohooks-plugin-pylint is
  installed as a development dependency.

      poetry install



  To activate the pylint autohooks plugin please add the following setting to your
  *pyproject.toml* file.

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.pylint"]
  ```

  By default, autohooks plugin pylint checks all files with a *.py* ending. If
  only files in a sub-directory or files with different endings should be
  formatted, just add the following setting:

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.pylint"]

  [tool.autohooks.plugins.pylint]
  include = ['foo/*.py', '*.foo']
  ```

  By default, autohooks plugin pylint executes pylint without any arguments and
  pylint settings are loaded from the *.pylintrc* file in the root directory of
  git repository. To change specific settings or to define a different pylint rc
  file the following plugin configuration can be used:

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.pylint"]

  [tool.autohooks.plugins.pylint]
  arguments = ["--rcfile=/path/to/pylintrc", "-s", "n"]
  ```



  This project is maintained by [Greenbone AG](https://www.greenbone.net/).



  Your contributions are highly appreciated. Please
  [create a pull request](https://github.com/greenbone/autohooks-plugin-pylint/pulls)
  on GitHub. Bigger changes need to be discussed with the development team via the
  [issues section at GitHub](https://github.com/greenbone/autohooks-plugin-pylint/issues)
  first.



  Copyright (C) 2019 - 2023 [Greenbone AG](https://www.greenbone.net/)

  Licensed under the [GNU General Public License v3.0 or later](LICENSE).


pkgId: 80a97ee1980b85f1b955ad5c10fc0101128fa540f0bccd11392a85295136cb72
name: python-autohooks-plugin-ruff
arch: src
version: 24.1.0
epoch: 0
release: 1
summary: An autohooks plugin for python code formatting via ruff
url: https://github.com/greenbone/autohooks-plugin-ruff
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autohooks-plugin-ruff-24.1.0-1.src.rpm
checksum_type: sha256
description:
  ![Greenbone Logo](https://www.greenbone.net/wp-content/uploads/gb_new-logo_horizontal_rgb_small.png)



  [![PyPI release](https://img.shields.io/pypi/v/autohooks-plugin-ruff.svg)](https://pypi.org/project/autohooks-plugin-ruff/)

  An [autohooks](https://github.com/greenbone/autohooks) plugin for python code
  formatting via [ruff](https://github.com/astral-sh/ruff).





  > [!NOTE] The `pip install` command does no longer work out-of-the-box in newer
  > distributions like Ubuntu >= 23.04 because of [PEP 668](https://peps.python.org/pep-0668).

  You can install the latest stable release of autohooks-plugin-ruff from the
  Python Package Index using [pip](https://pip.pypa.io/):

      python3 -m pip install --user autohooks-plugin-ruff



  It is highly encouraged to use [poetry](https://python-poetry.org) for
  maintaining your project's dependencies. Normally autohooks-plugin-ruff is
  installed as a development dependency.

      poetry add --group dev autohooks-plugin-ruff



  To activate the ruff autohooks plugin please run

  ```shell
  poetry run autohooks plugins add autohooks.plugins.ruff
  ```

  or alternatively add the following setting to your
  *pyproject.toml* file.

  ```toml
  [tool.autohooks]
  pre-commit = ["autohooks.plugins.ruff"]
  ```

  What the plugin actually does is `ruff check .` on git commit, so you should be
  able to use the exact same settings as in [ruff's docs](https://beta.ruff.rs/docs/settings/).



  This project only runs ruff as a pre-commit hook, so, all features from ruff
  should be available too.

  To activate this pre-commit hook remember to run this command before you start:

  ```shell
  poetry run autohooks activate --mode poetry
  ```



  This project is maintained by [Greenbone AG](https://www.greenbone.net/).



  Your contributions are highly appreciated. Please
  [create a pull request](https://github.com/greenbone/autohooks-plugin-ruff/pulls)
  on GitHub. Bigger changes need to be discussed with the development team via the
  [issues section at GitHub](https://github.com/greenbone/autohooks-plugin-ruff/issues)
  first.



  Copyright (C) 2023 - 2024 [Greenbone AG](https://www.greenbone.net/)

  Licensed under the [GNU General Public License v3.0 or later](LICENSE).


pkgId: 536ebaf651faf85ba910fe25f60ea378f6b006dc825af233279d13498bf58eb4
name: python-autoimp
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Automatic Python imports
url: https://github.com/uva-graphics/autoimp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoimp-1.0.4-1.src.rpm
checksum_type: sha256
description:
  The autoimp module makes usage of the interactive Python prompt more productive.
      With autoimp, all installed Python modules can be imported with the single statement "from autoimp import *".  The  imported modules are proxy objects which lazily load when first used.

      Install with 'sudo pip install autoimp'.

      Proper installation of autoimp involves placing "from autoimp import *" in your
      PYTHONSTARTUP file. Once autoimp is properly installed, it is no longer necessary to use statements of the form "import X" at the interactive prompt.


pkgId: 32953bc4ee7ab61c430e2931823eb985206d9ffed11536e0211da8794c1662a4
name: python-autoimport
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Autoimport missing python libraries.
url: https://github.com/lyz-code/autoimport
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoimport-1.6.1-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/lyz-code/autoimport/workflows/Tests/badge.svg)](https://github.com/lyz-code/autoimport/actions)
  [![Actions Status](https://github.com/lyz-code/autoimport/workflows/Build/badge.svg)](https://github.com/lyz-code/autoimport/actions)
  [![Coverage Status](https://coveralls.io/repos/github/lyz-code/autoimport/badge.svg?branch=main)](https://coveralls.io/github/lyz-code/autoimport?branch=main)

  Autoimport missing python libraries.

  Throughout the development of a python program you continuously need to manage
  the python import statements either because you need one new object or because
  you no longer need it. This means that you need to stop writing whatever you
  were writing, go to the top of the file, create or remove the import statement
  and then resume coding.

  This workflow break is annoying and almost always unnecessary. `autoimport`
  solves this problem if you execute it whenever you have an import error, for
  example by configuring your editor to run it when saving the file.



  See [documentation](https://lyz-code.github.io/autoimport) for more details.



  ```bash
  pip install autoimport
  ```



  For guidance on setting up a development environment, and how to make
  a contribution to *autoimport*, see [Contributing to
  autoimport](https://lyz-code.github.io/autoimport/contributing).



  GPLv3


pkgId: a9064767a84b0d85bf7047e14c96aac73698853c611608ec09aabad70e83a608
name: python-autoimpute
arch: src
version: 0.14.1
epoch: 0
release: 1
summary: Imputation Methods in Python
url: https://github.com/kearnz/autoimpute
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoimpute-0.14.1-1.src.rpm
checksum_type: sha256
description:
  <img alt="autoimpute-logo" class="autoimpute-logo" height="250" width="500" src="https://kearnz.github.io/autoimpute-tutorials/img/home/autoimpute-logo-transparent.png">


  [![PyPI version](https://badge.fury.io/py/autoimpute.svg)](https://badge.fury.io/py/autoimpute) [![Build Status](https://github.com/kearnz/autoimpute/actions/workflows/build.yml/badge.svg)](https://github.com/kearnz/autoimpute/actions) [![Documentation Status](https://readthedocs.org/projects/autoimpute/badge/?version=latest)](https://autoimpute.readthedocs.io/en/latest/?badge=latest) [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/) [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/release/python-380/)

  <span style="font-size:1.5em;">[`Autoimpute`](https://pypi.org/project/autoimpute/) is a Python package for analysis and implementation of <b>Imputation Methods!</b></span>

  <span style="font-size:1.5em;">[View our website](https://kearnz.github.io/autoimpute-tutorials/) to explore `Autoimpute` in more detail. New tutorials coming soon!</span>

  <span style="font-size:1.5em;">[Check out our docs](https://autoimpute.readthedocs.io/en/latest/) to get the developer guide to `Autoimpute`.</span>


  * We presented `Autoimpute` at a couple of PyData conferences!
  * **[PyData NYC](https://pydata.org/nyc2019/schedule/presentation/96/up-and-coming/)**: New and Upcoming slot in November 2019
  * **[PyData LA](https://pydata.org/la2019/schedule/presentation/22/introducing-autoimpute-a-python-package-for-grappling-with-missing-data/)**: Main talk slot in December 2019. See the video [here!](https://www.youtube.com/watch?v=QZRwg1NHB_Y&t=2041s)


  * v 0.13+ has upgraded to support pymc, the next generation of the pymc3 library
  * v 0.12+ contains the new `MiceImputer`. Thanks to [@gjdv](https://github.com/gjdv) for the help on this issue!
  * We're looking to collaborate and happy to work with those interested!
  * If you'd like to get involved, feel free to reach out! Our info is on the [Authors](https://github.com/kearnz/autoimpute/blob/master/AUTHORS.rst) page.


  Joseph Kearney – [@kearnz](https://github.com/kearnz)
  Shahid Barkat - [@shabarka](https://github.com/shabarka)
  Arnab Bose (Advisor) - [@bosearnab](https://github.com/bosearnab)
  See the [Authors](https://github.com/kearnz/autoimpute/blob/master/AUTHORS.rst) page to get in touch!


  * `Autoimpute` is **registered with PyPI!** Download with `pip install autoimpute`.
  * If `pip` cached an older version, try `pip install --no-cache-dir --upgrade autoimpute`.
  * If you want to work with the development branch, use the script below:

  *Development*
  ```sh
  git clone -b dev --single-branch https://github.com/kearnz/autoimpute.git
  cd autoimpute
  python setup.py install
  ```


  Most machine learning algorithms expect clean and complete datasets, but real-world data is messy and missing. Unfortunately, handling missing data is quite complex, so programming languages generally punt this responsibility to the end user. By default, R drops all records with missing data - a method that is easy to implement but often problematic in practice. For richer imputation strategies, R has multiple packages to deal with missing data (`MICE`, `Amelia`, `TSImpute`, etc.). Python users are not as fortunate. Python's `scikit-learn` throws a runtime error when an end user deploys models on datasets with missing records, and few third-party packages exist to handle imputation end-to-end.

  Therefore, this package aids the Python user by providing more clarity to the imputation process, making imputation methods more accessible, and measuring the impact imputation methods have in supervised regression and classification. In doing so, this package brings missing data imputation methods to the Python world and makes them work nicely in Python machine learning projects (and specifically ones that utilize `scikit-learn`). Lastly, this package provides its own implementation of supervised machine learning methods that extend both `scikit-learn` and `statsmodels` to mutiply imputed datasets.


  * Utility functions to examine patterns in missing data and decide on relevant features for imputation
  * Missingness classifier and automatic missing data test set generator
  * Native handling for categorical variables (as predictors and targets of imputation)
  * Single and multiple imputation classes for `pandas` `DataFrames`
  * Custom visualization support for utility functions and imputation methods
  * Analysis methods and pooled parameter inference using multiply imputed datasets
  * Numerous imputation methods, as specified in the table below:



  | Univariate                  | Multivariate                        | Time Series / Interpolation
  | :-------------------------- | :---------------------------------- | ---------------------------
  | Mean                        | Linear Regression                   | Linear
  | Median                      | Binomial Logistic Regression        | Quadratic
  | Mode                        | Multinomial Logistic Regression     | Cubic
  | Random                      | Stochastic Regression               | Polynomial
  | Norm                        | Bayesian Linear Regression          | Spline
  | Categorical                 | Bayesian Binary Logistic Regression | Time-weighted
  |                             | Predictive Mean Matching            | Next Obs Carried Backward
  |                             | Local Residual Draws                | Last Obs Carried Forward


  * Additional cross-sectional methods, including random forest, KNN, EM, and maximum likelihood
  * Additional time-series methods, including EWMA, ARIMA, Kalman filters, and state-space models
  * Extended support for visualization of missing data patterns, imputation methods, and analysis models
  * Additional support for analysis metrics and analyis models after multiple imputation
  * Multiprocessing and GPU support for larger datasets, as well as integration with `dask` DataFrames


  Autoimpute is designed to be user friendly and flexible. When performing imputation, Autoimpute fits directly into `scikit-learn` machine learning projects. Imputers inherit from sklearn's `BaseEstimator` and `TransformerMixin` and implement `fit` and `transform` methods, making them valid Transformers in an sklearn pipeline.

  Right now, there are three `Imputer` classes we'll work with:
  ```python
  from autoimpute.imputations import SingleImputer, MultipleImputer, MiceImputer
  si = SingleImputer() # pass through data once
  mi = MultipleImputer() # pass through data multiple times
  mice = MiceImputer() # pass through data multiple times and iteratively optimize imputations in each column
  ```


  * There are tradeoffs between the three imputers
  * We won't get into the specifics regarding why, but here are a couple points to keep in mind:
  * Execution time (best to worst): `SingleImputer`, `MultipleImputer`, `MiceImputer`
  * Imputation quality (best to worst): `MiceImputer`, `MultipleImputer`, `SingleImputer`
  * This shouldn't come as a surprise. The `MiceImputer` does the most work, while the `SingleImputer` does the least
  * The example below use the `MiceImputer`, but you can swap in the `MultipleImputer` or `SingleImputer` as well

  Imputations can be as simple as:
  ```python

  imp = MiceImputer()


  imp.fit_transform(data)
  ```

  Or quite complex, such as:
  ```python



  imp = MiceImputer(
      n=10,
      strategy={"salary": "pmm", "gender": "bayesian binary logistic", "age": "norm"},
      predictors={"salary": "all", "gender": ["salary", "education", "weight"]},
      imp_kwgs={"pmm": {"fill_value": "random"}},
      visit="left-to-right",
      return_list=True
  )



  imp.fit_transform(data)
  ```

  Autoimpute also extends supervised machine learning methods from `scikit-learn` and `statsmodels` to apply them to multiply imputed datasets (using the `MiceImputer` under the hood). Right now, Autoimpute supports linear regression and binary logistic regression. Additional supervised methods are currently under development.

  As with Imputers, Autoimpute's analysis methods can be simple or complex:
  ```python
  from autoimpute.analysis import MiLinearRegression


  simple_lm = MiLinearRegression()


  simple_lm.fit(X_train, y_train)



  simple_lm.summary()


  predictions = simple_lm.predict(X_test)


  mice_imputer_arguments = dict(
      n=3,
      strategy={"salary": "pmm", "gender": "bayesian binary logistic", "age": "norm"},
      predictors={"salary": "all", "gender": ["salary", "education", "weight"]},
      imp_kwgs={"pmm": {"fill_value": "random"}},
      visit="left-to-right"
  )
  complex_lm = MiLinearRegression(
      model_lib="sklearn", # use sklearn linear regression
      mi_kwgs=mice_imputer_arguments # control the multiple imputer
  )


  complex_lm.fit(X_train, y_train)



  complex_lm.summary()


  predictions = complex_lm.predict(X_test)
  ```

  Note that we can also pass a pre-specified `MiceImputer` (or `MultipleIputer`) to either analysis model instead of using `mi_kwgs`. The option is ours, and it's a matter of preference. If we pass a pre-specified `MiceImputer`, anything in `mi_kwgs` is ignored, although the `mi_kwgs` argument is still validated.

  ```python
  from autoimpute.imputations import MiceImputer
  from autoimpute.analysis import MiLinearRegression


  custom_imputer = MiceImputer(n=3, strategy="pmm", return_list=True)


  complex_lm = MiLinearRegression(mi=custom_imputer, model_lib="statsmodels")


  complex_lm.fit(X_train, y_train).predict(X_test)
  complex_lm.summary()
  ```

  For a deeper understanding of how the package works and its available features, see our [tutorials website](https://kearnz.github.io/autoimpute-tutorials/).


  * Python 3.8+
  * Dependencies:
      - `numpy`
      - `scipy`
      - `pandas`
      - `statsmodels`
      - `scikit-learn`
      - `xgboost`
      - `pymc`
      - `seaborn`
      - `missingno`
  * See `requirements.txt` for versioning info

  *A note for Windows Users*:
  * Autoimpute has NOT been tested on Windows using the upgrade to pymc. Historically, autoimpute has had trouble on Windows, as demonstrated by bullets below.
  * Autoimpute works on Windows but users may have trouble with pymc for bayesian methods. [(See discourse)](https://discourse.pymc.io/t/an-error-message-about-cant-pickle-fortran-objects/1073)
  * Users may receive a runtime error `‘can’t pickle fortran objects’` when sampling using multiple chains.
  * There are a couple of things to do to try to overcome this error:
      - Reinstall theano and pymc. Make sure to delete .theano cache in your home folder.
      - Upgrade joblib in the process, which is reponsible for generating the error (pymc uses joblib under the hood).
      - Set `cores=1` in `pm.sample`. This should be a last resort, as it means posterior sampling will use 1 core only. Not using multiprocessing will slow down bayesian imputation methods significantly.
  * Reach out and let us know if you've worked through this issue successfully on Windows and have a better solution!


  Distributed under the MIT license. See [LICENSE](https://github.com/kearnz/autoimpute/blob/master/LICENSE) for more information.


  Guidelines for contributing to our project. See [CONTRIBUTING](https://github.com/kearnz/autoimpute/blob/master/CONTRIBUTING.md) for more information.


  Adapted from Contributor Covenant, version 1.0.0. See [Code of Conduct](https://github.com/kearnz/autoimpute/blob/master/CODE_OF_CONDUCT.md) for more information.


pkgId: ae8433ac4a3385457b1da935a6a345e62bb34785660d5a5b71e041f10f6c06e3
name: python-autoinject
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: Automated dependency injection for Python
url: https://github.com/turnbullerin/autoinject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoinject-1.3.3-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/autoinject/badge/?version=latest)](https://autoinject.readthedocs.io/en/latest/?badge=latest)

  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/turnbullerin/autoinject/tree/main.svg?style=shield)](https://dl.circleci.com/status-badge/redirect/gh/turnbullerin/autoinject/tree/main)

  A clean, simple framework for automatically injecting dependencies into objects and functions
  based around Python's type-hinting system. The framework provides caching of injectable objects,
  though this may be disabled on a class-by-class basis. It also supports managing independent
  caches for different contexts.



  ```python


  from autoinject import injector

  @injector.injectable
  class MyInjectableClass:

      
      def __init__(self):
          pass





  @injector.register("example.MyInjectableClass", os.environ("MY_CONFIG_FILE"))
  class MyInjectableClass:

      def __init__(self, config_file):
          
          
          pass
  ```



  ```python


  @injector.inject
  def inject_me(param1, param2, injected_param: MyInjectableClass):
      
      pass



  inject_me("arg1", "arg2")




  class InjectMe:

      injected_attribute: MyInjectableClass = None

      @injector.construct
      def __init__(self):
          
          pass


  obj = InjectMe()

  ```



  You can override injected classes in your unit tests using the `@injector.test_case()` decorator. This provides an
  independent global context within the test case function and allows you to pass a map of objects to inject. For example,

  ```python

  from autoinject import injector


  @injector.injectable_global
  class ServiceConnection:

    def execute(self) -> int:
      
      pass



  class UsesServiceConnection:

    connection: ServiceConnection = None

    @injector.construct
    def __init__(self):
      pass

    def test_me(self) -> bool:
      
      resp_code = self.connection.execute()
      return resp_code < 400



  import unittest


  class _StubServiceFixture:

    def __init__(self, response_code):
      self.response_code = response_code

    def execute(self) -> int:
      return self.response_code



  class TestUsesServiceConnection(unittest.TestCase):

      @injector.test_case({
        ServiceConnection: _StubServiceFixture(200)
      })
      def test_success_200(self):
          test_obj = UsesServiceConnection()  # this will use the injected objects now
          self.assertTrue(test_obj.test_me())


      @injector.test_case({
        ServiceConnection: _StubServiceFixture(400)
      })
      def test_failure_400(self):
          test_obj = UsesServiceConnection()
          self.assertFalse(test_obj.test_me())


  ```

  Read the [full documentation](https://autoinject.readthedocs.io/en/latest/?) for more details.




  - Member lists of objects are now cached to prevent multiple calls to ``inspect.getmembers()`` when the
  same class is created many times. This results in significant speed increases.


  - The new `@injector.test_case()` decorator is available for use with unit testing frameworks. It executes the decorated
    function with a different global and non-global context to ensure the independence of test functions. In addition, one
    can override the injected classes to provide specific test fixtures. These are passed as a dict of either `type` objects
    or fully qualified class names as strings as keys and either the `type` or class name as string (to create the object),
    or an object or function to use as the injected object.
  - A bug was fixed where exceptions within a context caused issues with the new contextvars integration.


  - Contextvar-driven contexts are now respected by default
  - Several wrappers exist to better support using contextvars. All of them provide for a separate set of injected
    CONTEXT_CACHE dependencies. In addition, each is a wrapper around `@injector.inject`, so both are not needed.
    - `@injector.with_contextvars`: Creates a new context that is a copy of the current one
    - `@injector.with_same_contextvars`: Uses the current context
    - `@injector.with_empty_contextvars`: Creates a new empty context
  - When using a `with_contextvars` wrapper, you can inject the context object using type-hinting (e.g.
    `ctx: contextvars.Context`). Note that this is actually an instance of `ContextVarsManager` which is a context manager
    that delegates most functionality to the current `contextvars.Context` object with a few modifications:
    - It provides the method `set(context_var, value) -> token` and the complementary `reset(context_var, token)` to
      handle variable setting and resetting within the context manager.
      - If the "same" context is used, these methods are equivalent to calling the methods directly on the `context_var`
      - In all other cases, they are equivalent to calling `ctx.run(context_var.METHOD, *args, **kwargs)`.
      - In essence, this makes sure the `set()` and `reset()` operations are performed in the context that the manager is
        managing (since the manager doesn't run the inner block in the context).
    - If the "same" context is used:
      - `run()` will just directly call the function (it is in the current context essentially)
      - `copy()` is an alias for `contextvars.copy_context()`
      - Other functions besides `set()` and `reset()` make a copy of the current context and return the results of its
        method. This copy is transient and remade each time, so modules making extensive use of it can call `copy()` and
        check the copy.
  - Note that, unlike the context manager, the decorators also RUN the inner code in the given context.
  - Thread-handling was improved significantly and now also includes a wrapper function for `threading.Thread.run()` methods to
    ensure clean-up (`@injector.as_thread_run()`). This also is a wrapper around `@injector.inject` so you can inject
    variables into your `run()` method directly.


  - Injectable objects may now define a `__cleanup__()` method which will be invoked when the global cache or context
    cache is cleared.
  - Note that `__cleanup__()` IS NOT INVOKED for one-time use objects at the moment, but this is planned as a feature.


  - Inherited injectable class members are now supported properly


  - Official initial release
  - Added support for @injector.injectable_global which registers with GLOBAL cache instead of context-specific cache
  - Added support for @injector.injectable_nocache which registers with NO_CACHE instead
  - Added support for injector.override() as a helper function to replace one constructor with another.
  - Added support for any constructor argument (e.g. via override() or register_constructor()) to be specified
    by fully-qualified Python name (e.g. package.module.MyInjectableClass) to better support systems where injected
    classes are specified by name.
  - Fixed a bug whereby the cache wasn't cleared


  - Fixed a bug for injection when a non-truthy default value needed to be used.


  - Fixed a bug in Python 3.8 and 3.9 where `entry_points(group=?)` was not supported


  - Objects with a cache strategy of `CONTEXT_CACHE` will now have separate instances within threads
  - Added `injector.get()` as a fast way to get the object that would be injected (useful if operating outside of
    a function or method)
  - Added `injector.register_constructor()` as a wrapper to register a class in a non-decorated fashion
  - Added the entry point `autoinject.injectables` to directly register injectable classes
  - Added the entry point `autoinject.registrars`
  - Support for overriding injectables and for injecting functions
  - Added a `weight` keyword argument to `register()` and `register_construct()` to control overriding order
  - There is now a `cleanup()` function in the `ContextManager()` class which triggers informant objects to check for
    old items that are no longer needed. This was added mostly to support the thread-based context informant, since it
    has no easy way of calling `destroy()` whenever the thread ends (unless one manually calls it). It is the best
    practice if you can call `destroy()` directly whenever a context ceases to exist instead of relying on `cleanup()`.


pkgId: 28ca79c6c3d0ba5b73d59da4827e5069370c3263b2ca35707bb4bd7693445896
name: python-autointent
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A tool for automatically configuring a text classification pipeline for intent prediction.
url: https://deeppavlov.github.io/AutoIntent/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autointent-0.0.1-1.src.rpm
checksum_type: sha256
description:
  <img align="left" width="100" height="100" src="logo/square-light.svg#gh-light-mode-only">
  <img align="left" width="100" height="100" src="logo/square-dark.svg#gh-dark-mode-only">

  Auto ML for intent classification.

  Documentation: [deeppavlov.github.io/AutoIntent](https://deeppavlov.github.io/AutoIntent/).

  > The project is under active development.



  ```bash
  pip install autointent
  ```



  **AutoIntent** is an open source tool for automatic configuration of a text classification pipeline for intent prediction.

  The task of intent detection is one of the main subtasks in creating task-oriented dialogue systems, along with scriptwriting and slot filling. AutoIntent project offers users the following:

  - A convenient library of methods for intent classification that can be used in a sklearn-like "fit-predict" format.
  - An AutoML approach to creating classifiers, where the only thing needed is to upload a set of labeled data.

  Example of building an intent classifier in a couple of lines of code:

  ```python
  from autointent import Pipeline, Dataset

  dataset = Dataset.from_json(path_to_json)
  pipeline = Pipeline.default_optimizer(multilabel=False)
  pipeline.fit(dataset)
  pipeline.predict(["show me my latest recent transactions"])
  ```


pkgId: a12c19be9105272dde5eb52ca3281f4b5bd5fd5ef8026964d1a858bedac08f75
name: python-autoit-ripper
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Extract AutoIt scripts embedded in PE binaries
url: https://github.com/nazywam/AutoIt-Ripper
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoit-ripper-1.1.2-1.src.rpm
checksum_type: sha256
description:
  This is a short python script that allows for extraction of "compiled" AutoIt scripts from PE executables.


  This script is **heavily** based on 3 resources, definitely check them out if you want to dig a bit deeper into AutoIt stuff:
   * http://files.planet-dl.org/Cw2k/MyAutToExe/index.html
     * [Github mirror I](https://github.com/dzzie/myaut_contrib)
     * [Github mirror II](https://github.com/PonyPC/myaut_contrib)
   * https://github.com/sujuhu/autoit
   * https://github.com/Cisco-Talos/clamav-devel/blob/31824a659dff37ae03e3419395bb68e659c2b165/libclamav/autoit.c





  * `EA05` AutoIt3.00
  * `EA06` AutoIt3.26



  * `JB01` AutoHotKey
  * `JB01` AutoIT2


  ```shell
  python3 -m pip install autoit-ripper
  ```

  or, if you'd like to install the version from sources:

  ```shell
  git clone https://github.com/nazywam/AutoIt-Ripper.git
  cd AutoIt-Ripper
  pip install .
  ```



  From a python script:
  ```python
  from autoit_ripper import extract, AutoItVersion

  with open("sample.exe", "rb") as f:
      file_content = f.read()



  content_list = extract(data=file_content, version=AutoItVersion.EA06)
  ```

  From the commandline:
  ```shell
  autoit-ripper sample.exe out_directory
  ```

  Help message:
  ```shell
  autoit-ripper --help
  usage: autoit-ripper [-h] [--verbose] [--ea {EA05,EA06,guess}] file output_dir

  positional arguments:
    file                  input binary
    output_dir            output directory

  optional arguments:
    -h, --help            show this help message and exit
    --verbose, -v
    --ea {EA05,EA06,guess}
                          extract a specific version of AutoIt script (default: guess)

  ```








  |       Field      |    Length     | encryption (EA05) | encryption (EA06) |            Notes            |
  |:----------------:|:-------------:|:-----------------:|:-----------------:|:---------------------------:|
  |      "FILE"      |       4       |  MT(0x16FA)       |  LAME(0x18EE)     |        static string        |
  |       flag       |       4       |  xor(0x29BC)      |  xor(0xADBC)      |                             |
  |     auto_str     |   flag (* 2)  |  MT(0xA25E + flag)|LAME(0xB33F + flag)|        UTF-8/UTF-16         |
  |     path_len     |       4       |  xor(0x29AC)      |  xor(0xF820)      |                             |
  |       path       | path_len (* 2)|MT(0xF25E + path_len)|LAME(0xF479 + path_len) | Path of the compiled script |
  |    compressed    |       1       |  None             |  None             |   is the script compressed  |
  |     data_size    |       4       |  xor(0x45AA)      |  xor(0x87BC)      |    compressed data size     |
  |     code_size    |       4       |  xor(0x45AA)      |  xor(0x87BC)      |    uncompressed data size   |
  |       crc        |       4       |  xor(0xC3D2)      |  xor(0xA685)      | compressed data crc checksum|
  |   creation date  |       4       |  None             |  None             |  file creation date (high)  |
  |   creation date  |       4       |  None             |  None             |  file creation date (low)   |
  | last update date |       4       |  None             |  None             |      last edit date (high)  |
  | last update date |       4       |  None             |  None             |       last edit date (low)  |
  |       data       |   data_size   |MT(checksum + 0x22af)|LAME(0x2477)     |         script data         |



  |                     	| v3.00              	| v3.26                                 	|
  |---------------------	|--------------------	|---------------------------------------	|
  | Code storage        	| greped by magic    	| "SCRIPT" resource (/greped by magic?) 	|
  | String encoding     	| UTF-8             	| UTF-16                                	|
  | Encryption          	| xor/custom MT19937 	| xor/LAME crypt                        	|
  | Code encryption key 	| dynamic            	| static                                	|
  | Compression         	| yes                	| yes                                   	|
  | Code "compilation"  	| no                 	| yes                                   	|
  | Magic               	| EA05               	| EA06                                  	|


pkgId: 2889deaabef4a320b4ac6408c93717b45417ccc2a905b20befd5ccf5d8a700dc
name: python-autojenkins
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Jenkins Remote Control Library
url: https://github.com/txels/autojenkins
rpm_license: GNU Library or Lesser General Public License (LGPL)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autojenkins-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Automation (remote control) of Jenkins tasks.
  Things you can do with it:
  * Create a job (e.g. from a template job)
  * Delete a job
  * Enable or disable a job
  * Obtain the ``config.xml`` file for that job
  * Trigger building of a job
  * Obtain latest execution results
  * ...
  AutoJenkins can be used both as an API and a command-line tool.
  Supports non-authenticated as well as authenticated servers.


pkgId: 373f6a1d374bef4fc209ee1aea706e92ed6b4ad7ddda4853d9bb32ce6d187cdb
name: python-autojinja
arch: src
version: 1.14.1
epoch: 0
release: 1
summary: Content generation with Jinja templates in between comments
url: https://github.com/ldflo/autojinja
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autojinja-1.14.1-1.src.rpm
checksum_type: sha256
description:
  **autojinja** is a Python3 module that allows generating code inside any file using [Jinja templates](https://github.com/pallets/jinja) in between comments. It aims to assist development workflows by using simple Python3 scripts that perform content generation of neighboring files, which enables generating code next to traditionally hand-made code efficiently.

  It includes :
  - Content generation in any file that accepts comments
  - Ability to maintain hand-made code inside generated code
  - Simple integration in build pipelines and existing codebases

  **autojinja** can be seen as a _preprocessor_ for most file formats, and works great with any codebase as it automates writing code manually. It shines out even more when working with metadata files (such as XML or JSON files) that centralize information which later needs to be generated across various scattered files in the codebase.



  ```shell
  $ pip install autojinja
  ```



  ```shell
  $ autojinja script1.py script2.py
  ```
  ```shell
  $ autojinja -a .
  ```



  Content generation consists in generating parts of an existing file thanks to dedicated sections that delimit where the generation takes place. This technique is made possible for all files accepting comments, and allows defining [Jinja templates](https://github.com/pallets/jinja) directly in such files without breaking them.

  For example, let's suppose we have a C++ file we want to generate inside. To do this, we need to write our Jinja template between `[[[` and `]]]` markers, followed by an `[[[end]]]` marker :

  ```cpp
  // main.cpp


  int main() {
    std::cout << "Hello world !" << std::endl;
    // [[[ std::cout << "{{ value }}" << std::endl; ]]]  // Jinja template
    // [[[ end ]]]                                       // Code will be generated in between
    return 0;
  }
  ```

  The template can then be generated with a Python3 script that provides the `value` variable :

  ```python

  from autojinja import CogTemplate

  template = CogTemplate.from_file("main.cpp")
  template.context(value = "Python here !").render_file()
  ```

  Calling the script will modify our C++ file as such :

  ```cpp
  // main.cpp


  int main() {
    std::cout << "Hello world !" << std::endl;
    // [[[ std::cout << "{{ value }}" << std::endl; ]]]  // Jinja template
    std::cout << "Python here !" << std::endl;
    // [[[ end ]]]                                       // Code will be generated in between
    return 0;
  }
  ```

  This technique is greatly inspired by [Cog](https://github.com/nedbat/cog), but adapted to work with Jinja templating engine. When performing generation again, the content inside the markers is entirely replaced by the new generation.



  Modification by hand of generated code is made possible by using special sections that are preserved across new generations. To do this, we need to name a section between `<<[` and `]>>` markers, followed by an `<<[end]>>` marker :

  ```cpp
  // main.cpp


  // [[[
  // int main() {
  //
  //   std::cout << "{{ value }}" << std::endl;
  //   // <<[ impl ]>>  // Manually editable section named 'impl'
  //   return 0;
  //   // <<[ end ]>>   // End of section
  //
  // }
  // ]]]
  int main() {

    std::cout << "Python here !" << std::endl;
    // <<[ impl ]>>  // Manually editable section named 'impl'
    std::cout << "Modified by hand" << std::endl;
    return 1;
    // <<[ end ]>>   // End of section

  }
  // [[[ end ]]]
  ```

  When a new generation occurs, all previous sections are retrieved from the destination file and then reinserted into the new generation, inside each corresponding section with same name.

  All previous sections of a destination file must be reinserted when performing a new generation, otherwise it will be considered as code loss and generation will be aborted. Human intervention is required to deal with such scenarios.



  **autojinja** generation mechanism can be integrated as a build step by listing all Python3 scripts that perform generation :

  ```shell
  $ autojinja script1.py dir/script2.py ...
  ```

  **autojinja** also provides discover mechanisms to find and execute the concerned Python3 scripts in listed directories :

  - `-r -f` recursively executes all Python3 scripts named `__jinja__.py`

      ```shell
      $ autojinja -r -f .
      ```

  - `-r -t` recursively executes all Python3 scripts whose first line contains `autojinja` keyword (can be for instance `import autojinja` or `from autojinja import *`)

      ```shell
      $ autojinja -r -t .
      ```

  - `-a` equivalent to `-r -f -t`

      ```shell
      $ autojinja -a .
      ```

  Centralized metadata files (such as XML or JSON files) can easily be accessed inside Python3 scripts using environment variables and environment files :

  ```shell
  $ autojinja -a . -e FILE1=/tmp/file1.xml -e file.env
  ```


  - [Documentation](https://github.com/ldflo/autojinja/blob/main/docs/doc_autojinja.md)
  - [Examples](https://github.com/ldflo/autojinja/blob/main/examples)
  - [PyPI](https://pypi.org/project/autojinja)
  - [Jinja2](https://github.com/pallets/jinja)
  - [Cog](https://github.com/nedbat/cog)


pkgId: 683b98dc26e36eefa47c2e2ea03d97120ca3c49017231501b998af0a9677bb82
name: python-autokattis
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Updated Kattis API wrapper
url: https://github.com/RussellDash332/autokattis
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autokattis-2.0.2-1.src.rpm
checksum_type: sha256
description:
  Updated Kattis API wrapper as of May 2023 after the major UI/UX change.



  Simply install it as a Python package.

  ```sh
  $ pip install autokattis
  ```



  For now, this package supports `OpenKattis` and `NUSKattis`.



  Construct an `OpenKattis` object that takes in the username and the password.

  ```py
  from autokattis import OpenKattis
  kt = OpenKattis('username', 'password')
  kt = OpenKattis('username') # which will then prompt you for the password
  ```

  where `'username'` is your Kattis username/email and `'password'` is your Kattis account password. **Both should be provided as Python strings.**

  Similarly if you want to login to NUS Kattis.

  ```py
  from autokattis import NUSKattis
  kt = NUSKattis('username', 'password')
  kt = NUSKattis('username')
  ```



  > Due to backwards compatibility, you can still use `Kattis` as a shorthand form of `OpenKattis`.



  ```py
  kt.problems()                               # problems you have solved so far
  kt.problems(show_partial=False)             # exclude partial submissions
  kt.problems(low_detail_mode=False)          # include more data for each problem
  kt.problems(*[True]*4)                      # show literally all problems on Open Kattis

  kt.plot_problems()                          # plot the points distribution
  kt.plot_problems(filepath='plot.png')       # save to a filepath
  kt.plot_problems(show_partial=False)        # plot fully solved submissions

  kt.problem('2048')                          # fetch info about a problem
  kt.problem(['2048', 'abinitio', 'dasort'])  # fetch multiple in one
  kt.problem({'2048', 'abinitio', 'dasort'})  # tuples or sets also allowed
  kt.problem('2048', download_files=True)     # download files too

  kt.stats()                                  # your best submission for each problem
  kt.stats('Java')                            # all your Java submissions
  kt.stats(('Python3', 'Cpp'))                # multiple languages

  kt.suggest()                                # what's the next problem for me?
  kt.achievements()                           # do I have any?
  kt.problem_authors()                        # list down all problem authors
  kt.problem_sources()                        # list down all problem sources
  ```



  ```py
  kt.ranklist()                                                           # people around you

  kt.user_ranklist()                                                      # top 100 users in general ladder
  kt.challenge_ranklist()                                                 # top 100 users in challenge ladder

  kt.country_ranklist()                                                   # top 100 countries
  kt.country_ranklist('Singapore')                                        # specific country
  kt.country_ranklist('SGP')                                              # use country code instead

  kt.university_ranklist()                                                # top 100 universities
  kt.university_ranklist(university='National University of Singapore')   # specific university
  kt.university_ranklist(university='nus.edu.sg')                         # use university domain instead
  ```





  ```py
  kt.problems()                               # problems you have solved so far, only supports low detail mode
  kt.problems(show_solved=False)              # show literally all problems on NUS Kattis

  kt.problem('2048')                          # fetch info about a problem
  kt.problem(['2048', 'abinitio', 'dasort'])  # fetch multiple in one
  kt.problem({'2048', 'abinitio', 'dasort'})  # tuples or sets also allowed
  kt.problem('2048', download_files=True)     # download files too

  kt.stats()                                  # your best submission for each problem
  kt.stats('Java')                            # all your Java submissions
  kt.stats(('Python3', 'Cpp'))                # multiple languages
  ```



  ```py
  kt.courses()                                    # current and recently ended courses
  kt.offerings('CS3233')                          # course offerings
  kt.assignments('CS3233_S2_AY2223')              # offering assignments but course ID not provided
  kt.assignments('CS3233_S2_AY2223', 'CS3233')    # offering assignments
  ```



  As simple as adding `.to_df()`!

  ```py
  kt.problems().to_df()
  kt.ranklist().to_df()
  ```



  Some scenarios you can perform when using `autokattis`:
  1. Mapping problem ID with its difficulty
      ```py
      okt = OpenKattis(...)
      df = okt.problems().to_df()
      diff_map = dict(zip(df.id, df.difficulty))
      ```
  1. Find the number of questions on every assignment on an NUS course offering
      ```py
      nkt = NUSKattis(...)
      df = nkt.assignments('CS3233_S2_AY2324').to_df()
      df['n_problems'] = df['problems'].apply(lambda x: len(x.split(',')))
      df[['name', 'n_problems']]
      ```
  1. Find the average difficulty of every assignment on an NUS course offering
      ```py
      diff_map = ... # see scenario 1

      nkt = NUSKattis(...)
      avg_2dp = lambda x: round(sum(y:=[v for v in x if v != None])/max(len(y), 1), 2)
      df = nkt.assignments('CS3233_S2_AY2324').to_df()
      df['avg_diff'] = df['problems'].apply(lambda x: avg_2dp(map(diff_map.get, x.split(','))))
      df[['name', 'avg_diff']]
      ```
  1. Group top 100 users by country
      ```py
      okt = OpenKattis(...)
      okt.user_ranklist().to_df().groupby('country').size()
      ```



  The docstrings might be a great help if you want to know more about the JSON return values!

  ```py
  from autokattis import OpenKattis
  help(OpenKattis)
  ```



  The `test` directory is provided within this repository. You are free to test `autokattis` with these anytime.

  ```sh
  >>> python test/openkattis.py
  ...
  >>> python test/nuskattis.py
  ...
  ```



  - Old UI Kattis API wrapper: https://github.com/terror/kattis-api

      > Most of the work in `autokattis` is heavily inspired and motivated by this repository.

  - Kattis official CLI tool: https://github.com/Kattis/kattis-cli

      > Since Kattis has provided an official tool to automate submissions, there won't be such feature in `autokattis`.



  Feel free to suggest anything or add on some implementation by simply creating a pull request!


pkgId: b901c630fc06ec2609be1206d8a0f5225c6e002c70377a94647ddcfbfa767591
name: python-autokeras
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: AutoML for deep learning
url: http://autokeras.com
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autokeras-2.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img width="500" alt="logo" src="https://autokeras.com/img/row_red.svg"/>
  </p>

  [![](https://github.com/keras-team/autokeras/workflows/Tests/badge.svg?branch=master)](https://github.com/keras-team/autokeras/actions?query=workflow%3ATests+branch%3Amaster)
  [![codecov](https://codecov.io/gh/keras-team/autokeras/branch/master/graph/badge.svg)](https://codecov.io/gh/keras-team/autokeras)
  [![PyPI version](https://badge.fury.io/py/autokeras.svg)](https://badge.fury.io/py/autokeras)
  [![Python](https://img.shields.io/badge/python-v3.8.0+-success.svg)](https://www.python.org/downloads/)
  [![Tensorflow](https://img.shields.io/badge/tensorflow-v2.8.0+-success.svg)](https://www.tensorflow.org/versions)
  [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/keras-team/autokeras/issues)

  Official Website: [autokeras.com](https://autokeras.com)


  AutoKeras: An AutoML system based on Keras.
  It is developed by <a href="http://faculty.cs.tamu.edu/xiahu/index.html" target="_blank" rel="nofollow">DATA Lab</a> at Texas A&M University.
  The goal of AutoKeras is to make machine learning accessible to everyone.



  * A short example.

  ```python
  import autokeras as ak

  clf = ak.ImageClassifier()
  clf.fit(x_train, y_train)
  results = clf.predict(x_test)
  ```

  * [Official website tutorials](https://autokeras.com/tutorial/overview/).
  * The book of [*Automated Machine Learning in Action*](https://www.manning.com/books/automated-machine-learning-in-action?query=automated&utm_source=jin&utm_medium=affiliate&utm_campaign=affiliate&a_aid=jin).
  * The LiveProjects of [*Image Classification with AutoKeras*](https://www.manning.com/liveprojectseries/autokeras-ser).
  <p align="center">
  <a href="https://www.manning.com/books/automated-machine-learning-in-action?query=automated&utm_source=jin&utm_medium=affiliate&utm_campaign=affiliate&a_aid=jin"><img src="https://images.manning.com/360/480/resize/book/0/fc56aaf-b2ba-4ef4-85b3-4a31edbe8ecc/Song-AML-HI.png" alt="drawing" width="266"/></a>
  &nbsp
  &nbsp
  <a href="https://www.manning.com/liveprojectseries/autokeras-ser"><img src="https://images.manning.com/360/480/resize/liveProjectSeries/9/38c715a-0c8c-4f66-b440-83d29993877a/ImageClassificationwithAutoKeras.jpg" alt="drawing" width="250"/></a>
  </p>




  To install the package, please use the `pip` installation as follows:

  ```shell
  pip3 install autokeras
  ```

  Please follow the [installation guide](https://autokeras.com/install) for more details.

  **Note:** Currently, AutoKeras is only compatible with **Python >= 3.7** and **TensorFlow >= 2.8.0**.



  Ask your questions on our [GitHub Discussions](https://github.com/keras-team/autokeras/discussions).



  Here is how we manage our project.

  We pick the critical issues to work on from [GitHub issues](https://github.com/keras-team/autokeras/issues).
  They will be added to this [Project](https://github.com/keras-team/autokeras/projects/3).
  Some of the issues will then be added to the [milestones](https://github.com/keras-team/autokeras/milestones),
  which are used to plan for the releases.

  Refer to our [Contributing Guide](https://autokeras.com/contributing/) to learn the best practices.

  Thank all the contributors!

  [![The contributors](https://autokeras.com/img/contributors.svg)](https://github.com/keras-team/autokeras/graphs/contributors)



  Haifeng Jin, François Chollet, Qingquan Song, and Xia Hu. "AutoKeras: An AutoML Library for Deep Learning." *the Journal of machine Learning research* 6 (2023): 1-6. ([Download](http://jmlr.org/papers/v24/20-1355.html))

  Biblatex entry:

  ```bibtex
  @article{JMLR:v24:20-1355,
    author  = {Haifeng Jin and François Chollet and Qingquan Song and Xia Hu},
    title   = {AutoKeras: An AutoML Library for Deep Learning},
    journal = {Journal of Machine Learning Research},
    year    = {2023},
    volume  = {24},
    number  = {6},
    pages   = {1--6},
    url     = {http://jmlr.org/papers/v24/20-1355.html}
  }
  ```



  The authors gratefully acknowledge the D3M program of the Defense Advanced Research Projects Agency (DARPA) administered through AFRL contract FA8750-17-2-0116; the Texas A&M College of Engineering, and Texas A&M University.


pkgId: 51391da9d598202fa12003ba67fc34f400a2cd6264c761d16152cfa7fa8293a8
name: python-autokit
arch: src
version: 0.14.16
epoch: 0
release: 1
summary: A simple tool to automate the installation and integration of external tools.
url: https://github.com/lukasgolson/Autokit
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autokit-0.14.16-1.src.rpm
checksum_type: sha256
description:
  A framework for effortlessly integrating external tools into your Python projects.



  ```bash
  pip install autokit
  ```



  ```python
  from autokit import ToolConfig, PlatformData, ExternalTool
  from pathlib import Path

  class TestTool(ExternalTool):
      def __init__(self, base_dir: str = "./third-party", progress_bar: bool = True, lazy_setup: bool = False):
          super().__init__(base_dir, progress_bar, lazy_setup)

      @property
      def config(self) -> ToolConfig:
          return ToolConfig(
              tool_name="tests-tool",
              platform_data={
                  "windows": PlatformData(
                      url="https://github.com/IRSS-UBC/MediaTools/releases/download/latest/win-x64.zip",
                      subdir=Path(""),
                      executable=Path("IRSSMediaTools.exe")
                  ),
              },
              python=False,
          )

      def help(self):
          self.run_command("help")


  if __name__ == "__main__":
      test = TestTool()
      test.help()
  ```


  - Automatic download and configuration of external tools on first use.
  - Define tools and their commands in a configuration file.
  - Streamlined execution of tool commands from within your Python code.


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


  [MIT](https://choosealicense.com/licenses/mit/)


  Contact: olson@student.ubc.ca


pkgId: 213b32901f838e62459405700f896a49c79d43ce62c79f701337e276a5505b7c
name: python-autokitteh
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: AutoKitteh Python SDK
url: https://pypi.org/project/autokitteh/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autokitteh-0.3.4-1.src.rpm
checksum_type: sha256
description:
  This is the Python SDK for [AutoKitteh](https://autokitteh.com).

  It provides the following utilities for AutoKitteh workflows:

  - Client initialization functions for AutoKitteh connections
  - Un/subscription and consumption functions for AutoKitteh events
  - `activity` decorator to work around issues with [pickle](https://docs.python.org/3/library/pickle.html)

  For more information, see [our documentation](https://docs.autokitteh.com/develop/python).



  Installing is required only for local testing.

  When AutoKitteh runs your workflows it'll install this library automatically.

  ```
  python -m pip install autokitteh
  ```

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 AutoKitteh Inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 38995322878c6dc3f39e60d0a6d72c89fb0651b8fe52d9658b311e7b0537e086
name: python-autolab
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Python package for scientific experiments interfacing and automation
url: https://github.com/autolab-project/autolab
rpm_license: GPL-3.0 license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autolab-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/autolab)](https://pypi.org/project/autolab/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/autolab)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/autolab.svg?label=PyPI%20downloads)](https://pypi.org/project/autolab/)

  [![Documentation Status](https://readthedocs.org/projects/autolab/badge/?version=latest)](https://autolab.readthedocs.io/en/latest/?badge=latest)


  __Python package for scientific experiments automation__

  The purpose of this package it to provide easy and efficient tools to deal with your scientific instruments, and to run automated experiments with them, by command line instructions or through a graphical user interface (GUI).

  Created by Quentin Chateiller, Python drivers originally from Quentin Chateiller and Bruno Garbin, for the C2N-CNRS (Center for Nanosciences and Nanotechnologies, Palaiseau, France) ToniQ team.
  Project continued by Jonathan Peltier, for the C2N-CNRS Minaphot team and Mathieu Jeannin, for the C2N-CNRS Odin team.

  Project hosted at https://github.com/autolab-project/autolab

  Drivers made for this package can be found at https://github.com/autolab-project/autolab-drivers

  Visit https://autolab.readthedocs.io/ for the full documentation of this package.



  <img src="https://raw.githubusercontent.com/autolab-project/autolab/master/docs/scheme.png">



  <img src="https://raw.githubusercontent.com/autolab-project/autolab/master/docs/gui/scanning.png">

  <img src="https://raw.githubusercontent.com/autolab-project/autolab/master/docs/gui/control_panel.png">


pkgId: 95c80a100902bfc5ac085ed52a9aa96f0ed7384197371e68045f589c012fd983
name: python-autolab-core
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Core utilities for the Berkeley AutoLab
url: https://github.com/BerkeleyAutomation/autolab_core
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autolab-core-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Core utilities for the Berkeley AutoLab. Includes rigid transformations, loggers, and 3D data wrappers.


pkgId: 9d78d0887fa3b51986fb83c5bf49f9050260bd4da7c65637fddbc2e653816468
name: python-autolens
arch: src
version: 2024.11.13.2
epoch: 0
release: 1
summary: Open-Source Strong Lensing
url: https://github.com/Jammy2211/PyAutoLens
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autolens-2024.11.13.2-1.src.rpm
checksum_type: sha256
description:
  |binder| |RTD| |Tests| |Build| |code-style| |JOSS| |arXiv|
  `Installation Guide <https://pyautolens.readthedocs.io/en/latest/installation/overview.html>`_ |
  `readthedocs <https://pyautolens.readthedocs.io/en/latest/index.html>`_ |
  `Introduction on Binder <https://mybinder.org/v2/gh/Jammy2211/autolens_workspace/release?filepath=start_here.ipynb>`_ |
  `HowToLens <https://pyautolens.readthedocs.io/en/latest/howtolens/howtolens.html>`_
  When two or more galaxies are aligned perfectly down our line-of-sight, the background galaxy appears multiple times.
  This is called strong gravitational lensing and **PyAutoLens** makes it simple to model strong gravitational lenses.


pkgId: e1b30be332c357c804c0db68f3f65fc4d94162cc151172f22ea293d1d948e0d0
name: python-autolink-references-mkdocs-plugin
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: This plugin allows to configure your own autolink references for non-GitHub URLs.
url: https://pypi.org/project/autolink-references-mkdocs-plugin/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autolink-references-mkdocs-plugin-0.2.2-1.src.rpm
checksum_type: sha256
description:
  This [mkdocs plugin](http://www.mkdocs.org/user-guide/plugins/)
  look in each MkDocs article for the presence of a reference to tickets from issues
  trackers like Jira, Linear, etc and convert them to links that point to respective
  platforms:



  To install it, using `pip`:

  ```
  pip install autolink-references-mkdocs-plugin
  ```

  Edit your `mkdocs.yml` file and add these few lines of code:

  ```yaml
  plugins:
     - autolink_references:
          autolinks:
              - reference_prefix: AF-
                target_url: https://linear.com/AF-<num>
              - reference_prefix: PROJ-
                target_url: https://jiracloud.com/PROJ-<num>
  ```

  - __reference_prefix__: This prefix appended by a number will generate a link any time it is found in a page.
  - __target_url__: The URL must contain `<num>` for the reference number.



  For example, you could edit the `docs/index.md` file and insert the ticket references like this:

  ````markdown

  Changelog:

  - AF-100: add new feature.

  ````

  This will generate pre-processed to:

  ```
  Changelog:

  - [AF-100](https://linear.com/AF-100): add new feature.

  ```





  - Allow extended set for <num> and ignore ref style links, already linked items, and attr_list cases with '#' before the ref


  - Ignore already linked references.
  - Converts text `[AF-100]` to a linked version and removes the brackets `AF-100`



  MIT

  Built with ❤️ by [Saurabh Kumar](https://saurabh-kumar.com?ref=autolink-references-mkdocs-plugin)


pkgId: 203cacc1cf784cf4c7b3a90c9dbbbfa3f06cafaba1604d564e28ad9b0dceedec
name: python-autoload-module
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Python Autoload Module
url: https://github.com/hiroki0525/autoload_module
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoload-module-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/autoload-module.svg)](https://badge.fury.io/py/autoload-module)
  [![Test](https://github.com/hiroki0525/autoload_module/actions/workflows/test.yml/badge.svg)](https://github.com/hiroki0525/autoload_module/actions/workflows/test.yml)
  [![Downloads](https://pepy.tech/badge/autoload-module)](https://pepy.tech/project/autoload-module)
  <img src="https://img.shields.io/badge/license-MIT-blue.svg?style=flat" alt="MIT License image">

  This library will give you comfortable Python metaprogramming.
  The following is a plain example.

  - Directory
  ```
  project/
   ├ example.py
   └ validator/
     ├ validator_a.py
     ├ validator_b.py
     └ validator_c.py
  ```
  - example.py
  ```python
  from autoload import ModuleLoader

  input = "foo bar baz"
  loader = ModuleLoader()


  validator_classes = loader.load_classes("validator")
  try:
      
      [clazz().validate(input) for clazz in validator_classes]
  except:
      print("input is invalid!!")
  ```

  ```
  pip install autoload-module
  ```


  ```
  ModuleLoader(
    base_path: Optional[str] = None,
    strict: bool = False
  )
  ```
  The ModuleLoader can be generated with no parameters.
  In that case, the instance has the absolute path where
  it was initialized.
  - Directory
  ```
  /usr/local/src/project/
    ├ example.py
    └ validator/
      ├ validator_a.py
      ├ validator_b.py
      └ validator_c.py
  ```
  - example.py
  ```python
  from autoload import ModuleLoader


  loader = ModuleLoader()


  validator_classes = loader.load_classes("validator")
  ```
  If you want to change the base path, you must generate the ModuleLoader with an absolute path parameter.
  ```python
  loader = ModuleLoader('/user/local/src/custom')
  ```

  About strict parameter, please see [here](#NOTE) .

  You can also create global setting and initialize singleton object.
  ```python
  from autoload import ModuleLoader
  import os


  ModuleLoader.set_setting(base_path=os.getcwd(), strict=True)

  loader_a = ModuleLoader()
  loader_b = ModuleLoader()

  print(loader_a.base_path)

  print(loader_b.base_path)



  ModuleLoader.set_setting(singleton=True)

  loader_c = ModuleLoader()
  loader_d = ModuleLoader()
  loader_e = ModuleLoader('/test')

  assert loader_c is loader_d # OK
  assert loader_c is loader_e # OK


  assert loader_c.base_path is loader_e.base_path # OK
  ```



  ```
  load_classes(
      src: str,
      excludes: Iterable[str] = (),
      recursive: bool = False,
  ) -> Tuple[Type, ...]:
  ```
  This method read the Python package or module and return the tuple of class objects.

  - Directory
  ```
  pkg/
   ├ example.py
   ├ __init__.py
   ├ config.yaml
   └ main/
       ├ validator_a.py
       ├ validator_b.py
       ├ validator_c.py
       └ sub/
          ├ validator_d.py
          └ validator_e.py
  ```
  - validator_a.py
  ```python
  class ValidatorA:
      def validate(self):
          print("validateA!!")
  ```
  - example.py
  ```python
  loader = ModuleLoader()



  validator_classes = loader.load_classes("main")


  [clazz().validate() for clazz in validator_classes]



  ```
  You can also load only specific modules using `excludes` variable or `load_config` decorator as below.
  ```python



  validator_classes = loader.load_classes("main", ["validator_a"])

  [clazz().validate() for clazz in validator_classes]




  from autoload import load_config

  @load_config(load=False)
  class ValidatorA:
    def validate(self):
      print("validateA!!")

  validator_classes = loader.load_classes("main")

  [clazz().validate() for clazz in validator_classes]


  ```
  This function will check directory structure recursively if you specify `recursive=True`.
  ```python


  validator_classes = loader.load_classes("main", recursive=True)

  [clazz().validate() for clazz in validator_classes]





  ```
  You can specify `src` as below.
  ```python
  loader.load_classes("main/validator_a.py")
  loader.load_classes("main.validator_a")
  loader.load_classes("./main/validator_a")
  loader.load_classes(".main.validator_a")
  loader.load_classes("main.sub.validator_d")
  loader.load_classes("./main/sub/validator_d")
  loader.load_classes("../otherpkg")
  loader.load_classes("..otherpkg")
  ```


  ```
  load_functions(
      src: str,
      excludes: Iterable[str] = (),
      recursive: bool = False,
  ) -> Tuple[Callable, ...]:
  ```
  This method read the Python package or module and return the tuple of functions.
  The usage is the same as `load_classes`.


  - To search class or function, **You must match the name of file, and the one of class or function.**
  For example, if you named the file `test_module.py`, you must name the class `TestModule` or the function `test_module`.
  When you want to customize their name, use `@load_config` decorator.
      - validator_a.py
      ```python
      from autoload import load_config

      @load_config()
      class CustomValidator:
          def validate(self):
              print("validateA!!")
      ```
  - You can also control the order of loaded class objects using `@load_config` decorator.
      - validator_a.py
      ```python
      from autoload import load_config

      
      @load_config(order=1)
      class ValidatorA:
          def validate(self):
              print("validateA!!")
      ```
  - If you decorate some classes or functions with `@load_config`, the loader will load them.
    However, initialized `strict=True`, the loader denies multiple loading as below.
    - pkg/validator_a.py
    ```python
    from autoload import load_config

    
    class ValidatorA:
      def validate(self):
          print("validateA!!")

    
    @load_config(order=2)
    class Foo:
      pass
    ```

    - main.py
    ```python
    from autoload import ModuleLoader
    from autoload.exception import LoaderStrictModeError

    loader = ModuleLoader()
    
    classes = loader.load_classes("pkg")

    
    
    strict_loader = ModuleLoader(strict=True)
    try:
      classes = strict_loader.load_classes("pkg")
    except LoaderStrictModeError as e:
      print(e)
    
    
    ```

  ```
  load_class(file_name: str)
  ```
  This method read the Python file and return the class object.
  - Directory
  ```
  project/
    ├ example.py
    └ validator.py
  ```
  - validator.py
  ```python
  class Validator:
      def validate(self):
          print("validate!!")
  ```
  - example.py
  ```python
  loader = ModuleLoader()
  clazz = loader.load_class("validator")
  clazz().validate()

  ```
  How to specify `file_name` is the same as that of `load_classes`.


  ```
  load_function(file_name: str)
  ```
  This method read the Python file and return a function object.
  The usage is the same as `load_class`.


  Released under the MIT license.


pkgId: 170e9f51422e8c1722543630d16afcc37e01004f3c5041fa1755e94d03f4670d
name: python-autoload-module
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Python Autoload Module
url: https://github.com/hiroki0525/autoload_module
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoload-module-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/autoload-module.svg)](https://badge.fury.io/py/autoload-module)
  [![Test](https://github.com/hiroki0525/autoload_module/actions/workflows/test.yml/badge.svg)](https://github.com/hiroki0525/autoload_module/actions/workflows/test.yml)
  [![Downloads](https://pepy.tech/badge/autoload-module)](https://pepy.tech/project/autoload-module)
  ![MIT License image](<%5Bimage_url%5D(https://img.shields.io/badge/license-MIT-blue.svg?style=flat)>)

  Get classes and functions from modules simply and efficiently.
  The following is a plain example.

  ▼ Directory

  ```text
  project/
   ├ main.py
   └ pipelines/
     ├ pipeline_a.py
     ├ pipeline_b.py
     └ pipeline_c.py
  ```

  ▼ main.py

  ```py
  from autoload import autoload
  from functools import reduce


  pipelines = autoload("pipelines", "function")

  initial_value = 1


  final_result = reduce(lambda acc, func: func(acc), pipelines, initial_value)
  ```



  ```bash
  pip install autoload-module
  ```



  There are only 2 steps. Imagine the following directory structure.

  ```text
  project/
   ├ main.py
   └ functions.py
  ```



  ```py


  from autoload import loadable


  @loadable
  def increment(number: int) -> int:
      return number + 1


  @loadable
  def decrement(number: int) -> int:
      return number - 1
  ```



  ```py


  from autoload import autoload


  def main() -> None:
      functions = autoload("pipelines", "function")
      
      

      
      print(functions[0](1))
      

      
      print(functions[1](1))
      


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





  Set `"class"` to `autoload` .

  ▼ Directory

  ```text
  project/
   ├ main.py
   └ pipelines.py
  ```

  ▼ Code

  ```py


  from autoload import loadable


  @loadable
  class PipelineA:
      pass


  @loadable
  class PipelineB:
      pass



  from autoload import autoload

  classes = autoload("pipelines", "class")
  ```



  Set `"recursive=True"` to `autoload` .

  ▼ Directory

  ```text
  project/
   ├ main.py
   └ main_package/
     ├ module_a.py
     └ sub_package/
       ├ module_b.py
       └ module_c.py
  ```

  ▼ Code

  ```py

  @loadable
  def module_a_function() -> None:
      pass



  @loadable
  def module_b_function() -> None:
      pass



  @loadable
  def module_c_function() -> None:
      pass




  functions = autoload("main_package", "function")


  functions = autoload("main_package", "function", recursive=True)
  ```



  Set `order` to `@loadable` .

  ```py
  @loadable(order=3)
  def function_3() -> None:
      pass


  @loadable(order=1)
  def function_1() -> None:
      pass


  @loadable(order=2)
  def function_2() -> None:
      pass




  functions = autoload("package", "function")
  ```



  Set `base` to `autoload` .

  ```py
  functions = autoload("..module_a", "function", base="main_package.sub_package")
  ```



  Released under the MIT license.


pkgId: cc4a2743ac98b5e7fbca05256b9b16e7e87362c6406177c335dc436dc1072fe4
name: python-automagic-rest
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Automagic REST: Django REST Framework Code Generator for Underlying PostgreSQL DBs
url: https://github.com/wharton/automagic-rest
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automagic-rest-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/automagic-rest.svg)](https://pypi.python.org/pypi/automagic-rest/)

  Automagic REST is a code generator which builds a full Django app as a Django REST Framework read-only environment for a set of tables in a PostgreSQL database.

  This is very much for a specific niche, but we have found it quite powerful for building a RESTful API on top of datasets we receive from other sources through introspection of PostgreSQL's `information_schema`.



  To get started, `pip install automagic-rest` and add `automagic_rest` to your `INSTALLED_APPS` setting in Django.



  Setting up a secondary database in Django is recommended. For the following examples, we'll set up one called `my_pg_data` with the user `my_pg_user`:

  ```python
  DATABASES = {
      'default': {
          'ENGINE': 'django.db.backends.postgresql',
          'NAME': 'pg_web_db',
          'USER': 'web_user',
          'PASSWORD': '',
          'HOST': 'pg-web.domain.com',
      },
      'my_pg_data': {
          'ENGINE': 'django.db.backends.postgresql',
          'NAME': 'pg_data_db',
          'USER': 'my_pg_user',
          'PASSWORD': '',
          'HOST': 'pg-data.domain.com',
      },
  }
  ```

  By default, Automagic REST will create a directory called `data_path` at the root of your Django project, where `manage.py` lives. The follow options can be passed to the command:

  * `--database` (default: `my_pg_data`): the name of the Django database as defined in the `DATABASES` setting.
  * `--owner` (default: `my_pg_user`): the name of the PostgreSQL user which owns the schemata to be processed. This will normally be the same as the `USER` in the `DATABASES` setting for the database above.
  * `--path` (default: `data_path`): the path to write the models and serializers to. This path will be completely deleted and rewritten whenever the command is run, so be careful!

  Example: `python manage.py build_data_models --database=my_data --owner=my_user --path=my_data_path`

  Methods are provided which can be overridden to customize the endpoint with your own Django management command.



  `get_db` (default: `my_pg_data`): the name of the PostgreSQL database in Django's settings that we will introspect to build the API.

  `get_owner` (default: `my_pg_user`): the name of the PostgreSQL user that owns the schemata we will introspect.

  `get_allowed_schemata` (default: `None`): if set, returns a list of schemata in the database to be built. If `None`, selects all schemata for the specific user.

  `get_extra_sql` (default: `""`): if set, appends the SQL returned by this method to
  the information schema query. Useful for exclusions.

  `get_root_python_path` (default: `data_path`): a Python path where you would like to write the models, serializers, and routes. **IMPORTANT**: this path will be wiped and re-written every time the build command is run. It should be a dedicated directory with nothing else in it.

  `get_view` (default: `automagic_rest.views.GenericViewSet`): the view to use.

  `get_router` (default: `rest_framework.routers.DefaultRouter`): the router to use.

  `get_max_digits_default` (default: 100): the number of `max_digits` to provide for `NUMERIC` field types that are not explicitly set in PostgreSQL.

  `get_decimal_places_default` (default: 25): the number of `decimal_places` to provide for `NUMERIC` field types that are not explicitly set in PostgreSQL.

  `sanitize_sql_identifier`: this method takes a string, and sanitizes it for injections into SQL, allowing only alphanumerics and underscores.

  `metadata_sql`: this method returns the SQL used to pull the metadata from PostgreSQL to build the endpoints.

  To customize the build command, here is an example:

  ```python

  from automagic_rest.management.commands import build_data_models


  class Command(build_data_models.Command):
      """
      My specific overrides for DRF PG Builder command.
      """

      def get_db(self, options):
          """
          Returns our customized Django DB name.
          """
          return "my_data"

      def get_owner(self, options):
          """
          Returns our customized schema owner.
          """
          return "my_user"

      def get_root_python_path(self, options):
          """
          Returns our customized build path.
          """
          return "my_data_path"

      def get_view(self):
          """
          Returns our customized view path.
          """
          return "my_app.views.MyDataViewSet"

      def get_allowed_schemata(self, options, cursor):
          """
          Return a list of allowed schemata we want to create RESTful
          endpoints for. If None, will create endpoints for all schemata
          owned by the schema owner user.
          """
          allowed_schemata = ['my_data', 'public_data']

          return allowed_schemata

      def get_extra_sql(self):
          """
          Returns SQL to append to the information schema query.

          In this example, we exclude any tables ending in "_old".
          """
          return """
              AND c.table_name NOT LIKE '%_old'
          """
  ```



  The view has several methods and attributes which can be overridden as well.



  `index_sql`: this attribute defines SQL to return the first column in each index for the current table for the Model. These will be used to dynamically make all indexed fields searchable and filterable.



  `get_serializer_class_name` (default: `rest_framework.serializers.ModelSerializer`): the full path of the serializer class to use.

  `get_permission` (default: `None`): returns a permission class to use for the endpoint. When left at the default of `None`, uses the default permission class set by Django REST Framework.

  `get_estimate_count_limit` (default: `999_999`): to prevent long-running `SELECT COUNT(*)` queries, the view estimates the number of rows in the table by examing the query plan. If greater than this number, it will estimate pagination counts for vastly improved speed.

  To follow on the example above, here is an example of an overridden view, which sets the permission type and includes a mixin for naming Excel file downloads:

  ```python
  from rest_framework.permissions import IsAuthenticated
  from drf_excel.mixins import XLSXFileMixin

  class MyGenericViewSet(XLSXFileMixin, GenericViewSet):
      """
      """
      """
      Override the defaults from DRF PG Builder.
      """
      filename = 'my_export.xlsx'

      def get_permission(self):
          return IsAuthenticated
  ```



  After running the build command, you should have a directory created that you defined as `path` (or overrode with `get_root_python_path()`) that contains models, serializers, and a `urls.py` file. Include the `urls.py` file with a route from your Django project, and you should be able to visit the Django REST Framework browsable API.



  * Certain column types are not supported, such as `ts_vector` and others that don't map cleanly to a RESTful type.



  * [Release notes](https://github.com/wharton/automagic-rest/releases)
  * [Our wonderful contributors](https://github.com/wharton/automagic-rest/graphs/contributors)


  * [Timothy Allen](https://github.com/FlipperPA) at [The Wharton School](https://github.com/wharton)

  This package is maintained by the staff of [Wharton Research Data Services](https://wrds.wharton.upenn.edu/). We are thrilled that [The Wharton School](https://www.wharton.upenn.edu/) allows us a certain amount of time to contribute to open-source projects. We add features as they are necessary for our projects, and try to keep up with Issues and Pull Requests as best we can. Due to constraints of time (our full time jobs!), Feature Requests without a Pull Request may not be implemented, but we are always open to new ideas and grateful for contributions and our package users.


pkgId: c8100799b92aff7fcb61bba6e1b31d0be1f1d19468a1d90c4b42dfc9710de1af
name: python-automap
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: High-performance autoincremented integer-valued mappings.
url: https://github.com/brandtbucher/automap
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automap-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![latest version](https://img.shields.io/github/release-pre/brandtbucher/automap.svg?style=for-the-badge&label=latest)![latest release date](https://img.shields.io/github/release-date-pre/brandtbucher/automap.svg?style=for-the-badge&label=released)](https://github.com/brandtbucher/automap/releases)[![build status](https://img.shields.io/github/workflow/status/brandtbucher/automap/CI/master.svg?style=for-the-badge)](https://github.com/brandtbucher/automap/actions)[![issues](https://img.shields.io/github/issues-raw/brandtbucher/automap.svg?label=issues&style=for-the-badge)](https://github.com/brandtbucher/automap/issues)
  <br>
  </div>
  `automap` is a Python package containing high-performance autoincremented
  integer-valued mappings.
  To install, just run `pip install automap`.


pkgId: 36d347732219943bcb4905d0c102466dc08f1abfc1e6a29e83abf005e2ed9211
name: python-automata-lib
arch: src
version: 8.4.0
epoch: 0
release: 1
summary: A Python library for simulating finite automata, pushdown automata, and Turing machines
url: https://pypi.org/project/automata-lib/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automata-lib-8.4.0-1.src.rpm
checksum_type: sha256
description:
  *Copyright 2016-2024 Caleb Evans*
  *Released under the MIT license*

  [![PyPI version](https://badge.fury.io/py/automata-lib.svg)](https://badge.fury.io/py/automata-lib)
  [![tests](https://github.com/caleb531/automata/actions/workflows/tests.yml/badge.svg)](https://github.com/caleb531/automata/actions/workflows/tests.yml)
  [![docs](https://github.com/caleb531/automata/actions/workflows/docs.yml/badge.svg)](https://github.com/caleb531/automata/actions/workflows/docs.yml)
  [![Coverage Status](https://coveralls.io/repos/caleb531/automata/badge.svg?branch=main)](https://coveralls.io/r/caleb531/automata?branch=main)
  [![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/automata-lib)
  [![status](https://joss.theoj.org/papers/fe4d8521383598038e38bc0c948718af/status.svg)](https://joss.theoj.org/papers/fe4d8521383598038e38bc0c948718af)
  [![pyOpenSci](https://tinyurl.com/y22nb8up)](https://github.com/pyOpenSci/software-submission/issues/152)

  Links:
  - [**Documentation**](https://caleb531.github.io/automata/)
  - [**Examples**](https://caleb531.github.io/automata/examples/fa-examples/)
  - [**Migration Guide**](https://caleb531.github.io/automata/migration/)
  - [**API**](https://caleb531.github.io/automata/api/)

  Automata is a Python 3 library implementing structures and algorithms for manipulating finite automata,
  pushdown automata, and Turing machines. The algorithms have been optimized and are capable of
  processing large inputs. Visualization logic has also been implemented. This package is suitable for
  both researchers wishing to manipulate automata and for instructors teaching courses on theoretical
  computer science.

  The library requires Python 3.8 or newer.

  Huge thanks to [@eliotwrobson][eliotwrobson], [@YtvwlD][YtvwlD],
  [@dengl11][dengl11], [@Tagl][Tagl], [@lewiuberg][lewiuberg],
  [@CamiloMartinezM][CamiloMartinezM],
  [@abhinavsinha‑adrino][abhinavsinha-adrino],
  [@EduardoGoulart1][EduardoGoulart1],
  [@khoda81][khoda81], and
  [@christopher-hampson][christopher-hampson] for their invaluable code contributions to
  this project! 🎉

  [eliotwrobson]: https://github.com/eliotwrobson
  [YtvwlD]: https://github.com/YtvwlD
  [dengl11]: https://github.com/dengl11
  [Tagl]: https://github.com/Tagl
  [lewiuberg]: https://github.com/lewiuberg
  [CamiloMartinezM]: https://github.com/CamiloMartinezM
  [abhinavsinha-adrino]: https://github.com/abhinavsinha-adrino
  [EduardoGoulart1]: https://github.com/EduardoGoulart1
  [khoda81]: https://github.com/khoda81
  [christopher-hampson]: https://github.com/christopher-hampson



  You can install the latest version of Automata via pip:

  ```sh
  pip install automata-lib
  ```

  To install the optional visual dependencies, use the `visual` extra:

  ```sh
  pip install 'automata-lib[visual]'
  ```

  If you encounter errors building `pygraphviz`, you may need to install `graphviz`.
  See the instructions [here](https://graphviz.org/download/).



  Contributions are always welcome! Take a look at the [contributing guide](./CONTRIBUTING.md).

rpm_license:
  The MIT License (MIT)  Copyright (c) 2016-2024 Caleb Evans  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: 137d5eb294f3a37d2552976a3f9d20ebf5329656ac148dbd9e0f693a29873f02
name: python-automata-tools
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Tools to build automata from your custom rule
url: https://github.com/linonetwo/automata-tools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automata-tools-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Tools to build automata from your custom rule.

  This package provides a set of handy tools to programmatically build automata, so you can build NFA、DFA、MinimizedDFA、WFA from any custom rules.





  ```shell
  conda install -c conda-forge automata-tools # not available yet

  pip install automata-tools
  ```



  See example in [examples/NFAfromCustomRule.py](examples/NFAfromCustomRule.py)

  ```python
  from typing import List
  from automata_tools import BuildAutomata, Automata

  automata: List[Automata] = []
  ```





  Build simple `(0)-[a]->(1)` automata

  ```python
  automata.append(BuildAutomata.characterStruct(char))
  ```



  Build automata that is an "or" of two sub-automata `(1)<-[a]-(0)-[b]->(1)`

  ```python

  a = automata.pop()
  b = automata.pop()
  if operator == "|":
      automata.append(BuildAutomata.unionStruct(b, a))
  ```



  Build automata that is an "and" of two sub-automata `(0)-[a]->(1)-[b]->(2)`

  ```python

  a = automata.pop()
  b = automata.pop()
  automata.append(BuildAutomata.concatenationStruct(b, a))
  ```



  Build automata that looks like the "Kleene closure"

  ```python

  if operator == "*":
      a = automata.pop()
      automata.append(BuildAutomata.starStruct(a))
  ```



  Build automata that looks like the "Kleene closure" but without the loop back `(1)<-[ε]-(2)`, so it only match the token once at most.

  ```python

  if operator == "?":
      a = automata.pop()
      automata.append(BuildAutomata.skipStruct(a))
  ```



  Build automata that will match the same token for several times `(0)-[a]->(1)-[a]->(2)-[a]->(3)`

  ```python

  repeatedAutomata = BuildAutomata.repeatStruct(automata, 3)
  ```



  Build automata that will match the same token for n to m times

  `(0)-[a]->(1)-[a]->(4), (0)-[a]->(2)-[a]->(3)-[a]->(4)`

  ```python

  repeatedAutomata = BuildAutomata.repeatRangeStruct(automata, 2, 3)
  ```



  See example in [features/steps/customRule.py](features/steps/customRule.py)

  ```python
  from automata_tools import DFAFromNFA, Automata

  from your_implementation import NFAFromRegex, executor

  nfa: Automata = NFAFromRegex().buildNFA(rule)
  minDFA: Automata = DFAFromNFA(nfa).getMinimizedDFA()
  minDFA.setExecuter(executor)

  print(minDFA.execute(someText))
  ```

  where `executor` is a function like the one in [examples/NFAfromCustomRule.py](examples/NFAfromCustomRule.py):

  ```python
  def executor(tokens, startState, finalStates, transitions):
      return True
  ```



  Set an executor to the automata that can freely use state and transition of the automata, and return a boolean value.

  ```python
  from automata_tools import IAutomataExecutor

  defaultExecuter: IAutomataExecutor = lambda tokens, startState, finalStates, transitions: True
  minDFA.setExecuter(defaultExecuter)
  ```



  Set an tokenizer to the automata that can transform string to list of string token, which will be used by the executer.

  ```python
  minDFA.setExecuter(lambda input: input.split(' ')[::-1])
  ```



  Make automata state transitions not so ambiguous

  ```python
  nfa = NFAFromRegex().buildNFA(rule)
  dfa = NFAtoDFA(nfa)
  ```



  Allow you minify Automata state

  ```python
  nfa = NFAFromRegex().buildNFA(rule)
  minDFA = DFAtoMinimizedDFA(NFAtoDFA(nfa))
  ```



  WFA, it can execute automata use matrix multiplication, so it can be very fast compare to brute force execution, especially when state space is large.

  ```python
  from automata_tools import WFA, get_word_to_index

  _, wordToIndex = get_word_to_index([ruleParser(context.rule), tokenizer(text)])
  wfa = WFA(minDFA, wordToIndex, dfa_to_tensor)
  wfa.execute(text)
  ```



  Given `[['token', 'another'], ['token_in_rule']]`, return something like

  ```python
  {'token': 0, 'another': 1, ...}
  ```

  So we can translate automata state to a matrix.



  Given an automata, a word index like `{'token': 0, 'another': 1, ...}`, and a function that transform automata to tensor (see example at [customRuleDFAToTensor](examples/customRuleDFAToTensor.py)), return a WFA instance.





  Create environment from the text file:

  ```shell
  conda env create --file automataTools-env.txt
  conda activate automataTools
  ```

  Save env file: `conda list --explicit > automataTools-env.txt`



  Create a `.env` file with content `PYTHONPATH=automataTools`



  To pypi

  ```shell
  rm -rf ./dist && rm -rf ./build && rm -rf ./automata_tools.egg-info && python3 setup.py sdist bdist_wheel && twine upload dist/*
  ```

  To Conda

  ```shell

  ```



  [Automata Theory Course Slides](http://www.cs.may.ie/staff/jpower/Courses/Previous/parsing/node5.html)

  Probably the original reference [source](https://github.com/sdht0/automata-from-regex)


pkgId: 1943ceddeefb6013b5d5d14a3c73189697f1768347de7f3d3ce3e3256053946c
name: python-automate
arch: src
version: 0.10.19
epoch: 0
release: 1
summary: General purpose Python automatization library with nifty real-time web UI
url: http://github.com/tuomas2/automate
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automate-0.10.19-1.src.rpm
checksum_type: sha256
description:
  - Github URL: http://github.com/tuomas2/automate
  - Read full documentation at http://python-automate.readthedocs.org/
  Automate is a general purpose automatization library for Python.
  Its objective is to offer convenient and robust object-oriented programming
  framework for complex state machine systems. Automate can be used to design
  complex automation systems, yet it is easy to learn and fun to use. It was
  originally developed with home robotics/automatization projects in mind,
  but is quite general in nature and one could find applications from various
  fields that could take advantage of Automate. Automate can be embedded
  in other Python software as a component, which runs its operations in
  its own threads.


pkgId: 5e5a049fd953f7198044b2eefde3610c23b84df5e143c7b36204b82df12e3251
name: python-automate-scalable-unsupervised-dataset-generation
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: automate scalable unsupervised dataset generation
url: https://github.com/prakHr/automate-scalable-unsupervised-dataset-generation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automate-scalable-unsupervised-dataset-generation-0.4.0-1.src.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install automate-scalable-unsupervised-dataset-generation
  ```

  ```
  import automate_scalable_unsupervised_dataset_generation.automate
  query = ["Artificial Intelligence","recipe of lemon tea!"]
  num_page = 5
  sleep_time = 10
  results = automate_scalable_unsupervised_dataset_generation.automate.parallel_scraping(query,num_page,sleep_time)
  ```

  `automate-scalable-unsupervised-dataset-generation` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: b3f853eacf37389bd0a1aa04c9f920d6516a9ba5a330827c0fb7dda8ec08553f
name: python-automate-supervised-dataset-generation
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: automate unsupervised dataset generation
url: https://github.com/prakHr/automate-supervised-dataset-generation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automate-supervised-dataset-generation-0.4.0-1.src.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install automate-supervised-dataset-generation
  ```

  ```
  import automate_supervised_dataset_generation.automate
  query = "Artificial Intelligence"
  num_page = 5
  sleep_time = 10
  labels = ["spam","not Spam"]
  results = automate_supervised_dataset_generation.automate.parallel_scraping(query,num_page,labels,sleep_time)
  ```

  `automate-unsupervised-dataset-generation` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 9a5efccb83fbde7c0b1fe30af4a36716a560f67368ac5cdddabe384ba2bc6796
name: python-automate-supervised-dataset-generation
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A brief description
url: https://github.com/prakHr/automate-supervised-dataset-generation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automate-supervised-dataset-generation-0.7.0-1.src.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install automate-supervised-dataset-generation
  ```

  ```
  import automate_supervised_dataset_generation.automate
  query = "Artificial Intelligence"
  num_page = 1
  labels = ["Not AI related","AI"]
  sleep_time = 10
  test_size=0.2
  max_evals=3
  trial_timeout=120

  inference_size = "8gb" # for larger inference time with best tagging accuracy
  rv = automate_supervised_dataset_generation.automate.parallel_scraping(query,num_page,labels,sleep_time,test_size,max_evals,trial_timeout,inference_size)
  ```

  `automate-supervised-dataset-generation` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: a257ebe39210172b1efb59b809c07327d9320a9e9099f275a44792e45723848a
name: python-automate-unsupervised-dataset-generation
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: automate unsupervised dataset generation
url: https://github.com/prakHr/automate-unsupervised-dataset-generation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automate-unsupervised-dataset-generation-0.4.0-1.src.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install automate-unsupervised-dataset-generation
  ```

  ```
  import automate_unsupervised_dataset_generation.automate
  query = "Artificial Intelligence"
  num_page = 5
  sleep_time = 10
  results = automate_unsupervised_dataset_generation.automate.parallel_scraping(query,num_page,sleep_time)
  ```

  `automate-unsupervised-dataset-generation` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 4b58c3a664da13d67dbf5a9ea794eef34834e12702c65822ceeaf60f9068bc3b
name: python-automated-interpretability
arch: src
version: 0.0.6
epoch: 0
release: 1
url: https://pypi.org/project/automated-interpretability/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automated-interpretability-0.0.6-1.src.rpm
checksum_type: sha256
summary:
  OpenAI's implementation of automated-interpretability, with some updates. Not officially affiliated with OpenAI.


pkgId: 06153231cc4dc6ebbf6507d0d13cf4cdde052d027f929b176b378f13370e878b
name: python-automathon
arch: src
version: 0.0.15
epoch: 0
release: 1
summary: A Python library for simulating and visualizing finite automata
url: https://github.com/rohaquinlop/automathon
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automathon-0.0.15-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://rohaquinlop.github.io/automathon/" target="_blank">https://rohaquinlop.github.io/automathon/</a>
  **Source Code**: <a href="https://github.com/rohaquinlop/automathon" target="_blank">https://github.com/rohaquinlop/automathon</a>


pkgId: bdfc90e90f1562db1f78cb9c389dafe66aaf6e8b5472622ec3886a34217d8696
name: python-automatic-spike-detection
arch: src
version: 1.2.6
epoch: 0
release: 1
url: https://github.com/domfre/automatic-spike-detection
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automatic-spike-detection-1.2.6-1.src.rpm
checksum_type: sha256
summary:
  Python library for automatically detecting interictal epileptiform discharges (IEDs) by means of nonnegative matrix factorization (NMF)

description:
  The automatic-spike-detection package is a Python library for automatically detecting interictal epileptiform
  discharges (IEDs) in intracranial EEG (iEEG) recordings.


  IEDs, also referred to as ”spikes”, are a characteristic of
  the epileptic brain that are recognizable as large transient events in the electroencephalogram
  of patients living with epilepsy [[1]](#1). Whereas, for clinicians, IEDs can provide valuable information
  about the epileptogenic zone, for researchers, they can also be a source of noise and need to be excluded,
  such as in [[2]](#2) where Cusinato and Alnes et al. studied how the human brain processes sounds. Regardless of
  the context, the localization of IEDs in EEG recordings is a very time-consuming task.

  This package aims to contribute to this issue by building on an algorithm previously developed by
  Baud et al. [[3]](#3) that employs nonnegative matrix factorization (NMF) to automatically detect IEDs,
  an unsupervised machine-learning algorithm that produces a lower-dimensional approximation of the input.

  It is important to note, that the algorithm used by this package is optimized for and was solely tested
  on iEEG recordings. Intracranial EEG is an invasive technique with implanted electrodes
  that is used for clinical monitoring, e.g. to identify the epileptogenic zone and prepare for epilepsy surgery.
  The primary characteristic of iEEG is that it provides high spatial and temporal resolution of the
  electrical activity in the brain, which makes it a valuable resource for neuroscientific research as well [[4]](#4).

  Please consult the automatic-spike-detection [Documentation](https://automatic-spike-detection.readthedocs.io/en/latest/index.html)
  for details on the [underlying concepts](https://automatic-spike-detection.readthedocs.io/en/latest/documentation/index.html)
  of the algorithm, the [Installation and Usage](https://automatic-spike-detection.readthedocs.io/en/latest/usage/index.html#usage)
  , and the application programming interface [(API)](https://automatic-spike-detection.readthedocs.io/en/latest/reference/index.html)


  In addition to the dependencies in the `requirements.txt` file, you need to install the dependencies listed in the
  `dev-requirements.txt` file, which provides some formatting tools:

  ````
  pip install requirements.txt
  pip install dev-requirements.txt
  ````


  <a id="1">[1]</a>
  Marco de Curtis and Giuliano Avanzini. "Interictal spikes in focal epileptogenesis".
  Progress in Neurobiology 63, no.5 (2001): 541-567.

  <a id="2">[2]</a>
  Riccardo Cusinato, Sigurd L. Alnes, Ellen van Maren, Ida Boccalaro, Debora Ledergerber, Antoine
  Adamantidis, Lukas L. Imbach, Kaspar Schindler, Maxime O. Baud, and Athina Tzovara. Intrinsic
  neural timescales in the temporal lobe support an auditory processing hierarchy. Journal of
  Neuroscience, 43(20):3696–3707, 2023.

  <a id="3">[3]</a>
  Maxime O. Baud, Jonathan K. Kleen, Gopala K. Anumanchipalli, Liberty S. Hamilton, Yee-Leng
  Tan, Robert Knowlton, and Edward F. Chang. Unsupervised learning of spatiotemporal interictal
  discharges in focal epilepsy. Neurosurgery, 83(4), 2018.

  <a id="4">[4]</a>
  Elizabeth L Johnson, Julia W Y Kam, Athina Tzovara, and Robert T Knight. Insights into human
  cognition from intracranial eeg: A review of audition, memory, internal cognition, and causality.
  Journal of Neural Engineering, 17(5):051001, oct 2020.


pkgId: b845864c13116d85645bce4007049023cba2168f1c9918708fb7c2db20970066
name: python-automation
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: A Django-specific implementation of Fabric
url: https://github.com/dustinfarris/automation
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automation-0.6.1-1.src.rpm
checksum_type: sha256
description:
  Automation is a Django-specific implementation of Fabric that provides
  automation for server and git repository tasks.


pkgId: ac99236fba7fc1367f056406db365b0ecf6a507bd306d8c01e20ca6c353915bc
name: python-automation-file
arch: src
version: 0.0.23
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/JE-Chen/Integration-testing-environment
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automation-file-0.0.23-1.src.rpm
checksum_type: sha256
description:
  > Project Kanban \
  > https://github.com/orgs/Integration-Automation/projects/2/views/1
  > * FileAutomation is used to manager files and dirs.
  > * Easily file automation.
  > * Automatically backup.
  > * Automatically download from Google Drive.
  > * Automatically upload to Google Drive.
  > * Automatically zip and unzip file.
  > * Automatically manager specify file.
  > * OS Independent.
  > * Remote automation support.
  > * Project & Template support.
  > * Detailed log file.
  > * Scheduler.

  > pip install automation_file

  > python 3.9 or later

  ![architecture_diagram](architecture_diagram/FileAutomation.drawio.png)


pkgId: 88dbb9462df652f435fe966dd28cadb0c0d1c21cc1d8c8b85a005a6d87e66820
name: python-automation-ide-dev
arch: src
version: 0.0.38
epoch: 0
release: 1
summary: AutomationEditor for multi automation
url: https://github.com/Intergration-Automation-Testing/AutomationEditor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automation-ide-dev-0.0.38-1.src.rpm
checksum_type: sha256
description:
  > * If you can't run program and get argument or internal error on windows, Please update your powershell.


pkgId: f3b9263202c4a367c17e2798239a8bd73508a73ba5de4b0c16c3a0e8e6784231
name: python-automation-report
arch: src
version: 1.2.1
epoch: 0
release: 1
url: https://github.com/bibekad123/automation-report
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automation-report-1.2.1-1.src.rpm
checksum_type: sha256
summary:
  Generate HTML report for your test cases / Automation cases with its steps specifying its valid status.

description:
  Python package to generate HTML report of your automation or test cases with:

  - Supports multiple test cases and its steps with valid status
  - Well displayed chart according to the test results
  - Dynamic HTML Report contents, user allowed to modify accordingly



  ```
  $ pip install automation-report
  ```





  ```
  from automation_report.report import AutomationReport
  ```

  - **LogoImage** : Provide URL of the image
  - **MainHeader**: When header text is to be used instead of logo
  - **FooterContent**: Provide HTML content to add on the footer section
  ```
  options = {}

  options["MainHeader"] = "Automation Report"
  options["FooterContent"] = "<a href='#'> Footer link </a>"
  ```



  ```
  new_report = AutomationReport("Login Test", options)
  ```


  ```
  new_report.starttest("CASE 0001: Login to the system")
  ```



  ```
  new_report.info("Entered email in email field")
  new_report.success("Login Successfully:")
  ```



  ```
  new_report.endtest()
  ```



  ```
  new_report.starttest("CASE 0002: Logout User")
  new_report.info("User is logged in")
  new_report.success("Logout link is present")
  new_report.fail("User not logged out")
  new_report.endtest()
  ```


  ```
  new_report.close()
  ```

  ![Automation Report](https://user-images.githubusercontent.com/12621555/78378665-06362000-75f1-11ea-86aa-7f3ff063cfcf.png)

  ![Automation report](https://user-images.githubusercontent.com/12621555/78378679-0b936a80-75f1-11ea-84ee-8d5c490a46b9.png)


pkgId: a1ed7e9d5bb7951735cacd424517b429bb38bd1ba1f5041864ca21131a17e618
name: python-automation-test
arch: src
version: 1.25
epoch: 0
release: 1
summary: Simple calculator API hosted on APIMATIC - townhall demo
url: https://apimatic.io
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automation-test-1.25-1.src.rpm
checksum_type: sha256
description:
  Simple calculator API hosted on APIMATIC - townhall demo



  The package is compatible with Python versions `2 >=2.7.9` and `3 >=3.4`.
  Install the package from PyPi using the following pip command:

  ```python
  pip install automation-test==1.25
  ```

  You can also view the package at:
  https://pypi.python.org/pypi/automation-test



  You can test the generated SDK and the server with test cases. `unittest` is used as the testing framework and `nose` is used as the test runner. You can run the tests as follows:

  Navigate to the root directory of the SDK and run the following commands

  ```
  pip install -r test-requirements.txt
  nosetests
  ```



  **_Note:_** Documentation for the client can be found [here.](/doc/client.md)

  The following parameters are configurable for the API Client:

  | Parameter | Type | Description |
  |  --- | --- | --- |
  | `environment` | Environment | The API environment. <br> **Default: `Environment.PRODUCTION`** |
  | `timeout` | `float` | The value to use for connection timeout. <br> **Default: 60** |
  | `max_retries` | `int` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
  | `backoff_factor` | `float` | A backoff factor to apply between attempts after the second try. <br> **Default: 2** |
  | `retry_statuses` | `Array of int` | The http statuses on which retry is to be done. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
  | `retry_methods` | `Array of string` | The http methods on which retry is to be done. <br> **Default: ['GET', 'PUT']** |

  The API client can be initialized as follows:

  ```python
  from apimaticcalculator.apimaticcalculator_client import ApimaticcalculatorClient
  from apimaticcalculator.configuration import Environment

  client = ApimaticcalculatorClient(
      environment=Environment.PRODUCTION,)
  ```



  * [Simple Calculator](/doc/controllers/simple-calculator.md)



  * [Utility Classes](/doc/utility-classes.md)
  * [HttpResponse](/doc/http-response.md)
  * [HttpRequest](/doc/http-request.md)


pkgId: 8f95778d8da1687aa2bda98fde08737ca13fbb3792b2b084127edc940cde2357
name: python-automationhat
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Driver for the Pimoroni Automation HAT
description:
  * Refactor to gpiod/gpiodevice.
  * Repackage to hatch/pyproject.toml.

url: https://www.pimoroni.com
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automationhat-1.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2017 Pimoroni Ltd.  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: d95550e6e34c6fb2e53af5c559933a04f1efe234123233c26e392407eb4f0463
name: python-automationimg
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A tool for image preprocessing and object detection
url: https://github.com/akshitharsola/AutomationIMG
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automationimg-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  [![Python](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)

  AutomationIMG is a Python-based tool for automated image preprocessing and object detection, featuring an intuitive graphical user interface. It simplifies the process of organizing and analyzing image datasets for machine learning and computer vision tasks.



  - **Preprocessing Pipeline**
    - Automated image organization
    - Support for various directory structures
    - Batch processing capabilities

  - **Object Detection**
    - Single object detection using Canny edge detection
    - Bounding box visualization
    - Quality assessment of detections

  - **User Interface**
    - Intuitive GUI built with PyQt5
    - Real-time progress tracking
    - Easy folder selection and processing



  Before you begin, ensure you have the following installed:
  - Python 3.7 or higher
  - pip (Python package installer)



  1. **Clone the repository:**
  ```bash
  git clone https://github.com/akshitharsola/AutomationIMG.git
  cd AutomationIMG
  ```

  2. **Install the package:**
  ```bash
  pip install -e .
  ```




  The tool supports the following directory structure for input data:
  ```
  Main_Folder/
      └── Apple/
          └── image1.jpg
          └── image2.jpg
      └── Orange/
          └── image1.jpg
          └── image2.jpg
  ```


  1. **Start the application:**
  ```python

  automationIMG
  ```

  2. **Using the GUI:**
     - Click "Input Folder" to select your image directory
     - Choose "Output Folder" for processed results
     - Run "Preprocess Dataset" to organize images
     - Use "Single Object Detection" for detection and analysis


  The tool generates the following output structure:
  ```
  Output_Folder/
      └── processed/
          └── images
          └── annotations.json
      └── edge_detection/
          └── detection results
      └── bounding_boxes/
          └── visualizations
  ```


  You have several ways to uninstall AutomationIMG:

  1. **Using the GUI**
     - Launch the application: `automationimg`
     - Click the "Uninstall Tool" button
     - Follow the prompts

  2. **Using the uninstall module**
  ```bash
  python -m automationimg.uninstall
  ```

  3. **Manual uninstallation**
  ```bash
  pip uninstall automationimg -y
  ```

  Note: After uninstallation, any remaining files in the installation directory can be safely deleted manually.


  Contributions are welcome! Please feel free to submit a Pull Request.

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



  This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.



  **Akshit Harsola**
  - Email: harsolaakshit@gmail.com
  - GitHub: [@akshitharsola](https://github.com/akshitharsola)



  - Thanks to all contributors who help improve this tool
  - Special thanks to the open-source community for their valuable tools and libraries



  If you encounter any problems or have suggestions, please [open an issue](https://github.com/akshitharsola/AutomationIMG/issues).


pkgId: cd81b6005a532db4e2f10df25c14fd359cde1b83ea8714130ae2ad3732d59bbe
name: python-automatoes
arch: src
version: 0.9.12
epoch: 0
release: 1
summary: Let's Encrypt/ACME V2 client replacement for Manuale. Manual or automated your choice.
url: https://github.com/candango/automatoes
rpm_license: Apache License V2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automatoes-0.9.12-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/automatoes.svg)](https://pypi.org/project/automatoes/)
  [![Number of PyPI downloads](https://img.shields.io/pypi/dm/automatoes.svg)](https://pypi.org/project/automatoes/#files)
  [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Fcandango%2Fautomatoes%2Fbadge&style=flat)](https://actions-badge.atrox.dev/candango/automatoes/goto)
  [![Requirements Status](https://requires.io/github/candango/automatoes/requirements.svg?branch=develop)](https://requires.io/github/candango/automatoes/requirements/?branch=develop)


  Automatoes is a [Let's Encrypt](https://letsencrypt.org)/[ACME](https://github.com/ietf-wg-acme/acme/)
  client for advanced users and developers. It is intended to be used by anyone
  because we don't care if you're a robot, a processes or a person.

  We will keep the `manuale` command to provide manual workflow designed by the
  original project and to be a direct replacement from
  [ManuaLE](https://github.com/veeti/manuale).



  Bacause Let's Encrypt's point is to be automatic and seamless and ManuaLE was
  designed to be manual.

  Automatoes will add automatic workflows and new features to evolve ManuaLe's
  legacy. The project also will keep performing maintenance tasks as bug fixes
  and refactory.

  Automatoes is an ACME V2 replacement to ManuaLE.



  * Simple interface with no hoops to jump through. Keys and certificate signing
  requests are automatically generated: no more cryptic OpenSSL one-liners.
  (However, you do need to know what to do with generated certificates and keys
  yourself!)

  * Support for DNS & HTTP validation. No need to figure out how to serve
  challenge files from a live domain.

  * Obviously, runs without root access. Use it from any machine you want, it
  doesn't care. Internet connection recommended.

  * Awful, undiscoverable name.

  * And finally, if the `openssl` binary is your spirit animal after all, you can
  still bring your own keys and/or CSR's. Everybody wins.



  Python 3.6 or above is required.



  * TO DO

  * Package maintainers wanted: your package here?




  You can install the package from
  [PyPI](https://pypi.python.org/pypi/automatoes) using the `pip` tool. To do
  so, run `pip3 install automatoes`.

  If you're not using Windows or OS X pip may need to compile some of the
  dependencies. In this case, you need a compiler and development headers for
  Python, OpenSSL and libffi installed.

  On Debian-based distributions, these will typically be
  `gcc python3-dev libssl-dev libffi-dev`, and on RPM-based distributions
  `gcc python3-devel openssl-devel libffi-devel`.



      git clone https://github.com/candango/automatoes ~/.automatoes
      cd ~/.automatoes
      python3 -m venv env
      env/bin/python setup.py install
      ln -s env/bin/manuale ~/.bin/

  (Assuming you have a `~/.bin/` directory in your `$PATH`).



  Register an account (once):

      $ manuale register me@example.com

  Authorize one or more domains:

      $ manuale authorize example.com
      DNS verification required. Make sure these records are in place:
        _acme-challenge.example.com. IN TXT "(some random gibberish)"
      Press Enter to continue.
      ...
      1 domain(s) authorized. Let's Encrypt!

  Get your certificate:

      $ manuale issue --output certs/ example.com
      ...
      Certificate issued.

      Expires: 2016-06-01
       SHA256: (more random gibberish)

      Wrote key to certs/example.com.pem
      Wrote certificate to certs/example.com.crt
      Wrote certificate with intermediate to certs/example.com.chain.crt
      Wrote intermediate certificate to certs/example.com.intermediate.crt

  Set yourself a reminder for renewal!



  You need to create an account once. To do so, call `manuale register [email]`.
  This will create a new account key for you. Follow the registration
  instructions.

  Once that's done, you'll have your account saved in `account.json` in the
  current directory. You'll need this to do anything useful. Oh, and it contains
  your private key, so keep it safe and secure.

  `manuale` expects the account file to be in your working directory by default,
  so you'll probably want to make a specific directory to do all your certificate
  stuff in. Likewise, created certificates get saved in the current path by
  default.

  Next up, verify the domains you want a certificate for with
  `manuale authorize [domain]`. This will show you the DNS records you need to
  create and wait for you to do it. For example, you might do it for
  `example.com` and `www.example.com`.

  Once that's done, you can finally get down to business.
  Run `manuale issue example.com www.example.com` to get your certificate.
  It'll save the key, certificate and certificate with intermediate to the
  working directory.

  There's plenty of documentation inside each command. Run `manuale -h` for a
  list of commands and `manuale [command] -h` for details.



  Yes and no. Mostly yes, in the background.

  Automatoes provides a manuale command replacement and a new automatoes command
  that will be added in the future.

  The manuale command will interface ACME V2 only as V1 is reaching
  [End Of Life](https://community.letsencrypt.org/t/end-of-life-plan-for-acmev1/88430).

  The account file structure from ManuaLE is maintained, no change here.

  For Let's Encrypt servers it is necessary to change the uri from V1 api to V2.
  With [#30](https://github.com/candango/automatoes/issues/30) we'll warn you
  about your uri being Let's Encrypt ACME V1 and run with a correct ACME V2
  without fixing the account.json file.

  To fix the account.json file permanently run `manuale upgrade` and after
  confirmation your account uri will be changed to the Let's Encrypt ACME V2 uri.

  The upgrade action will only act against an account uri from production Let's
  Encrypt ACME V1 otherwise nothing will be executed.

  ACME V2 works with an
  [order workflow](https://tools.ietf.org/html/rfc8555#section-7.1) that must be
  fulfilled. Automatoes will mimic orders in a file structure locally for better
  control.

  The manuale command will handle orders following the original project workflow
  with minimal changes.

  The automatoes command will be order based, let's talk about that when
  released.

  Here is what happens in the background(manuale replacement):

  > `manuale authorize domain.com other.domain.com`
  > 1. /acme/new-order is called and order file is stored locally at
  > working_directory/orders/<sha256sum(domain.com other.domain.com)>/order.json
  > 1. /acme/authz/challenge1 and /acme/authz/challenge2 are called and stored at
  > working_directory/orders/<sha256sum(domain.com other.domain.com)>
  > 1. the file name for challenges will be <domain>_challenge.json
  > 1. you fulfill all challenges either by dns or http, dns is default.
  > Just saying... you know the drill right? Same as before.
  > 1. manuale the Let's Encrypt! message and you can issue the certificate

  * If any challenge fails we delete the order file because it will be invalid
  in the server side. Invalid orders are considered fulfilled and not pending,
  we can discard them.
  * If you hit Ctrl+c, the order will start from the state found in the local
  file stored. Even challenges will be maintained, in a case when one challenge
  is validated and 2 are pending, if Ctrl+c was hit, we'll recognize them in a
  next attempt.
  * If you call the authorize command and there is an existent invalid order,
  this one will be deleted, and a new order will be created.

  > `manuale issue domain.com other.domain.com`

  > 1. /acme/order/<order_id>/finalize is called with the pem generated
  > or the one provided by you
  > 1. /acme/cert/<cert_id> is called, and we place keys like we use to do before
  > 1. we're done!

  * If you try to issue certificates for a domain sequence and an oder is pending
  or invalid, automatoes will ask you to run authorize before.

  After authorizing a domain sequence you need run issue with the same domain
  sequence because:

   1. The order file is stored at
   working_directory/orders/<sha256sum(domain.com other.domain.com)>
   if we change the domain sequence a new order file will be created at
   working_directory/orders/<sha256sum(other.domain.com domain.com)>
   2. The acme V2 order finalize call also requires something like this as
   described at
   [rfc8555 section-7.4](https://tools.ietf.org/html/rfc8555#section-7.4):

  >  A request to finalize an order will result in an error if the CA is
     unwilling to issue a certificate corresponding to the submitted CSR.
     For example:
  >
  >   *  **If the CSR and order identifiers differ** <--- TALKING ABOUT THIS
  >
  >   *  If the account is not authorized for the identifiers indicated in the CSR
  >
  >   *  If the CSR requests extensions that the CA is not willing to include

  Trying to keep thing as [KISS](https://www.acronymfinder.com/KISS.html) as
  possible, we can complicate things later. Now we need ACME V2.

  To create a certificate for a domain sequence authorized by a previous order
  just:

   1. call authorize again. Chances are that no challenge will be needed, but it
   depends on the ACME V2 server implementation.
   1. fulfill challenge(s) if needed
   1. call issue with same domain sequence authorize
   1. we're done!

  In other words, a domain sequence defines how the order identifier is created
  locally.

  The sha256sum command from coreutils can be used if you have a bash script
  to monitor `manuale` execution:

  ```
  > echo "domain.com other.domain.com" | sha256sum
  83ccaf9441b1abea98837e2f4c2fc18122c0e9ee4e39dd1995387f4d5d495b69  -

  > echo "other.domain.com domain.com" | sha256sum
  d0bd2c4957537572ffb7150a7dc89e61f44f9ab603b75be481118e37ec5a6163  -
  ```

  Storing meta files at working_directory/orders directory will let us
  automate things better. Don't delete those files let Automatoes handle them for
  you.

  Here are more some features we can explore with this local file structure in
  the future:

   - control and advise about limits, as Acme V2 enforce limits for opened orders
   per account
   - list orders and status (for pending orders)
   - create partial authorizations (that will be on automatoes command not in
   manuale)
   - SDK?
   - Can you imagine more? Create a feature request for us.

  Also, the manuale command can be called with a verbose parameter(-v) right now
  providing more output.



  * [Best practices for server configuration](https://wiki.mozilla.org/Security/Server_Side_TLS)
  * [Configuration generator for common servers](https://mozilla.github.io/server-side-tls/ssl-config-generator/)
  * [Test your server](https://www.ssllabs.com/ssltest/)
  * [Other clients](https://community.letsencrypt.org/t/list-of-client-implementations/2103)



  For direct support create a
  [new discussion](https://github.com/candango/automatoes/discussions/new?category=help)
  or a
  [new ticket](https://github.com/candango/automatoes/issues/new)
  we'll love to see how to help you.

  Automatoes is one of
  [Candango Open Source Group](http://www.candango.org/projects/)
  initiatives. Available under the
  [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html).

  This website and all documentation are licensed under
  [Creative Commons 3.0](http://creativecommons.org/licenses/by/3.0/).

  Copyright © 2019-2022 Flávio Gonçalves Garcia
  Copyright © 2016-2017 Veeti Paananen under MIT License


pkgId: 53b21684d1de7090c266b37f29f9892a41d261f2045509725be0516f342f520f
name: python-automators-agent
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Automators AI Agent
url: https://pypi.org/project/automators-agent/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automators-agent-0.1.7-1.src.rpm
checksum_type: sha256
description:
  Before you begin, ensure that you have [pipx](https://pipx.pypa.io/stable/installation) installed.

  > **Note:** Python 3.13 (which the default homebrew pipx install depends on) is not yet supported by us (see https://github.com/automators-com/agent/issues/7). We would suggest using `pip install pipx` in the interim.

  You also need to have playwright installed:

  ```bash
  pip install --upgrade pip
  pip install playwright
  playwright install
  ```



  1. Install the agent using pipx:

  ```bash
  python -m pipx install automators-agent
  ```

  2. Initialize the agent:

  ```bash
  agent init
  ```

  3. Update the `.env` file to include an OpenAI API key. Edit the prompt in the `config.toml` file and then start the agent:

  ```bash
  agent start
  ```



  Clone the repository:

  ```bash
  git clone https://github.com/automators-com/agent.git
  cd agent
  ```

  Install the dependencies:

  ```bash
  pip install uv
  uv sync --all-extras --dev
  ```

  Install playwright:

  ```bash
  playwright install chromium

  ```



  Create a `.env` file in the root of the project with the following content:

  ```bash
  OPENAI_API_KEY=""
  OPENAI_MODEL="gpt-4o"
  HEADLESS=true
  LOG_LEVEL="INFO"
  ```



  Run the agent:

  ```bash
  uv run agent start
  ```


pkgId: 3ce78305f78a4f823d653913ae955af6e66c63aec77fd3bfc5087341a6498120
name: python-autometrics
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/autometrics-dev/autometrics-py
rpm_license: MIT OR Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autometrics-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Easily add metrics to your system – and actually understand them using automatically customized Prometheus queries

description:
  ![GitHub_headerImage](https://user-images.githubusercontent.com/3262610/221191767-73b8a8d9-9f8b-440e-8ab6-75cb3c82f2bc.png)

  [![Tests](https://github.com/autometrics-dev/autometrics-py/actions/workflows/main.yml/badge.svg)](https://github.com/autometrics-dev/autometrics-py/actions/workflows/main.yml)
  [![Discord Shield](https://discordapp.com/api/guilds/950489382626951178/widget.png?style=shield)](https://discord.gg/kHtwcH8As9)

  > A Python port of the Rust
  > [autometrics-rs](https://github.com/fiberplane/autometrics-rs) library

  Metrics are a powerful and cost-efficient tool for understanding the health and performance of your code in production. But it's hard to decide what metrics to track and even harder to write queries to understand the data.

  Autometrics provides a decorator that makes it trivial to instrument any function with the most useful metrics: request rate, error rate, and latency. It standardizes these metrics and then generates powerful Prometheus queries based on your function details to help you quickly identify and debug issues in production.

  See [Why Autometrics?](https://github.com/autometrics-dev#why-autometrics) for more details on the ideas behind autometrics.



  - ✨ `@autometrics` decorator instruments any function or class method to track the
    most useful metrics
  - 💡 Writes Prometheus queries so you can understand the data generated without
    knowing PromQL
  - 🔗 Create links to live Prometheus charts directly into each function's docstring
  - 🔍 [Identify commits](#build-info) that introduced errors or increased latency
  - 🚨 [Define alerts](#alerts--slos) using SLO best practices directly in your source code
  - 📊 [Grafana dashboards](#dashboards) work out of the box to visualize the performance of instrumented functions & SLOs
  - ⚙️ [Configurable](#settings) metric collection library (`opentelemetry` or `prometheus`)
  - 📍 [Attach exemplars](#exemplars) to connect metrics with traces
  - ⚡ Minimal runtime overhead



  1. Add `autometrics` to your project's dependencies:

  ```shell
  pip install autometrics
  ```

  2. Instrument your functions with the `@autometrics` decorator

  ```python
  from autometrics import autometrics

  @autometrics
  def my_function():
    
  ```

  3. Configure autometrics by calling the `init` function:

  ```python
  from autometrics import init

  init(tracker="prometheus", service_name="my-service")
  ```

  4. Export the metrics for Prometheus

  ```python

  from fastapi import FastAPI, Response
  from prometheus_client import generate_latest



  @app.get("/metrics")
  def metrics():
      return Response(generate_latest())
  ```

  5. Run Prometheus locally with the [Autometrics CLI](https://docs.autometrics.dev/local-development#getting-started-with-am) or [configure it manually](https://github.com/autometrics-dev#5-configuring-prometheus) to scrape your metrics endpoint

  ```sh

  am start :8080
  ```

  6. (Optional) If you have Grafana, import the [Autometrics dashboards](https://github.com/autometrics-dev/autometrics-shared#dashboards) for an overview and detailed view of all the function metrics you've collected



  - You can import the library in your code and use the decorator for any function:

  ```python
  from autometrics import autometrics

  @autometrics
  def sayHello:
    return "hello"

  ```

  - To show tooltips over decorated functions in VSCode, with links to Prometheus queries, try installing [the VSCode extension](https://marketplace.visualstudio.com/items?itemName=Fiberplane.autometrics).

    > **Note**: We cannot support tooltips without a VSCode extension due to behavior of the [static analyzer](https://github.com/davidhalter/jedi/issues/1921) used in VSCode.

  - You can also track the number of concurrent calls to a function by using the `track_concurrency` argument: `@autometrics(track_concurrency=True)`.

    > **Note**: Concurrency tracking is only supported when you set with the environment variable `AUTOMETRICS_TRACKER=prometheus`.

  - To access the PromQL queries for your decorated functions, run `help(yourfunction)` or `print(yourfunction.__doc__)`.

    > For these queries to work, include a `.env` file in your project with your prometheus endpoint `PROMETHEUS_URL=your endpoint`. If this is not defined, the default endpoint will be `http://localhost:9090/`



  Autometrics provides [Grafana dashboards](https://github.com/autometrics-dev/autometrics-shared#dashboards) that will work for any project instrumented with the library.



  Autometrics makes it easy to add intelligent alerting to your code, in order to catch increases in the error rate or latency across multiple functions.

  ```python
  from autometrics import autometrics
  from autometrics.objectives import Objective, ObjectiveLatency, ObjectivePercentile



  API_SLO_HIGH_SUCCESS = Objective(
      "My API SLO for High Success Rate (99.9%)",
      success_rate=ObjectivePercentile.P99_9,
  )

  @autometrics(objective=API_SLO_HIGH_SUCCESS)
  def api_handler():
    
  ```

  The library uses the concept of Service-Level Objectives (SLOs) to define the acceptable error rate and latency for groups of functions. Alerts will fire depending on the SLOs you set.

  > Not sure what SLOs are? [Check out our docs](https://docs.autometrics.dev/slo) for an introduction.

  In order to receive alerts, **you need to add a special set of rules to your Prometheus setup**. These are configured automatically when you use the [Autometrics CLI](https://docs.autometrics.dev/local-development#getting-started-with-am) to run Prometheus.

  > Already running Prometheus yourself? [Read about how to load the autometrics alerting rules into Prometheus here](https://github.com/autometrics-dev/autometrics-shared#prometheus-recording--alerting-rules).

  Once the alerting rules are in Prometheus, you're ready to go.

  To use autometrics SLOs and alerts, create one or multiple `Objective`s based on the function(s) success rate and/or latency, as shown above.

  The `Objective` can be passed as an argument to the `autometrics` decorator, which will include the given function in that objective.

  The example above used a success rate objective. (I.e., we wanted to be alerted when the error rate started to increase.)

  You can also create an objective for the latency of your functions like so:

  ```python
  from autometrics import autometrics
  from autometrics.objectives import Objective, ObjectiveLatency, ObjectivePercentile



  API_SLO_LOW_LATENCY = Objective(
      "My API SLO for Low Latency (99th percentile < 250ms)",
      latency=(ObjectiveLatency.Ms250, ObjectivePercentile.P99),
  )

  @autometrics(objective=API_SLO_LOW_LATENCY)
  def api_handler():
    
  ```



  Autometrics keeps track of instrumented functions that call each other. So, if you have a function `get_users` that calls another function `db.query`, then the metrics for latter will include a label `caller="get_users"`.

  This allows you to drill down into the metrics for functions that are _called by_ your instrumented functions, provided both of those functions are decorated with `@autometrics`.

  In the example above, this means that you could investigate the latency of the database queries that `get_users` makes, which is rather useful.



  Autometrics makes use of a number of environment variables to configure its behavior. All of them are also configurable with keyword arguments to the `init` function.

  - `tracker` - Configure the package that autometrics will use to produce metrics. Default is `opentelemetry`, but you can also use `prometheus`. Look in `pyproject.toml` for the corresponding versions of packages that will be used.
  - `histogram_buckets` - Configure the buckets used for latency histograms. Default is `[0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 7.5, 10.0]`.
  - `enable_exemplars` - Enable [exemplar collection](#exemplars). Default is `False`.
  - `service_name` - Configure the [service name](#service-name).
  - `version`, `commit`, `branch`, `repository_url`, `repository_provider` - Used to configure [build_info](#build-info).

  Below is an example of initializing autometrics with build information, as well as the `prometheus` tracker. (Note that you can also accomplish the same confiugration with environment variables.)

  ```python
  from autometrics import autometrics, init
  from git_utils import get_git_commit, get_git_branch

  VERSION = "0.0.1"

  init(
    tracker="prometheus",
    version=VERSION,
    commit=get_git_commit(),
    branch=get_git_branch()
  )
  ```



  Autometrics makes it easy to identify if a specific version or commit introduced errors or increased latencies.

  > **NOTE** - As of writing, `build_info` will not work correctly when using the default setting of `AUTOMETRICS_TRACKER=opentelemetry`. If you wish to use `build_info`, you must use the `prometheus` tracker instead (`AUTOMETRICS_TRACKER=prometheus`).
  >
  > The issue will be fixed once the following PR is merged and released on the opentelemetry-python project: https://github.com/open-telemetry/opentelemetry-python/pull/3306
  >
  > autometrics-py will track support for build_info using the OpenTelemetry tracker via [this issue](https://github.com/autometrics-dev/autometrics-py/issues/38)

  The library uses a separate metric (`build_info`) to track the version and git metadata of your code - repository url, provider name, commit and branch.

  It then writes queries that group metrics by these metadata, so you can spot correlations between code changes and potential issues.

  Configure these labels by setting the following environment variables:

  | Label                 | Run-Time Environment Variables        | Default value |
  | --------------------- | ------------------------------------- | ------------- |
  | `version`             | `AUTOMETRICS_VERSION`                 | `""`          |
  | `commit`              | `AUTOMETRICS_COMMIT` or `COMMIT_SHA`  | `""`          |
  | `branch`              | `AUTOMETRICS_BRANCH` or `BRANCH_NAME` | `""`          |
  | `repository_url`      | `AUTOMETRICS_REPOSITORY_URL`          | `""`\*        |
  | `repository_provider` | `AUTOMETRICS_REPOSITORY_PROVIDER`     | `""`\*        |

  \* Autometrics will attempt to automagically infer these values from the git config inside your working directory. To disable this behavior, explicitly set the corresponding setting or environment variable to `""`.

  This follows the method outlined in [Exposing the software version to Prometheus](https://www.robustperception.io/exposing-the-software-version-to-prometheus/).



  All metrics produced by Autometrics have a label called `service.name` (or `service_name` when exported to Prometheus) attached, in order to identify the logical service they are part of.

  You may want to override the default service name, for example if you are running multiple instances of the same code base as separate services, and you want to differentiate between the metrics produced by each one.

  The service name is loaded from the following environment variables, in this order:

  1. `AUTOMETRICS_SERVICE_NAME` (at runtime)
  2. `OTEL_SERVICE_NAME` (at runtime)
  3. First part of `__package__` (at runtime)



  > **NOTE** - As of writing, exemplars aren't supported by the default tracker (`AUTOMETRICS_TRACKER=opentelemetry`).
  > You can track the progress of this feature here: https://github.com/autometrics-dev/autometrics-py/issues/41

  Exemplars are a way to associate a metric sample to a trace by attaching `trace_id` and `span_id` to it. You can then use this information to jump from a metric to a trace in your tracing system (for example Jaeger). If you have an OpenTelemetry tracer configured, autometrics will automatically pick up the current span from it.

  To use exemplars, you need to first switch to a tracker that supports them by setting `AUTOMETRICS_TRACKER=prometheus` and enable
  exemplar collection by setting `AUTOMETRICS_EXEMPLARS=true`. You also need to enable exemplars in Prometheus by launching Prometheus with the `--enable-feature=exemplar-storage` flag.



  There are multiple ways to export metrics from your application, depending on your setup. You can see examples of how to do this in the [examples/export_metrics](https://github.com/autometrics-dev/autometrics-py/tree/main/examples/export_metrics) directory.

  If you want to export metrics to Prometheus, you have two options in case of both `opentelemetry` and `prometheus` trackers:

  1. Create a route inside your app and respond with `generate_latest()`

  ```python

  from fastapi import FastAPI, Response
  from prometheus_client import generate_latest


  @app.get("/metrics")
  def metrics():
      return Response(generate_latest())
  ```

  2. Specify `prometheus` as the exporter type, and a separate server will be started to expose metrics from your app:

  ```python
  exporter = {
      "type": "prometheus",
      "address": "localhost",
      "port": 9464
  }
  init(tracker="prometheus", service_name="my-service", exporter=exporter)
  ```

  For the OpenTelemetry tracker, you have more options, including a custom metric reader. You can specify the exporter type to be `otlp-proto-http` or `otlp-proto-grpc`, and metrics will be exported to a remote OpenTelemetry collector via the specified protocol. You will need to install the respective extra dependency in order for this to work, which you can do when you install autometrics:

  ```sh
  pip install autometrics[exporter-otlp-proto-http]
  pip install autometrics[exporter-otlp-proto-grpc]
  ```

  After installing it you can configure the exporter as follows:

  ```python
  exporter = {
      "type": "otlp-proto-grpc",
      "address": "http://localhost:4317",
      "insecure": True
  }
  init(tracker="opentelemetry", service_name="my-service", exporter=exporter)
  ```

  To use a custom metric reader you can specify the exporter type to be `otel-custom` and provide a custom metric reader:

  ```python
  my_custom_metric_reader = PrometheusMetricReader("")
  exporter = {
      "type": "otel-custom",
      "reader": my_custom_metric_reader
  }
  init(tracker="opentelemetry", service_name="my-service", exporter=exporter)
  ```



  This package uses [poetry](https://python-poetry.org) as a package manager, with all dependencies separated into three groups:

  - root level dependencies, required
  - `dev`, everything that is needed for development or in ci
  - `examples`, dependencies of everything in `examples/` directory

  By default, poetry will only install required dependencies, if you want to run examples, install using this command:

  ```sh
  poetry install --with examples
  ```

  Code in this repository is:

  - formatted using [black](https://black.readthedocs.io/en/stable/).
  - contains type definitions (which are linted by [mypy](https://www.mypy-lang.org/))
  - tested using [pytest](https://docs.pytest.org/)

  In order to run these tools locally you have to install them, you can install them using poetry:

  ```sh
  poetry install --with dev --all-extras
  ```

  After that you can run the tools individually

  ```sh

  poetry run black .

  poetry run mypy .

  poetry run pytest

  poetry run pytest --cache-clear -k test_tracker
  ```


pkgId: 2f13654bba6a8329f5e2c1ee3dfe116c208ea813aa56efa8d0a9c4ea1a667d57
name: python-automic
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A library for manipulating finite-state automata
url: https://github.com/person594/automic
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automic-0.0.2-1.src.rpm
checksum_type: sha256
description:
  This is a library for simple operations on nondeterministic finite automata.
  It is primarily being developed as a component of the CCRF sequence-labeling model, and so it may not contain features not directly related to this.


pkgId: 0257963ca0213ebc844791d360e52e57adcbe8adc01b418bc261734054f15396
name: python-automig
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Declarative, automatic db migrations using SQL & git as the source of truth
url: https://github.com/abe-winter/automigrate
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automig-0.1.8-1.src.rpm
checksum_type: sha256
description:
  Automigrate is a command-line tool for SQL migrations.
  Unlike other migration tools, it uses git history to do diffs on `create table` statements instead of storing the migration history in a folder somewhere.

  * [How is this different](#how-is-this-different)
  * [Usage](#usage)
  * [Advanced features](#advanced-features)



  This tool uses git history to infer database migrations, and uses git SHAs to version production databases.

  Other schema migration tools typically work by diffing ORM definitions against a live database (which can be your local DB).
  Often these diffs are then checked into a folder in your project repo.

  Seriously, all you have to do is maintain a file like this:

  ```sql
  -- schema.sql
  create table whatever (
    userid uuid primary key,
    age_at_birth int default 0
  );
  ```

  And when you add a field to the create table statement, automig figures out the 'alter table'.



  If you're using postgres:

  ```bash
  pip install automig[postgres]

  export AUTOMIG_CON=postgresql://postgres:$PGPASSWORD@host

  automig_pg --glob 'schema/*.sql' init

  automig_pg --glob 'schema/*.sql' update

  automig_pg --preview --glob 'schema/*.sql' update
  ```

  If you're using another database, you can get the raw SQL for these actions by using the `automig` tool instead of `automig_pg`. (docs coming soon).

  Postgres is the primary database I test on, with sqlite support secondary.



  * [Instructions for doing kube-native migrations](./kube) are in the `kube` folder.
  * Lambda support: you'll need to bundle a binary version of git that's compatible with amazonlinux. Post an issue if you need help with this.
  * You can skip over bad diffs using `--opaque` mode, docs coming soon
  * You can specify manual overrides for erroring diffs, or skip over whole shas, by using [.manualmig.yml file](./.manualmig.yml). docs coming soon but in the meantime look inside that file for an example.
  * Convert an existing DB to use automig -- please post a github issue if you have this issue and I'll add instructions



  Experimental sqlalchemy generator in sa_harness.py. Try it out with:

  ```bash
  python -m automig.lib.sa_harness 'test/schema/*.sql'
  ```


pkgId: 0e08849818c2a8d82dab33fa1394fa31945ad4a9c8a0b62b425af8c1bb0345a5
name: python-automl-sphinx-theme
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: AutoML Theme for Sphinx
url: https://github.com/automl/automl_sphinx_theme
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automl-sphinx-theme-0.2.0-1.src.rpm
checksum_type: sha256
description:
  The goal of this repository is to set up a documentation as fast and as clean as possible. In your
  source project you only need to install `automl_sphinx_theme` to get all the features you need.
  Those include automatic API generation, beautiful theme, numpy docstring interpretation, and
  executing/plotting examples.

  <b>NO COMPLICATED `.conf` OR SPHINX KNOWLEDGE ARE NECESSARY!</b><br />
  :sparkling_heart: You're welcome. :sparkling_heart:




  - Include `name`, `version`, `author`, `copyright` in `{PACKAGE_NAME}/__init__.py`.
  - Copy the `docs` and `examples` directories to your root folder. You don't have to include all
  files but you should at least include `docs/conf.py` and `docs/Makefile`.
  - In `docs/conf.py` change `src` to `{PACKAGE_NAME}`. Adapt the file if needed.
  - Install this repo via pypi:
  ```
  pip install automl_sphinx_theme
  ```
  - You can generate the docs via `make html` inside the docs directory. Have a look inside the
  `Makefile` to get more information and commands.

  We recommend using the repository `automl_template` which incorporates `automl_sphinx_theme`
  automatically.




  The documentation can be pushed automatically to a branch, which is used to display a webpage.
  Follow the steps to enable it:
  - Copy `.github/workflows/docs.yml` to you root folder.
  - Create a new branch called `gh-pages`.
  - Go to `settings > pages` and select `gh-pages` as source.




  AutoML Sphinx Theme provides the user to link older versions of documentations (must be done manually!). Specify ``versions`` in the options to enable it. We recommend setting up a Github workflow which automatically pushes the latest tag to the gh-pages. From there, you could link the version directly.




  - Logo: Add docs/images/logo.png.
  - Favicon: Add docs/images/favicon.ico.


pkgId: e31cdb0d6cf7e0bde7903180e29ac9f6dcb4d0b893f126bde833db88d3452960
name: python-automl-tools
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: automl_tools
url: https://github.com/jonaqp/automl_tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automl-tools-0.2.5-1.src.rpm
checksum_type: sha256
description:
  [![Github License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Updates](https://pyup.io/repos/github/woctezuma/google-colab-transfer/shield.svg)](pyup)
  [![Python 3](https://pyup.io/repos/github/woctezuma/google-colab-transfer/python-3-shield.svg)](pyup)
  [![Code coverage](https://codecov.io/gh/woctezuma/google-colab-transfer/branch/master/graph/badge.svg)](codecov)




  Automl_tools is a Python library that implements Gradient Boosting


  The code is packaged for PyPI, so that the installation consists in running:
  ```sh
  pip install automl-tools
  ```



  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/10DFkSmzMO1GqLX-mgBWfDjS9OIVmEy6O?usp=sharing)




  Probabilistic binary example on the Boston housing dataset:

  ```python
  import pandas as pd
  from automl_tools import automl_run

  train = pd.read_csv("https://raw.githubusercontent.com/jonaqp/automl_tools/main/automl_tools/examples/train.csv?token=AAN2ZBDWF77QITK4ARSFIFDABUGAU")
  test = pd.read_csv("https://raw.githubusercontent.com/jonaqp/automl_tools/main/automl_tools/examples/test.csv?token=AAN2ZBD6TMUC5XSGRTJNVPDABUGCO")

  automl_run(train=train,
             test=test,
             id_col=None,
             target_col="Survived",
             imp_num="knn",
             imp_cat="knn",
             processing="binding",
             mutual_information=False,
             correlation_drop=False,
             model_feature_selection=None,
             model_run="LR",
             augmentation=True,
             Stratified=True,
             cv=5)







  ```


  ```sh
  imp_num : "gaussian", "arbitrary", "median", "mean", "random", "knn"
  imp_cat : "frequent", "constant", "rare", "knn"
  processing:  "woe", "binding"
  ```


  ```sh
  model_feature_selection:
      default: ["LR", "RF", "LGB"]
          LR  : LogisticRegression
          RF  : RandomForestClassifier
          SVM : SVC
          LS  : LASSO
          RD  : RIDGE
          NET : Elasticnet
          DT  : DecisionTreeClassifier
          ET  : ExtraTreesClassifier
          GB  : GradientBoostingClassifier
          AB  : AdaBoostClassifier
          XGB  : XGBClassifier
          LGB  : LGBMClassifier
          CTB  : CatBoostClassifier
          NGB  : NGBClassifier

  model_run:
      default: "LR"
          LR  : LogisticRegression
          RF  : RandomForestClassifier
          SVM : SVC
          LS  : LASSO
          RD  : RIDGE
          NET : Elasticnet
          DT  : DecisionTreeClassifier
          ET  : ExtraTreesClassifier
          GB  : GradientBoostingClassifier
          AB  : AdaBoostClassifier
          XGB  : XGBClassifier
          LGB  : LGBMClassifier
          CTB  : CatBoostClassifier
          NGB  : NGBClassifier
  ```



  [Apache License 2.0](https://www.dropbox.com/s/8t6xtgk06o3ij61/LICENSE?dl=0).



   * multi_class
   * regression
   * integrations GCP deploy model CI/CD
   * integrations AWS deploy model CI/CD


   - 0.1.5
     - fix imputer
     - fix space hyperparameter
     - update catboost test

   - 0.1.4
     - add parameter cv
     - add confusion Matrix
     - add comments readme.txt

   - 0.1.3
     - add parameter id_col
     - add comments readme.txt





   - Jonathan Quiza [github](https://github.com/jonaqp).
   - Jonathan Quiza [RumiMLSpark](http://rumi-ml.herokuapp.com/).
   - Jonathan Quiza [linkedin](https://www.linkedin.com/in/jonaqp/).


pkgId: ee3171a50e4cad67355a508727cb9b5f76bb8ed72f09c70b314d60a694c9314c
name: python-automodinit
arch: src
version: 0.16
epoch: 0
release: 1
summary: Solves the problem of forgetting to keep __init__.py files up to date
url: http://pypi.python.org/pypi/automodinit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automodinit-0.16-1.src.rpm
checksum_type: sha256
description:
  automodinit v0.16 5th March 2017:
  -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  Niall Douglas http://www.nedproductions.biz/
  See http://pypi.python.org/pypi/automodinit for latest version
  Go to http://github.com/ned14/automodinit to report bugs

  This package fixes a small problem which has been bugging me throughout
  years of python development: forgetting to keep a module's __init__.py
  up to date with new files added. This causes the following, irritating
  problems:

  1. Test suites don't find docstring tests.
  2. Static analysis tools don't see some module content in __all__.
  3. Things which scan themselves for plugins mismatch what os.listdir()
     returns as against what the module import table has.
  4. I waste time over something which should take care of itself.
  5. os.listdir() based solutions tend to fail when freezed into
     an executable binary because they don't understand running from
     inside a ZIP archive.

  So here's how to make the problem go away forever:

  1. Include the automodinit package into your setup.py dependencies.
  2. Replace all __init__.py files like this:

  __all__ = ["I will get rewritten"]

  import automodinit
  automodinit.automodinit(__name__, __file__, globals())
  del automodinit


  3. That's it! From now on importing a module will set __all__ to
     a list of .py[co] files in the module and will also import each
     of those files as though you had typed:

     for x in __all__: import x

     Therefore the effect of "from M import *" matches exactly "import M".

  Customising:
  -=-=-=-=-=-=
  automodinit can take the following additional parameters:

  filter: This is a callable which will be passed a list of tuples
          (loader, modulename, ispkg) which is the output of
          pkgutil.iter_modules() for the calling module. Return only
          those which you want to be imported.
  importFindings: Defaults to True. Set to False to not auto-import
                  the contents of __all__.

  Version history:
  -=-=-=-=-=-=-=-=
   * v0.16 5th Mar 2017
     * Fixed stripping of __init__.py file encoding. Thanks to wtyerogers
  for reporting this.
     * Removed suggestion this is the smallest package on pypi. Thanks to
  asl97 for reporting this.
     * Tell PyPi we are under the MIT licence. Thanks to njwhite for
  reporting this.

   * v0.13 9th Feb 2013
     * Fixed a bug where the source distribution would fail to install due
  to not including distribute_setup.py. Thanks to kanzure for reporting this.

   * v0.12 5th Mar 2012
     * Fixed a bug where isinstance would occasionally fail. Turns out the
  pkgutil loading mechanism doesn't check to see if the module is already
  loaded, so it was loading duplicates whose types wouldn't compare.

   * v0.11 5th Mar 2012
     * Fixed some typos in Readme.txt
     * Typically what worked before packaging did not work after. Fixed!

   * v0.10 5th Mar 2012
     First release


pkgId: 980735e9034d368308d8e4d18f6675b02a51899ebd13438e9c374aae63e83ff3
name: python-automonisaur
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Core libraries for automonisaur
url: https://github.com/TheShellLand/automonisaur
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automonisaur-0.6.0-1.src.rpm
checksum_type: sha256
description:
  ![](https://github.com/TheShellLand/automonisaur/raw/master/docs/images/sauruspark.gif)



  **[about](#about)** |
  **[integrations](#integrations)** |
  **[install](#install)** |
  **[docker](docker)** |
  **[unittest locally](#unittest-locally)** |
  **[codecov](https://codecov.io/gh/TheShellLand/automonisaur)** |
  **[pypi](https://pypi.org/project/automonisaur/)**

  [![master](https://github.com/TheShellLand/automonisaur/actions/workflows/ci.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/ci.yml)
  [![master](https://github.com/TheShellLand/automonisaur/actions/workflows/python312.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python312.yml)
  [![master](https://github.com/TheShellLand/automonisaur/actions/workflows/python311.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python311.yml)
  [![master](https://github.com/TheShellLand/automonisaur/actions/workflows/python310.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python310.yml)
  [![master](https://github.com/TheShellLand/automonisaur/actions/workflows/python39.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python39.yml)
  [![master](https://github.com/TheShellLand/automonisaur/actions/workflows/python38.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python38.yml)
  [![master](https://github.com/TheShellLand/automonisaur/actions/workflows/python37.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python37.yml)

  [![Downloads](https://static.pepy.tech/badge/automonisaur)](https://pepy.tech/project/automonisaur)
  [![Downloads](https://static.pepy.tech/badge/automonisaur/month)](https://pepy.tech/project/automonisaur)
  [![Downloads](https://static.pepy.tech/badge/automonisaur/week)](https://pepy.tech/project/automonisaur)

  [//]: # ([![codecov]&#40;https://codecov.io/gh/TheShellLand/automonisaur/branch/master/graph/badge.svg&#41;]&#40;https://codecov.io/gh/TheShellLand/automonisaur&#41;)



  This library adds some easier-to-use wrappers around common services for data
  science and threat intelligence.

  Provides easier clients and configuration options, as well as any additional
  helpers to get things up and running.

  Github issues and feature requests welcomed.



  | Category        | Library                                                     |
  |-----------------|-------------------------------------------------------------|
  | API             | flask                                                       |
  | Chat            | slack                                                       |
  | Data Scraping   | beautifulsoup<br/>facebook groups<br/>instagram<br/>scrapy  |
  | Databases       | elasticsearch<br/>neo4j<br/>splunk<br/>pass                 |
  | Data Store      | minio<br/>swift                                             |
  | Devices         | snmp                                                        |
  | Google Cloud    | google auth api<br/>google people api<br/>google sheets api |
  | Helpers         | os<br/>subprocess<br/>threading<br/>socket<br/>datetime     |
  | Logging         | sentryio                                                    |
  | MacOS           | airport<br/>macchanger<br/>wdutil                           |
  | Python          | logging<br/>requests                                        |
  | SOAR            | swimlane<br/>splunk soar<br/>xsoar                          |
  | Recon           | nmap                                                        |
  | Test Automation | selenium                                                    |



  - python >= 3.10

  _Note: install requirements.txt to use all integrations_



  ```shell script
  /bin/bash install.sh
  ```



  ```shell script

  /bin/bash install-requirements.sh


  python3 -m pip install -U -r requirements.txt


  python3 -m pip install -U -r https://raw.githubusercontent.com/TheShellLand/automonisaur/master/requirements.txt


  python3 -m pip install --upgrade git+https://github.com/TheShellLand/automonisaur.git@master#egg
  ```



  ```shell script
  /bin/bash unittests.sh
  ```


pkgId: 964a8a9232ef6cf15765f9de23a9d294951b1bf7a6c9e4d2b86e5f8d9ad14735
name: python-automonisaur
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Core libraries for automonisaur
url: https://github.com/TheShellLand/automonisaur
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automonisaur-0.6.1-1.src.rpm
checksum_type: sha256
description:
  ![](https://github.com/TheShellLand/automonisaur/raw/master/docs/images/sauruspark.gif)



  **[about](#about)** |
  **[integrations](#integrations)** |
  **[install](#install)** |
  **[docker](docker)** |
  **[unittest locally](#unittest-locally)** |
  **[codecov](https://codecov.io/gh/TheShellLand/automonisaur)** |
  **[pypi](https://pypi.org/project/automonisaur/)**

  [![cicd](https://github.com/TheShellLand/automonisaur/actions/workflows/ci.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/ci.yml)
  [![3.14](https://github.com/TheShellLand/automonisaur/actions/workflows/python314.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python314.yml)
  [![3.13](https://github.com/TheShellLand/automonisaur/actions/workflows/python313.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python313.yml)
  [![3.12](https://github.com/TheShellLand/automonisaur/actions/workflows/python312.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python312.yml)
  [![3.11](https://github.com/TheShellLand/automonisaur/actions/workflows/python311.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python311.yml)
  [![3.10](https://github.com/TheShellLand/automonisaur/actions/workflows/python310.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python310.yml)
  [![3.9](https://github.com/TheShellLand/automonisaur/actions/workflows/python39.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python39.yml)
  [![3.8](https://github.com/TheShellLand/automonisaur/actions/workflows/python38.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python38.yml)
  [![3,7](https://github.com/TheShellLand/automonisaur/actions/workflows/python37.yml/badge.svg)](https://github.com/TheShellLand/automonisaur/actions/workflows/python37.yml)

  [![Downloads](https://static.pepy.tech/badge/automonisaur)](https://pepy.tech/project/automonisaur)
  [![Downloads](https://static.pepy.tech/badge/automonisaur/month)](https://pepy.tech/project/automonisaur)
  [![Downloads](https://static.pepy.tech/badge/automonisaur/week)](https://pepy.tech/project/automonisaur)

  [//]: # ([![codecov]&#40;https://codecov.io/gh/TheShellLand/automonisaur/branch/master/graph/badge.svg&#41;]&#40;https://codecov.io/gh/TheShellLand/automonisaur&#41;)



  This library adds some easier-to-use wrappers around common services for data
  science and threat intelligence.

  Provides easier clients and configuration options, as well as any additional
  helpers to get things up and running.

  Github issues and feature requests welcomed.



  | Category        | Library                                                     |
  |-----------------|-------------------------------------------------------------|
  | API             | flask                                                       |
  | Chat            | slack                                                       |
  | Data Scraping   | beautifulsoup<br/>facebook groups<br/>instagram<br/>scrapy  |
  | Databases       | elasticsearch<br/>neo4j<br/>splunk<br/>pass                 |
  | Data Store      | minio<br/>swift                                             |
  | Devices         | snmp                                                        |
  | Google Cloud    | google auth api<br/>google people api<br/>google sheets api |
  | Helpers         | os<br/>subprocess<br/>threading<br/>socket<br/>datetime     |
  | Logging         | sentryio                                                    |
  | MacOS           | airport<br/>macchanger<br/>wdutil                           |
  | Python          | logging<br/>requests                                        |
  | SOAR            | swimlane<br/>splunk soar<br/>xsoar                          |
  | Recon           | nmap                                                        |
  | Test Automation | selenium                                                    |



  - python >= 3.10

  _Note: install requirements.txt to use all integrations_



  ```shell script
  /bin/bash install.sh
  ```



  ```shell script

  /bin/bash install-requirements.sh


  python3 -m pip install -U -r requirements.txt


  python3 -m pip install -U -r https://raw.githubusercontent.com/TheShellLand/automonisaur/master/requirements.txt


  python3 -m pip install --upgrade git+https://github.com/TheShellLand/automonisaur.git@master#egg
  ```



  ```shell script
  /bin/bash unittests.sh
  ```


pkgId: b7f2d1479af11fd9dcd55775fbd3e5a6e1dbeed10b1bc88df5d6b8d2173dd15a
name: python-automotifs
arch: src
version: 1.6
epoch: 0
release: 1
summary: A wrapper for automatic Motif Detection
url: https://github.com/GiorgioMB/auto_dotmotif/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automotifs-1.6-1.src.rpm
checksum_type: sha256
description:
  AutoMotif streamlines the identification and cataloging of motifs within network graphs. Utilizing NetworkX for graph manipulation, dotmotif for detecting motifs, and pandas for data management, it simplifies the process of uncovering patterns across both directed and undirected networks. Users can customize searches based on motif size, directionality, executors and the treatment of automorphisms, as well as even having the option to save the results for further analysis.




  ```bash
  pip install automotifs
  ```
  If you have an NVIDIA GPU and want to use GPU acceleration, ensure your system meets the requirements for CUDA 11 or CUDA 12, and then install the appropriate package:
  For CUDA 11:
  ```bash
  pip install nx-cugraph-cu11 --extra-index-url https://pypi.nvidia.com
  ```
  For CUDA 12:
  ```bash
  pip install nx-cugraph-cu12 --extra-index-url https://pypi.nvidia.com
  ```

  ```python
  from automotif import AutoMotif
  from dotmotif import executors
  import networkx as nx


  G = nx.gnp_random_graph(100, 0.5, directed=True)


  motif_finder = AutoMotif(Graph=G, size=3, directed=True, verbose=True, use_GPU=True)


  motifs = motif_finder.find_all_motifs()


  z_scores = motif_finder.calculate_zscore(num_random_graphs = 30, Executor = executors.NetworkXExecutor)


  motif_finder.display_all_motifs()
  ```

  - **Automated Detection**: AutoMotif automates the detection of motifs, eliminating the need for manual parameter adjustments. It's designed to be efficient and user-friendly, allowing users to focus more on analysis and less on setup.
  - **Flexible and Powerful**: Capable of handling both directed and undirected graphs, AutoMotif provides flexibility in defining motifs, including size and whether to consider automorphisms, ensuring a broad applicability across different types of network analyses. Additionally, AutoMotif supports GPU acceleration, allowing users to leverage the power of NVIDIA GPUs by setting `use_GPU=True` to accelerate motif detection.
  - **Data Organization and Export**: Directly save your motifs to CSV files for easy access, further analysis, or sharing with your team or research community.
  - **Z-Score Calculation**: Assess the statistical significance of detected motifs by calculating their Z-scores, providing insights into the rarity or commonality of patterns within your network compared to random expectations.
  - **Visual Representation**: AutoMotif includes features for visualizing network motifs, allowing users to display them as graphs within the application. This aids in the qualitative analysis of motifs, offering a graphical representation of network patterns and their connections for easier interpretation and presentation.

  We encourage contributions to AutoMotif! If you have ideas for improvements or new features, don't hesitate to open an issue or submit a pull request on our repository.

  AutoMotif is made available under the MIT License. See the LICENSE file for more details.
  ***

  AutoMotif was developed by Giorgio Micaletto under the guidance of Professor Marta Zava at Bocconi University. This tool is designed to simplify and facilitate the complex process of network motif analysis.
  Contacts:
  - giorgio.micaletto@studbocconi.it
  - [LinkedIn](linkedin.com/in/giorgio-micaletto/)


pkgId: 57fb5e30018d472547f52122bad739e0f1742ccafd3456414b4d9d64be6a761a
name: python-automower-ble
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: An unofficial reverse engineered Husqvarna Automower Connect BLE library
url: https://pypi.org/project/automower-ble/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automower-ble-0.2.0-1.src.rpm
checksum_type: sha256
description:
  This is an unofficial reverse engineered Husqvarna Automower Connect BLE library. This allows connecting and controlling an Automower without any accounts, cloud or network connection.

  <noscript><a href="https://liberapay.com/alistair23/donate"><img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg"></a></noscript>

  This library is written with the intent of integrating into Home Assistant, but it can be used independently as well.

  Details on how this was developed are available at: https://www.alistair23.me/2024/01/06/reverse-engineering-automower-ble

  This was developed and tested against a Automower 305, but it should work on all Automowers. If you are able to test on different models please do and report any results back.


  This library can be installed by
  ```shell
  pip3 install automower-ble
  ```
  Please note that the library is under active development and that the code on github might not be released for pip.



  You can test querying data with the following

  ```shell
  python3 ./mower.py --address D8:B6:73:40:07:37
  ```

  You can uncomment parts of `async def main(mower)` to send commands, or send commands using parameters:

  ```shell
  python3 ./mower.py --address D8:B6:73:40:07:37 --command park
  ```

  Where command is one of:
    park
    pause
    override
    resume

  (override will run for 3hrs)

  To get the address, the `ble_scanner.py` script can be run.



  Unit tests are found in the /tests/ folder.

  You can run the unit tests with [pytest](https://docs.pytest.org). Install it by `pip3 install pytest`. In the root path, just run

  ```shell
  pytest
  ```




  You can get Bluetooth debug logs from an Android phone which will help development for new features, unknown codes
  or implementation of extra devices. To debug you need to enable developer mode on your
  Android handset/tablet (and have the manufacturer app installed to communicate with your mower)

  To enable debug mode on Android:

  * Go into settings and System (Sometimes this is in About phone). Look for the "Build number" entry.
  * Tap this several times, onscreen you should then see a note confirming by tapping 7 times developer mode will be enabled.
  * Once enabled, click BACK and you'll see a "Developer Options" menu. In there scroll to find "Enable Bluetooth HCI snoop log".
  * Set "Enable Bluetooth HCI snoop log" to "Enabled"
  * Turn bluetooth OFF then back ON to enable the logging.

  Go into your mower app and carry out the commands, making a note of precise time you send the command to the mower.
  Once you've captured the commands, to retrieve the log you can either grab it using your phones file browser.
  The file location is /data/misc/bluetooth/logs
  The filename is btsnoop_hci.log
  (This varies, for example Samsung phones store them elsewhere)

  An alternative is to use the adb via usb to retrieve the log. Plug your phone in via usb and use adb to download your
  bug report:
    adb bugreport MyFilename
  (This will generate a bugreport and save it as MyFilename.zip)
  Extract that zip file and the bluetooth HCI snoop file is in FS/data/log/bt/btsnoop_hci.log

  These bluetooth hci snoop files (btsnoop_hci.log) are in wireshark file format so use wireshark to view them.
  You can then see the commands sent and received from your mower and can then decode/investigate the commands.


pkgId: fdd37af012022038bf88611f57ac4e4a6367c4cf40ac6ea4e5e85e5a8b314dd8
name: python-automox-console-sdk
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Automox Console SDK for Python
url: https://github.com/AutomoxCommunity/automox-console-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automox-console-sdk-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ![Automox logo]



  [![Continuous Integration](https://github.com/AutomoxCommunity/automox-console-sdk-python/actions/workflows/ci.yml/badge.svg)](https://github.com/AutomoxCommunity/automox-console-sdk-python/actions/workflows/ci.yml)
  [![Release](https://github.com/AutomoxCommunity/automox-console-sdk-python/actions/workflows/release.yml/badge.svg)](https://github.com/AutomoxCommunity/automox-console-sdk-python/actions/workflows/release.yml)

  The Automox SDK for Python includes an out-of-the-box Python library used to interact with the [Automox Console API]
  in order to:
  - Perform automated tasks
  - Retrieve Automox data
  - Perform management and administration functions
  - All other Automox Console API functionality!

  This SDK automatically generated and maintained with the use of [Swagger Codegen](https://github.com/swagger-api/swagger-codegen).
  By providing a supported mechanism with usage examples, we hope that customers can quickly get comfortable with the
  Automox API without the need to generate or build the library themselves.



  The SDK has been tested and supported for the following versions of Python:
  - Python 3 versions 3.9 and later

  While the library will work with Python 2.7, we discourage and do not support Python 2 use as it has since been sunset
  and python.org [recommends upgrading to Python 3](https://www.python.org/doc/sunset-python-2/).





  The Automox SDK for Python is most easily installed with a single `pip` command to pull the latest package version from
  the [Python package Index (PyPi)](https://pypi.org/). The published versions of the project are maintained at the
  [PyPi Project page](https://pypi.org/project/automox-console-sdk/). Getting started is generally a simple as running
  the following command on a system with Python 3.9+ installed:

  ```shell
  pip install automox-console-sdk
  ```



  With each new release of the SDK, a published tag and Github Release will be created. To install the latest version of
  SDK from Github:
  1. Download the latest wheel from the project's [Github Releases](https://github.com/AutomoxCommunity/automox-console-sdk-python/releases)
  2. Install the wheel locally: `pip install automox_console_sdk-0.1.1-py3-none-any.whl`
  3. Import the package:
  ```python
  import automox_console_sdk
  ```



  Please follow the [installation procedure](https://github.com/AutomoxCommunity/automox-console-sdk-python#installation--usage) and then move on to the following sections.



  Prior to using the SDK, it is necessary to generate an [Automox API Key](https://docs.automox.com/home/automox-settings/accessing-your-api-keys#api-key)
  used for authorizing requests to the Automox API. Steps for creating an API key for you user account can be found
  [here](https://docs.automox.com/home/automox-settings/accessing-your-api-keys#adding-api-keys).

  Once an API key has been created, it can then be used with the [example scripts](https://github.com/AutomoxCommunity/automox-console-sdk-python/tree/main/examples/scripts) provided with the
  SDK. By importing the package and creating an Automox ApiClient, you will then be ready to leverage SDK functionality:

  ```python
  import automox_console_sdk as automox
  import os

  config = automox.Configuration()

  client = automox.ApiClient(configuration=config)
  client.default_headers['Authorization'] = f"Bearer {os.getenv('AUTOMOX_API_KEY')}"
  ```

  The example above imports the package, creates a base configuration, and initializes the `ApiClient` with the
  Authorization header set with your API key. All examples avoid hard-coding API Keys in the script by leveraging the
  `AUTOMOX_API_KEY` environment variable. When running scripts, remember to set or pass your API key as an environment
  variable to avoid authorization exceptions:
  ```shell
  AUTOMOX_API_KEY=<API KEY GOES HERE> python example.py
  ```

  Once defining the base client with authorization, the script can be updated to include a specific API implementation. In
  the example below we will be using the DevicesApi to list devices:
  ```python
  devices_api = DevicesApi(client)

  for d in devices_api.get_devices(limit=500, page=0):
      print(f"Device ID: {d.id}, Hostname: {d.name}, Server Group ID: {d.server_group_id}, IP Addresses: {d.ip_addrs}")
  ```

  A fully-implemented [script example](https://github.com/AutomoxCommunity/automox-console-sdk-python/blob/main/examples/scripts/list_devices.py) of listing devices is provided along with a
  growing number of other examples of using the Automox SDK for Python. Feel free to contribute any scripts you have found
  helpful with the Community!



  To get started without writing a single line of Python, [Example Scripts](https://github.com/AutomoxCommunity/automox-console-sdk-python/tree/main/examples/scripts) have been included with the
  SDK. These scripts show off simple functionality such as:
  - Listing Devices
  - Updating a Device
  - Creating a Device Group

  They should be used as reference as you are building your own scripts and utilities with the Automox SDK.



  [Use Case Examples](https://github.com/AutomoxCommunity/automox-console-sdk-python/tree/main/examples/use-cases) have
  been provided to show off end to end utility of leveraging the Automox SDK within varying environments. These use cases
  can be used as-is or modified to meet your environment needs.



  All functionality provided by the Automox Console SDK for Python is based on the Autmox Console API specification that
  is publicly published. If there is functionality that is incomplete or does not yet exist, please reached out to your
  Customer Success Manager or [contact support](https://support.automox.com/help/contacting-automox-support) along with
  the details of what you would like to see in future releases of the SDK.

  [//]: # "Link anchor definitions"
  [Automox Logo]: https://raw.githubusercontent.com/AutomoxCommunity/automox-console-sdk-python/main/assets/AX-Horiz-Logo.png
  [Automox Console API]: https://developer.automox.com/developer-portal/
  [Documentation]: https://github.com/AutomoxCommunity/automox-console-sdk-python/blob/main/docs/README.md


pkgId: a36899370bca94969425c856f153b61e742121a8f1a6189cc813dc1b9439ffb3
name: python-automsr
arch: src
version: 9.7.0
epoch: 0
release: 1
summary: Automate Rewards points collection
url: https://github.com/Crissal1995/automsr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automsr-9.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/automsr)](https://pypi.org/project/automsr/#history)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/automsr)](https://pypi.org/project/automsr)
  [![Checks](https://github.com/Crissal1995/automsr/actions/workflows/checks.yaml/badge.svg)](https://github.com/Crissal1995/automsr/actions/workflows/checks.yaml)



  **AutoMSR** is an automation tool created for educational purpose,
  intending to show how to use Selenium as an automation driver
  for the Microsoft Rewards service.



  This tool is intended to show how to collect automatically daily points for
  Microsoft Rewards.

  What is included:
  - Daily promotions completed.
  - Other activities completed.
  - Free punchcards completed.
  - Searches with a desktop User Agent completed.
  - Searches with a mobile User Agent completed.



  Before using this software, read carefully the [Microsoft Terms of Service](https://www.microsoft.com/servicesagreement),
  section _Microsoft Rewards_.

  TL;DR: the usage of AutoMSR could lead in a ban.





  ```shell
  $ pip install automsr  # this will install the binary `automsr`
  ```



  AutoMSR behaviour can be configured using a `config.yaml` file.

  An example with every input described in detail is found here: [link](https://github.com/Crissal1995/automsr/blob/main/tests/configs/config.example.yaml).


  Download the correct [Chromedriver](https://chromedriver.chromium.org/downloads) matching your Chrome version.





  ```shell
  $ automsr --help
  ```



  ```shell
  $ automsr run


  $ automsr run --config path/to/a/config.yaml
  ```



  ```shell
  $ automsr init
  ```



  ```shell
  $ automsr profiles


  $ automsr profiles --format pretty-json






  ```



  ```shell
  $ automsr email
  ```


pkgId: 9d96b45b5fe8c4daa5d3d8eebff3fdb1049cac55b6089a2d6e43f39939b8cdaa
name: python-automua
arch: src
version: 2023.0
epoch: 0
release: 1
summary: Mail client autoconfiguration service
url: https://hlfh.github.io/automua
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automua-2023.0-1.src.rpm
checksum_type: sha256
description:
  automua makes configuring email accounts easy. It unites methods for automated mailbox configuration from Apple's
  [Mobileconfig](https://support.apple.com/en-gb/guide/profile-manager/pmdbd71ebc9/mac), Microsoft's
  [Autodiscover](https://docs.microsoft.com/en-gb/exchange/architecture/client-access/autodiscover?view=exchserver-2019)
  and Mozilla's [Autoconfig](https://hlfh.github.io/autoconfiguration/) in one tool.
  automua is a fork of automx2. It accepts code contributions.


  automua is a fork of [automx2](https://github.com/rseichter/automx2).
  Check per-file copyright notices to see the sole modifications and the new files of the fork automua that are Copyright © 2022 Gaspard d'Hautefeuille.
  automx2 and most of the files of the fork are Copyright © 2019-2022 Ralph Seichter.

  automua is licensed under the GNU General Public License V3 or later. The project is hosted on GitHub in the [HLFH/automua](https://github.com/HLFH/automua) repository. It is published on [PyPI.org](https://pypi.org/project/automua/) and [Arch Linux AUR](https://aur.archlinux.org/packages/automua).


  automua as a fork of automx2 has a few advantages:
   - automua is working [better with Autodiscover](https://github.com/HLFH/automua/issues/6) ;
   - automua implements [PEP 517 & PEP 518](https://github.com/HLFH/automua/issues/1) ;
   - automua supports [Arch Linux](https://aur.archlinux.org/packages/automua) ;
   - automua supports the last version of [Flask](https://github.com/HLFH/automua/issues/7).



  Detailed documentation is available in [HTML](https://hlfh.github.io/automua/),
  [PDF](https://github.com/hlfh/automua/blob/master/docs/automua.pdf) and
  [other formats](https://github.com/hlfh/automua/blob/master/docs).



  [Mobileconfig mail payload](https://support.apple.com/en-gb/guide/deployment/dep9c14bfc5/1/web/1.0)
  Use [Apple Configurator](https://apps.apple.com/app/apple-configurator-2/id1037126344) to go into details.

  [MS-OXDSCLI Autodiscover Publishing and Lookup Protocol](https://learn.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxdscli/78530279-d042-4eb0-a1f4-03b18143cd19)

  Mozilla Thunderbird is looking up with [Autodiscover](https://github.com/mozilla/releases-comm-central/blob/master/mail/components/accountcreation/ExchangeAutoDiscover.jsm) before Autoconfig.
  But it [does not support the Encryption element](https://bugzilla.mozilla.org/show_bug.cgi?id=1799635), only the SSL element.




  This project accepts code contributions.

  Furthermore, submitting ideas, suggestions, requests and bug reports in the form of
  [GitHub issues](https://github.com/hlfh/automua/issues) is welcome.



  It is possible to sponsor specific new features. Please contact me via email to discuss this in detail.


pkgId: 8c2f0604c831cb45c6bf626dbe95be38bb243c9789dd23fedb452559658bd944
name: python-automx2
arch: src
version: 2024.2
epoch: 0
release: 1
summary: Mail User Agent auto-configuration service
url: https://github.com/rseichter/automx2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-automx2-2024.2-1.src.rpm
checksum_type: sha256
description:
  automx2 makes configuring email accounts easy. It unites methods for automated mailbox configuration from Apple's
  [Mobileconfig](https://support.apple.com/de-de/guide/profile-manager/pmdbd71ebc9/mac), Microsoft's
  [Autodiscover](https://docs.microsoft.com/de-de/exchange/architecture/client-access/autodiscover?view=exchserver-2019)
  and Mozilla's [Autoconfig](https://developer.mozilla.org/de/docs/Mozilla/Thunderbird/Autokonfiguration) in one tool.
  automx2 is successor to automx. It has been designed to be easier to set up, easier to configure and easier to use.



  automx2 is Copyright © 2019-2024 Ralph Seichter.
  automx2 is licensed under the GNU General Public License V3 or later. The project is hosted on GitHub in the
  [rseichter/automx2](https://github.com/rseichter/automx2) repository and published on
  [PyPI.org](https://pypi.org/project/automx2/).



  Detailed documentation is available in [HTML](https://rseichter.github.io/automx2/),
  [PDF](https://github.com/rseichter/automx2/blob/master/docs/automx2.pdf) and
  [other formats](https://github.com/rseichter/automx2/blob/master/docs).



  To avoid copyright issues, I do not currently accept code contributions. I hope that this will change at some point
  in the future, but for now, please refrain from opening merge requests.

  However, submitting ideas, suggestions and bug reports in the form of
  [GitHub issues](https://github.com/rseichter/automx2/issues) is welcome. Please refer to
  [this blog article](https://about.gitlab.com/blog/2016/03/03/start-with-an-issue/) for an explanation on why issues
  are a good method to share and discuss ideas.



  It is possible to sponsor specific new features. Please contact me via email to discuss this in detail.


pkgId: 4dd81191c4d76a77c3d4d172933a14ff879487cb10ecce71a738b8e5bab40c9c
name: python-autonicer
arch: src
version: 1.2.6
epoch: 0
release: 1
url: https://pypi.org/project/autonicer/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autonicer-1.2.6-1.src.rpm
checksum_type: sha256
summary:
  A program that retrieves NICER observational data sets and performs a default data reduction process on the NICER observational data

description:
  [![PyPI](https://img.shields.io/pypi/v/autonicer.svg)](https://pypi.org/project/autonicer/)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/autonicer.svg?label=PyPI%20downloads)](https://pypi.org/project/autonicer/)


  A piece of software that allows for the automated retrieval, and default data reduction of NICER data. This software was developed to automate the retrieval of NICER data and perform standardized data reduction on the retrieved NICER data.
  This project unaffiliated with the NICER team, NASA, the Goddard Space Flight Center (GSFC), and HEASARC. Thus, under no circumstances should anyone consider this project endorsed or recommended by the afformentioned agencies and organizations.


  Anyone considering contribiting to this project is encouraged to do so.
  Constributing can be something as small as submitting issues you have found or requesting enhancements. Your feedback is incredibly valuable for improving the project.
  All that is asked is that if you wish to contribute code please reach out in one way or another to nkphysics(Nick Space Cowboy), and submit a pull request.
  And if you want to see what's being worked on for future versions check out the open issues tagged as enhancements or the open projects under the projects tab.

  Thank you.


  This software is licensed under the Apache 2.0 license, so it is free and open source for you to use.
  This project unaffiliated with the NICER team, NASA, the Goddard Space Flight Center (GSFC), and HEASARC. Under no circumstances should anyone consider this project endorsed or recommended by the afformentioned agencies and organizations.


  After v1.0.2 I a made a video going over autoNICER and demoing some of its functionality.
  See it here:
  <https://youtu.be/q23dvn3Da7Q>

  For more in depth instructions and documentation check out the wiki:
  <https://github.com/nkphysics/autoNICER/wiki>


  - HEASoft v6.29c, v6.30.1, RECOMMENDED v6.31.1 <https://heasarc.gsfc.nasa.gov/docs/software/lheasoft/>

  A video tutorial on how to generally install heasoft can be found here: <https://youtu.be/3-gobnSEuDo>
  - Remote CALDB <https://heasarc.gsfc.nasa.gov/docs/heasarc/caldb/caldb_remote_access.html>

  A video tutorial on how to setup Remote CALDB can be found here: <https://youtu.be/s01DF0cwOvM>
  - wget



  For standard non-dev use cases download via pip.

  	$ pip3 install autonicer

  OR

  	$ pip install autonicer

  For development cases:
  - Clone the repo
  - cd into the project directory
  - Run `poetry install` to install the needed dependencies
  - Start working!



  1. Initialize HEASoft.

  2. Go to the HEASARC archive in your web browser and query the NICERMASTER catalog for the source of your choice.

  2. Navigate to the desired directory where you want the NICER data that will be retrieved to be stored.

  3. Run autonicer by calling the local installation (i.e. `$ autonicer`)

  4. Upon starting autoNICER you will be asked to input the target source that you would like to query. Input the same source that you queryed in the web browser (ex: PSR_B0531+21).

  5. Next you will be prompted to select the settings. You can select the following
  	- If you want a barycenter correction performed
  	- If a .csv log of the autoNICER run is written out
  	- If the *ufa.evt files are compressed after reduction

  6. Next you will see the following prompt `autoNICER > `. Enter in the desired OBSID for the observation that you want retrieved and reduced. Better yet, copy the desired observation ID from the HEASARC archive and paste into the program. This will query that observation to be retrieved and processed. Type `sel` to see all the OBSID's you've selected. Type `cycle [cycle number]`(not with the brackets) to select all OBSID's from a specific cycle. You can use the `rm [all or OBSID]` or `back` commands to remove unwanted OBSID's that you may have selected by mistake. Type `done` when you have entered in all the observation IDs you want retrieved and reduced.

  7. You will see autoNICER start retrieving the data with wget, then that will be fed directly into `nicerl2`, then it will be barycenter corrected and lastly compressed in a .gz format if you selected for it to happen. Selected OBSID's are retrieved and processed in series so autoNICER will move on the the next OBSID you've queryed up and give you back command of your terminal after it has retrieved and reduced all selected OBSIDs.

  - Run `autonicer --help` for a list of CLI options

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 2021 Nicholas Kuechel  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: 842bb2a2fd31087fa3c095b4aaab1ac747f0593b2404580e772b3527dd2cc8ca
name: python-autonomize-model-sdk
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: SDK for creating and managing machine learning pipelines.
url: https://github.com/autonomize-ai/autonomize-model-sdk.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autonomize-model-sdk-1.0.0-1.src.rpm
checksum_type: sha256
description:
  The ModelHub SDK is a comprehensive toolkit designed to streamline the creation, management, and deployment of machine learning pipelines. It integrates seamlessly with ModelHub, a robust platform for developing and deploying machine learning models. This SDK provides an intuitive API for interacting with various ModelHub components, including MLflow for experiment tracking and pipeline orchestration.



  - **Modular Architecture**: Organized into well-defined modules for core functionalities, client implementations, models, and utilities.
  - **MLflow Integration**: Simplifies interaction with MLflow for tracking experiments, logging metrics, and managing model artifacts.
  - **Pipeline Management**: Tools for creating, updating, and submitting machine learning pipelines efficiently.
  - **Utility Functions**: Includes helper functions for common tasks such as logging setup and file encoding.
  - **Extensibility**: Designed to be easily extendable for future enhancements and additional features.



  To install the ModelHub SDK, run:

  pip install autonomize-model-sdk


pkgId: 50e8b0ccf9a2bd25fddb53d9134f8cd1a2b2e085c8d80b4c5bb7477fc1e4671d
name: python-autonomy-dev
arch: src
version: 0.2.78
epoch: 0
release: 1
summary: A collection of tooling to enable open source development of autonomy tools
url: https://github.com/8ball030/auto_dev
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autonomy-dev-0.2.78-1.src.rpm
checksum_type: sha256
description:
  Tooling to speed up autonomy development.



  There are a number of useful command tools available.

  - Dev Tooling: linting, formatting and dependency management.

  - Scaffolding: Tooling to auto generate repositories and components.



  - Templated agents for speedy proof of concept and getting started fast.






  We provide tools to generate protocols components from specs.

  ```bash
  adev create tmp_agent_name -t eightballer/base --force
  cd tmp_agent_name
  adev scaffold protocol ../specs/protocols/balances.yaml
  aea -s publish --push-missing
  ...
  Starting Auto Dev v0.2.75 ...
  Using 32 processes for processing
  Setting log level to INFO
  Creating agent tmp_agent_name from template eightballer/base
  Executing command: ['poetry', 'run', 'autonomy', 'fetch', 'bafybeidohldv57m3jkc33zpgbxukaushmcibmt4ncnsnomd3pvpocxs3ui', '--alias', 'tmp_agent_name']
  Command executed successfully.
  Agent tmp_agent_name created successfully.
  Starting Auto Dev v0.2.75 ...
  Using 32 processes for processing
  Setting log level to INFO
  Read protocol specification: ../specs/protocols/balances.yaml
  protolint version 0.50.0(d6a3250)
  protolint version 0.50.0(d6a3250)
  Updated: /home/eight/Projects/StationsStation/repos/capitalisation_station/tmp_agent_name/protocols/balances/custom_types.py
  New protocol scaffolded at /home/eight/Projects/StationsStation/repos/capitalisation_station/tmp_agent_name/protocols/balances

  ...

  adev test -p packages/eightballer/protocols/balances
  Testing path: `packages/eightballer/protocols/balances/` ⌛
  Testing... ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   0% -:--:--👌 - packages/eightballer/protocols/balances/
  Testing... ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:02
  Testing completed successfully! ✅
  ```



  We can scaffold a new contract using the `adev scaffold contract` command. This will create a new directory with;
  - open-aea contract component
      - open-aea contract component class 🎉
      - open-aea contract component function generation 🚧
      - open-aea contract component test generation 🚧


  ```bash
  adev scaffold contract 0xc939df369C0Fc240C975A6dEEEE77d87bCFaC259 beyond_pricer \
        --block-explorer-api-key $BLOCK_EXPLORER_API_KEY \
        --block-explorer-url "https://api-goerli.arbiscan.io"
  ```




  ```bash
  pip install autonomy-dev[all]
  ```


  ```bash
  checkout main
  git pull
  adev release
  ```



  [![Code Quality](https://github.com/8ball030/auto_dev/actions/workflows/common_check.yaml/badge.svg)](https://github.com/8ball030/auto_dev/actions/workflows/common_check.yaml)


pkgId: 0f22cd4f38d7e80c39428ff9a030b3ceb057a9d0c6979b5d7c56bfd95b2c52dd
name: python-autonote
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Automate taking notes
url: https://pypi.org/project/autonote/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autonote-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/nakamasato/autonote/branch/main/graph/badge.svg?token=ejR44mVdjO)](https://codecov.io/gh/nakamasato/autonote)



  ![](docs/diagram.drawio.svg)

  Automate creating daily, weekly, monthly, and quarterly manual repetitive documents:

  1. Daily: daily journal, habit tracker
  1. Weekly: weekly report
  1. Monthly: monthly report
  1. Quarterly: quarterly review



  1. [Confluence API Token](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/)

      ```
      export CONFLUENCE_URL=https://xxx.atlassian.net
      export CONFLUENCE_USERNAME=<yourname>@domain.com
      export CONFLUENCE_PASSWORD=<TOKEN>
      ```
  1. [Notion Integration Token](https://developers.notion.com/docs/authorization)

      ```
      export NOTION_INTEGRATION_TOKEN=xxx
      ```

      Please do not forget to [share the target database/page with your integration](https://developers.notion.com/docs/create-a-notion-integration#step-2-share-a-database-with-your-integration)



  ```
  pip install autonote
  ```



  1. Create a template page.

      <table><tr><td>
      <img src="docs/notion_template_page_1.png" width="200px" />
      </td></tr></table>

  1. Prepare Python script.

      ```python
      from autonote.notion import NotionClient

      client = NotionClient()

      kwargs = {
          "Date": {"start": "2023-02-04", "end": "2023-02-10"},
          "replace_rules": [
              {
                  "block_types": ["heading_1"],  # target blocks to apply replacement
                  "replace_str": "YYYY/MM/DD",  # replacement string match
                  "replace_type": "datetime",  # currently only support "datetime"
                  "date_format": "%Y/%m/%d",  # used to parse `start_date` and generate string from datetime when interpolating
                  "start_date": "2023/02/04",  # start date
                  "increment": True,  # if true, increment 1 day every time replacement is executed
              },
          ],
      }
      client.create_page_from_template(
          template_id="a7cc4f73460c4b9fa82be8d4ed74d8ca",
          title="weekly note",
          override=True,
          **kwargs
      )
      ```

  1. Run the script.
      ```
      pip install autonote
      python main.py
      ```

      Generated page:
      <table><tr><td>
      <img src="docs/notion_page_3.png" width="200px" />
      </td></tr></table>


  For more examples, please check [examples](examples/README.md).



  `autonote` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).



  `autonote` was created by Masato Naka. It is licensed under the terms of the MIT license.


  1. [Atlassian Python API Confluence module](https://atlassian-python-api.readthedocs.io/confluence.html)
  1. [notion-client](https://pypi.org/project/notion-client/)
  1. [Notion API](https://developers.notion.com/)


pkgId: be855021369d8920d708b20c678595a112d9510a4f40572926bc14139678bc77
name: python-autooc
arch: src
version: 0.0.17
epoch: 0
release: 1
summary: AutoOC: Automated Machine Learning (AutoML) library for One-Class Learning
url: https://github.com/luisferreira97/AutoOC
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autooc-0.0.17-1.src.rpm
checksum_type: sha256
description:
  <!-- PROJECT SHIELDS -->
  <!--
  *** I'm using markdown "reference style" links for readability.
  *** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
  *** See the bottom of this document for the declaration of the reference variables
  *** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
  *** https://www.markdownguide.org/basic-syntax/#reference-style-links
  -->
  <!--[![Downloads](https://static.pepy.tech/personalized-badge/autooc?period=total&units=international_system&left_color=black&right_color=orange&left_text=Downloads)](https://pepy.tech/project/autooc)-->
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![LinkedIn][linkedin-shield]][linkedin-url]

  <!-- PROJECT LOGO -->
  <br />
  <p align="center">
    <a href="https://github.com/luisferreira97/AutoOC">
      <img src="https://raw.githubusercontent.com/luisferreira97/AutoOC/main/images/logo.png" alt="Logo" width="100" height="100">
    </a>

    <h3 align="center">AutoOC (in Beta)</h3>

    <p align="center">
      AutoOC: Automated Machine Learning (AutoML) library focused on One-Class Learning algorithms (Deep AutoEncoders, Variational AutoEncoders, Isolation Forest, Local Outlier Factor and One-Class SVM)
      <br />
      <!--<a href="https://github.com/luisferreira97/AutoOC"><strong>Explore the docs »</strong></a>
      <br />
      <br />-->
      <!--<a href="https://github.com/luisferreira97/AutoOC">View Demo</a>
      ·-->
      <a href="https://github.com/luisferreira97/AutoOC/issues">Report Bug</a>
      ·
      <a href="https://github.com/luisferreira97/AutoOC/issues">Request Feature</a>
    </p>
  </p>



  <!-- TABLE OF CONTENTS
  <details open="open">
    <summary>Table of Contents</summary>
    <ol>
      <li>
        <a href="#about-the-project">About The Project</a>
        <ul>
          <li><a href="#built-with">Built With</a></li>
        </ul>
      </li>
      <li>
        <a href="#getting-started">Getting Started</a>
        <ul>
          <li><a href="#prerequisites">Prerequisites</a></li>
          <li><a href="#installation">Installation</a></li>
        </ul>
      </li>
      <li><a href="#usage">Usage</a></li>
      <li><a href="#roadmap">Roadmap</a></li>
      <li><a href="#contributing">Contributing</a></li>
      <li><a href="#license">License</a></li>
      <li><a href="#contact">Contact</a></li>
      <li><a href="#acknowledgements">Acknowledgements</a></li>
    </ol>
  </details>-->



  <!-- ABOUT THE PROJECT


  [![Product Name Screen Shot][product-screenshot]](https://example.com)

  There are many great README templates available on GitHub, however, I didn't find one that really suit my needs so I created this enhanced one. I want to create a README template so amazing that it'll be the last one you ever need -- I think this is it.

  Here's why:
  * Your time should be focused on creating something amazing. A project that solves a problem and helps others
  * You shouldn't be doing the same tasks over and over like creating a README from scratch
  * You should element DRY principles to the rest of your life :smile:

  Of course, no one template will serve all projects since your needs may be different. So I'll be adding more in the near future. You may also suggest changes by forking this repo and creating a pull request or opening an issue. Thanks to all the people have have contributed to expanding this template!

  A list of commonly used resources that I find helpful are listed in the acknowledgements.
  -->

  <!-- GETTING STARTED -->


  This section presents how the package can be reached and installed.



  The source code is currently hosted on GitHub at: https://github.com/luisferreira97/AutoOC

  Binary installer for the latest released version are available at the Python Package Index (PyPI). The PyPI name of the package is `autooc`.

  ```sh
  pip install autooc
  ```

  <!-- USAGE EXAMPLES -->



  The first step in using the package is, after it has been installed, to import it. The main class from which all the methods are available is ```AutoOC```.

  ```python
  from autooc.autooc import AutoOC
  ```


  The second step is to instantiate the AutoOC class with the information about your dataset and context (e.g., normal and anomaly classes, wether to run single-objective or multi-objective, the performance_metric, and the algorithm).
  You can change the ```algorithm``` parameter to select which algorithms are used during the optimization. The options are:
  - "autoencoders": Deep AutoEncoders (from TensorFlow)
  - "vae": Variational AutoEncoders (from TensorFlow)
  - "iforest": Isolation Forest (from Scikit-Learn)
  - "lof": Local Outlier Factor (Scikit-Learn)
  - "svm": One-Class SVM (from Scikit-Learn)
  - "nas": the optimization is done using AutoEncoders and VAEs
  - "all": the optimization is done using all five algorithms

  For the ```performance_metric``` parameter to select which algorithms are used during the optimization. The options are:
  - "training_time": Minimizes training time
  - "predict_time": Minimizes the time it takes to predict one record
  - "num_params": Minimizes the number of parameters (```count_params()``` in Keras); only available when ```algorithm``` equals to ```autoencoders```, ```vae```, or ```nas```.
  - "bic": Minimizes the value of the Bayesian Information Criterion

  ```python
  aoc = AutoOC(anomaly_class = 0,
      normal_class = 1,
      multiobjective=True,
      performance_metric="training_time",
      algorithm = "autoencoder"
  )
  ```


  The third step is to load the dataset. Depending on the type of validation you need *train data* (only 'normal' instances), *validation data* (you can use (1) only 'normal' instances or (2) both 'normal' and 'anomaly' instances with the respective labels), and *test data* (both types of instances and labels). You can use the ```load_example_data()``` function to load the popular ECG dataset.


  ```python
  X_train, X_val, X_test, y_test = aoc.load_example_data()
  ```


  The fourth step is to train the model. The ```fit()``` function computes the optimization using the given parameters.

  ```python
  run = aoc.fit(
      X=X_train,
      X_val=X_val,
      pop=3,
      gen=3,
      epochs=100,
      mlflow_tracking_uri="../results",
      mlflow_experiment_name="test_experiment",
      mlflow_run_name="test_run",
      results_path="../results"
  )
  ```



  The fifth step is to predict the labels of the test data. You can use the ```predict()``` function to predict the labels of the test data. You can change the ```mode``` parameter to select which individuals are used to predict.
  - "all": uses all individuals (models) from the last generation
  - "best": uses the from the last generation which achieved the best predictive metric
  - "simplest": uses the from the last generation which achieved the best efficiency metric
  - "pareto": uses the pareto individuals from the last generation (only for multiobjective. These are the models that achieved simultaneouly the best predictive metric and efficiency metric.

  Additionally, you can use the ```threshold``` parameter (only used for AutoEncoders) to set the threshold for the prediction. You can use the following values:
  - "default": uses a different threshold value for each individual (model). For each model the threshold value is the associated default value (currently this works similar to the "mean" value).
  - "mean": For each model the threshold value is the sum of the mean reconstruction error obtained on the validation data and one standard deviation.
  - "percentile": For each model the threshold value is the 95th percentile of the reconstruction error obtained on the validation data (you can also use the ```percentile``` parameter to change the percentile).
  - "max": For each model the threshold value is maximum reconstruction error obtained on the validation data.
  - You can also pass an Integer of Float value. In this case, the threshold value is the same for all the models.


  ```python
  predictions = aoc.predict(X_test,
      mode="all",
      threshold="default")
  ```



  You can use the predictions to calculate manually the performance metrics of the model. However, the ```evaluate()``` function is a more convenient way to do it. You can also use the ```mode``` parameter (works similarly to the ```predict()``` function) and use metrics from the ```sklearn.metrics``` package (currently available are "roc_auc", "accuracy", "precision", "recall", and "f1").

  ```python
  score = aoc.evaluate(X_test,
      y_test,
      mode="all",
      metric="roc_auc",
      threshold="default")
  ```



  ```python
  from autooc.autooc import AutoOC

  aoc = AutoOC(anomaly_class = 0,
      normal_class = 1,
      multiobjective=True,
      performance_metric="training_time",
      algorithm = "autoencoder"
  )

  X_train, X_val, X_test, y_test = aoc.load_example_data()

  run = aoc.fit(
      X=X_train,
      X_val=X_val,
      pop=3,
      gen=3,
      epochs=100,
      mlflow_tracking_uri="../results",
      mlflow_experiment_name="test_experiment",
      mlflow_run_name="test_run",
      results_path="../results"
  )

  predictions = aoc.predict(X_test,
      mode="all",
      threshold="default")

  score = aoc.evaluate(X_test,
      y_test,
      mode="all",
      metric="roc_auc",
      threshold="default")
  print(score)
  ```





  Grammatical Evolution (GE) is a biologically inspired evolutionary algorithm for generating computer programs. The algorithm was proposed by O’Neill and Ryan in 2001 and has been widely used in both optimization and ML tasks. In GE, a set of programs is represented as strings of characters, known as chromosomes. The chromosomes are encoded using a formal grammar, which defines the syntax and structure of the programs. The grammar is used to parse the chromosomes and generate the corresponding programs, which are then evaluated using a fitness function. The fitness function measures the quality of the programs and is used to guide the evolution process toward better solutions.

  One of the main advantages of GE is its ability to generate programs in any language, as long as a suitable grammar is defined. This makes GE a versatile tool for developing custom software solutions for a wide range of applications. In addition to its flexibility and versatility, GE can handle complex optimization problems with a large number of objectives and constraints. It can also handle continuous and discrete optimization problems, as well as problems with mixed variables. GE has been shown to be effective in finding high-quality solutions in a relatively short time, compared to other optimization methods.

  A GE execution starts by creating an initial population of solutions (usually randomly), where each solution (usually named individual) corresponds to an array of integers (or genome) that is used to generate the program (or phenotype). In the evolutionary process of GE, each generation consists of two main phases: evolution and evaluation. During the evolution phase, new solutions are generated using operations such as crossovers and mutations. Crossover involves selecting pairs of individuals as parents and swapping their genetic material to produce new individuals, known as children. Mutation, which is applied to the children individuals after crossover, consists of randomly altering their genome to maintain genetic diversity. In the evaluation phase, the population of individuals is evaluated using the fitness function.

  GE uses a mapping process to generate programs from a genome encoded using a formal grammar, typically in Backus-Naur Form (BNF) notation. This notation consists of terminals, which represent items that can appear in the language, and non-terminals, which are variables that include one or more terminals.



  Nondominated Sorting Genetic Algorithm II (NSGA-II) is a multi-objective optimization algorithm that was proposed in 2002. The algorithm is based on the concept of non-dominance, which means that a solution is considered superior to another solution if it is not worse than the other solution in any objective and strictly better in at least one objective. The goal of NSGA-II is to find a set of non-dominated solutions, known as the Pareto front, which represents the trade-off between the different objectives.

  One of the main features of NSGA-II is its ability to handle constraints. The algorithm handles constraints by assigning a penalty value to solutions that violate the constraints. The penalty value is then used as an additional objective, which is minimized during the optimization process. NSGA-II also includes a crowding distance measure, which is used to preserve diversity among the solutions and avoid premature convergence. The algorithm has been widely used in various fields, including engineering, economics, and biology, and has shown promising results in a variety of multi-objective optimization problems.



  Also known as unary classification, One-Class Classification (OCC) can be viewed as a subclass of unsupervised learning, where the Machine Learning model only learns using training examples from a single class [8, 9]. This type of learning is valuable in diverse real-world scenarios where labeled data is non-existent, infeasible, or difficult (e.g., requiring a costly and slow manual class assignment), such as fraud detection, cybersecurity, predictive maintenance or industrial quality assessment.


  <!--_For more examples, please refer to the [Documentation](https://example.com)_-->

  <!-- CITATION -->


  To cite this work please use the following article:

  ```
  @article{FERREIRA2023110496,
    author = {Luís Ferreira and Paulo Cortez}
    title = {AutoOC: Automated multi-objective design of deep autoencoders and one-class classifiers using grammatical evolution},
    journal = {Applied Soft Computing},
    volume = {144},
    pages = {110496},
    year = {2023},
    issn = {1568-4946},
    doi = {https://doi.org/10.1016/j.asoc.2023.110496},
    url = {https://www.sciencedirect.com/science/article/pii/S1568494623005148}
  }
  ```



  * [Python](https://www.python.org)
  * [PonyGE2](https://github.com/PonyGE/PonyGE2)
  * [TensorFlow](https://www.tensorflow.org/)
  * [Scikit-Learn](https://scikit-learn.org/)

  <!-- ROADMAP -->


  See the [open issues](https://github.com/luisferreira97/AutoOC) for a list of proposed features (and known issues).

  <!-- CONTRIBUTING -->


  Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request

  <!-- LICENSE -->


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

  <!-- CONTACT -->


  Luís Ferreira - [LinkedIn](https://www.linkedin.com/in/luisferreira97/) - luis_ferreira223@hotmail.com

  Project Link: [https://github.com/luisferreira97/AutoOC](https://github.com/luisferreira97/AutoOC)



  <!-- ACKNOWLEDGEMENTS -->

  * [PonyGE2](https://github.com/PonyGE/PonyGE2)





  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/luisferreira97/AutoOC.svg?style=for-the-badge
  [contributors-url]: https://github.com/luisferreira97/AutoOC/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/luisferreira97/AutoOC.svg?style=for-the-badge
  [forks-url]: https://github.com/luisferreira97/AutoOC/network/members
  [stars-shield]: https://img.shields.io/github/stars/luisferreira97/AutoOC.svg?style=for-the-badge
  [stars-url]: https://github.com/luisferreira97/AutoOC/stargazers
  [issues-shield]: https://img.shields.io/github/issues/luisferreira97/AutoOC.svg?style=for-the-badge
  [issues-url]: https://github.com/luisferreira97/AutoOC/issues
  [license-shield]: https://img.shields.io/github/license/luisferreira97/AutoOC.svg?style=for-the-badge
  [license-url]: https://github.com/luisferreira97/AutoOC/blob/master/LICENSE
  [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
  [linkedin-url]: https://www.linkedin.com/in/luisferreira97/
  [product-screenshot]: images/logo.png


pkgId: 7c388925e8525b7c576783ceb40120f2136427845ae52debd08b53451c5a38b4
name: python-autopacmen-Paulocracy
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: The AutoPACMEN package
url: https://github.com/klamt-lab/autopacmen
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopacmen-Paulocracy-0.6.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/autopacmen-Paulocracy.svg)](https://badge.fury.io/py/autopacmen-Paulocracy)






  AutoPACMEN allows one to apply the sMOMENT method of automatically expanding a stoichiometric metabolic
  model with protein allocation constraints (as described in further detail in [Bekiaris & Klamt, 2020](#autopacmens-publication)).

  This repository of AutoPACMEN consists of three source code parts:

  1) The AutoPACMEN Model Generator, implemented as the Python module "autopacmen-Paulocracy" module, which provides a mostly automated way to generate enzyme-constraint-enhanced stoichiometric metabolic models, including an automatic retrieval of k<sub>cat</sub> values. It is primarily dependent on [cobrapy](https://github.com/opencobra/cobrapy).
  <br>→This module can be found in the "autopacmen" subfolder.

  2) An optional mixed Python 3/MATLAB AutoPACMEN Model Calibrator whose MATLAB parts primarily use [CellNetAnalyzer](https://www2.mpi-magdeburg.mpg.de/projects/cna/cna.html) and which allows one to optimize given protein allocation constraints in order to get a better fit with <i>in vivo</i> data.
  <br>→The Python parts can be found in the "autopacmen" subfolder as described in AutoPACMEN's manual,the MATLAB parts can be found in the subfolder "AutoPACMEN_Model_Calibrator_MATLAB".

  3) The exemplary usage of autopacmen-Paulocracy and the Model Calibrator resulting in the enzyme-constraint-enhanced model iJO1366*, as described in Supplementary File 1 of AutoPACMEN's publication. The final iJO1366* model is stored in a ready-to-use SBML form as "./iJO1366star/ec_model_2019_06_25_output_optimization/iJO1366star.xml".
  <br>→The relevant scripts and data can be found in the "iJO1366" subfolder. <b>Note:</b> As it has a huge file size, the obligatory downloaded complete BRENDA text file brenda_downloads.txt (as described in AutoPACMEN's manual) is not included here. Instead, it can be downloaded from BRENDA's web site.



  The combined manual for autopacmen-Paulocracy and the Model Calibrator can be found as "manual.pdf" or LibreOffice-compatible "manual.odt" in the "docs" subfolder folder.
  It explains the manual installation process (without pip, see next chapter for the installation with pip) and usage of AutoPACMEN in detail.

  An additional HTML documentation of the source code of AutoPACMEN's Python modules can be found under the "autopacmen" folder's subfolder "html".
  This HTML documentation was automatically generated using [pdoc3](https://pdoc3.github.io/pdoc/) (link accessed on Oct 30, 2019).
  The HTML documentation's starting point is "index.html" in the "./autopacmen/html/autopacmen" subfolder.

  If you are particularily interested in the generation of k<sub>cat</sub> databases from BRENDA and SABIO-RK, look up
  the scripts "data_parse_brenda_textfile.py", "data_parse_sabio_rk_for_model.py" as well as the combining
  script "data_create_combined_kcat_database.py". These scripts create JSON files with the k<sub>cat</sub> data from these
  databases with EC number, organism and substrate information. An exemplary created database with BRENDA is
  "kcat_database_brenda" in the main folder's  subfolder "./iJO1366star/ec_model_2019_06_25_output", a database with SABIO-RK is
  "kcat_database_sabio_rk" in the same subfolder.




  You can install autopacmen-Paulocracy [from PyPI](https://pypi.org/project/autopacmen-Paulocracy/) using pip as follows:
  <pre>
  pip install autopacmen-Paulocracy
  </pre>

  autopacmen-Paulocracy requires Python >=3.7 for its Python parts, and MATLAB >=2017a for its optional Model Calibrator
  MATLAB scripts.




  All relevant scripts of autopacmen-Paulocracy are in the "autopacmen" main folder.

  In this main folder, the scripts which start with "analysis_", "data_" and "modeling_" are command-line interfaces (CLI)
  for AutoPACMEN's Python modules. These Python modules can be found the main folder's "submodules" subfolder.

  The subfolder "AutoPACMEN_Model_Calibrator_MATLAB" contains the Model Calibrator's MATLAB parts.

  All scripts and folders within "iJO1366star" are part of the generation and analysis of iJO1366* (see AutoPACMEN's publication for more about it). From these scripts, these ones
  starting with "./iJO1366star/ec_model_2019_06_25_figure" create either a full figure or data for a figure used in AutoPACMEN's publication.

  The main script for the generation of the uncalibrated iJO1366* model is "./iJO1366star/ec_model_2019_06_25_sMOMENT_iJO_CREATION.py" in the "iJO1366" subfolder. This
  main script uses AutoPACMEN's functionalities as Python modules. The commented steps in this script correspond to the steps described in supplementary
  File 1 of (Bekiaris & Klamt, in submission).

  The "iJO1366star" folder's subfolder "iJOstar_MCS_analysis_scripts" contains the scripts used for the computation and the analysis of the published Minimal Cut Set enumeration
  with iJO1366 and iJO1366*.

  AutoPACMEN creates a cache of SABIO-RK, NCBI TAXONOMY and UniProt data in the "_cache" main folder's subfolder.  In the current state, the cache is the one
  from AutoPACMEN's run for iJO1366* around the 25th of June 2019.




  * Bekiaris, P.S., Klamt, S. Automatic construction of metabolic models with enzyme constraints. <i>BMC Bioinformatics</i> <b>21</b>, 19 (2020). [https://doi.org/10.1186/s12859-019-3329-9](https://doi.org/10.1186/s12859-019-3329-9)



  This project is free and open-source, using the Apache License Version 2.0.




  External sources which are included in this package are given in the respective SOURCES.txt files.


pkgId: 275f34980d4df8681ce3b3eb645bf07c45c79742d92f0bcd761589ca5b848332
name: python-autopage
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: A library to provide automatic paging for console output
url: https://github.com/zaneb/autopage
rpm_license: OSI Approved
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopage-0.5.2-1.src.rpm
checksum_type: sha256
description:
  [Autopage](https://github.com/zaneb/autopage) is a Python library to
  automatically display terminal output from a program in a pager (like `less`)
  whenever you need it, and never when you don't. And it only takes one line of
  code.

  You know how some CLI programs like `git` (and a handful of others, including
  `man` and `systemctl`) automatically pipe their output to `less`? Except not if
  there's less than one screen's worth of data. And if you redirect the output to
  a file or a pipe, it does the right thing instead. Colours are preserved. Don't
  you wish all programs worked like that? Now at least all of your Python
  programs can.



  © 2020-2022 by Zane Bitter

  Open Source licensed under the terms of the Apache Software License, version
  2.0.



  [Autopage is available from PyPI](https://pypi.org/project/autopage/). The
  easiest way to install (preferably in a `virtualenv` virtual environment) is
  with `pip`:

      $ pip install autopage



  Autopage is [packaged for
  Fedora](https://packages.fedoraproject.org/pkgs/python-autopage/python3-autopage/)
  35 and later. To install:

      

  Copr repositories are available for older versions of Fedora and EPEL. Before
  attempting to install on those versions, first enable the copr repository:

      



  Autopage is [packaged for
  Ubuntu](https://packages.ubuntu.com/search?keywords=python3-autopage&searchon=names)
  jammy and later, and [for Debian](https://packages.debian.org/python3-autopage)
  bookworm. To install:

      

  A PPA is available for older versions of Ubuntu. Before attempting to install
  on those versions, first enable the PPA:

      
      



  Autopage is [packaged for
  Gentoo](https://packages.gentoo.org/packages/dev-python/autopage). To install:

      



  The `AutoPager` class provides a context manager that furnishes the output
  stream to write to. Here is a basic example that reads from stdin and outputs
  to a pager connected to stdout:

  ```python
  import sys
  import autopage

  with autopage.AutoPager() as out:
      for l in sys.stdin:
          out.write(l)
  ```

  If you are explicitly passing a stream to write to (rather than directly
  referencing a global variable such as `sys.stdout` then you may be able to add
  automatic paging support with only a single line of code.



  If your program uses the `argparse` module from the standard library, you can
  ensure that the help output is automatically paged when possible by changing
  the import statement to:

  ```python
  from autopage import argparse
  ```

  If you don't control the module that imports `argparse`, you can instead call
  `autopage.argparse.monkey_patch()` to patch the module directly. This function
  can also be used as a context manager.



  The default pager command (`autopage.command.DefaultPager()`) allows the end
  user to override the pager command by setting the `PAGER` environment variable.
  To disable this behaviour, pass
  `pager_command=autopage.command.PlatformPager()` to use the default pager for
  the current platform, or pass a specific pager from `autopage.command`. The
  default pager command is `less` on most platforms. On AIX the default pager
  command is `more`, and on Windows `more.com`.

  The end user can also override the settings for `less` by setting the `LESS`
  environment variable. If not specified, the settings are determined by the
  `allow_color` and `line_buffering` options. By default ANSI control characters
  for setting colours are respected and the pager will not run if there is less
  than a full screen of text to display.



  Normally output streams are buffered so that data is written to the output file
  only when the buffer becomes full. This is efficient and generally works fine
  as long as the data is being produced as fast as it can be consumed. However,
  when the data is streaming at a slower rate than it could be displayed (e.g.
  log output from something like `tail -f`) this results in a large delay between
  data being produced and consumed. If you have ever tried to grep a streaming
  log and pipe the output to a pager then you are familiar with how
  unsatisfactory this is.

  The solution is to flush the output buffer after each line is written, which is
  known as [line
  buffering](https://www.pixelbeat.org/programming/stdio_buffering/). The
  `AutoPager` class supports a `line_buffering` argument to enable or disable
  line buffering. The default is to use the line buffering mode already
  configured for the output stream (which is usually to disable line buffering).

  When reading from an input stream (which may be a file, pipe, or the console)
  and optionally processing the data before outputting it again, the convenience
  function `line_buffer_from_input()` returns the optimal line buffering setting
  for a given input stream (`sys.stdin` by default).

  ```python
  import sys
  import autopage

  with autopage.AutoPager(line_buffering=autopage.line_buffer_from_input()) as o:
      for l in sys.stdin:
          o.write(l)
  ```



  By default, when the pager exits it will leave the latest displayed output on
  screen in the terminal. This can be changed by passing `True` for the
  `reset_on_exit` argument to the `AutoPager` class. If this option is set, the
  terminal will be cleared when the pager exits, returning to its position prior
  to starting the pager (as is the case by default when running `less` manually
  from the command line).



  Programs may wish to return a different exit code if they are interrupted by
  the user (either with Ctrl-C or by closing the pager) than if they ran to
  completion. The exceptions generated when the pager is closed prematurely are
  suppressed, so the `AutoPager` class offers the `exit_code()` method to provide
  a suitable exit code for the program. This also takes into account other
  exceptions that bubble up through the context manager.



  ```python
  import sys
  import autopage

  def process(input_stream, output_stream):
      pager = autopage.AutoPager(
          output_stream,
          line_buffering=autopage.line_buffer_from_input(input_stream),
          allow_color=True,
          reset_on_exit=True,
          errors=autopage.ErrorStrategy.REPLACE,
      )

      try:
          with pager as out:
              for l in input_stream:
                  out.write(l)
      except Exception as exc:
          sys.stderr.write(f'{str(exc)}\n')
      except KeyboardInterrupt:
          pass
      return pager.exit_code()

  sys.exit(process(sys.stdin, sys.stdout))
  ```


