# packages

pkgId: 02c520646336539477f9c6fb4bc0f069229810bd4a7ef21a6275a375b0ef3f0c
name: python-authx
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Ready to use and customizable Authentications and Oauth2 management for FastAPI
url: https://github.com/yezz123/authx
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-authx-1.4.0-1.src.rpm
checksum_type: sha256
description:
  | Project | Status                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
  |---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | CI      | [ ![ CI ]( https://github.com/yezz123/authx/actions/workflows/ci.yml/badge.svg ) ]( https://github.com/yezz123/authx/actions/workflows/ci.yml )  [ ![ pre-commit.ci status ]( https://results.pre-commit.ci/badge/github/yezz123/authx/main.svg )   ]( https://results.pre-commit.ci/latest/github/yezz123/authx/main )  [ ![ Codecov ]( https://codecov.io/gh/yezz123/authx/branch/main/graph/badge.svg )   ]( https://codecov.io/gh/yezz123/authx ) |


pkgId: b90af1bf43a96c65aea0dea60df0f21f76a725daf088564c65415750f7984117
name: python-authy
arch: src
version: 2.2.6
epoch: 0
release: 1
summary: Authy API Client
url: http://github.com/authy/authy-python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-authy-2.2.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/authy.svg)](https://pypi.org/project/authy/) [![Build Status](https://travis-ci.org/twilio/authy-python.svg?branch=master)](https://travis-ci.org/authy/authy-python)



  Documentation for Python usage of the Authy API lives in the [official Twilio documentation](https://www.twilio.com/docs/authy/api/).

  The Authy API supports multiple channels of 2FA:
  * One-time passwords via SMS and voice.
  * Soft token ([TOTP](https://www.twilio.com/docs/glossary/totp) via the Authy App)
  * Push authentication via the Authy App

  If you only need SMS and Voice support for one-time passwords, we recommend using the [Twilio Verify API](https://www.twilio.com/docs/verify/api) instead.

  [More on how to choose between Authy and Verify here.](https://www.twilio.com/docs/verify/authy-vs-verify)



  For a full tutorial, check out either of the Python Authy Quickstarts in our docs:
  * [Python/Django Authy Quickstart](https://www.twilio.com/docs/authy/quickstart/two-factor-authentication-python-django)
  * [Python/Flask Authy Quickstart](https://www.twilio.com/docs/authy/quickstart/two-factor-authentication-python-flask)



  Install with [pip](https://www.twilio.com/docs/usage/quickstart/devenvironment-python#how-to-install-pip):

      $ pip install authy

  **OR**

  Download the [source code](https://github.com/twilio/authy-python/archive/master.zip) and run the following command from your terminal:

      $ python setup.py install

  _Note that you may need admin permissions to run the above commands._



  To use the Authy client, import AuthyApiClient and initialize it with your production API Key found in the [Twilio Console](https://www.twilio.com/console/authy/applications/):

  ```python
  from authy.api import AuthyApiClient
  authy_api = AuthyApiClient('your_api_key')
  ```

  ![authy api key in console](https://s3.amazonaws.com/com.twilio.prod.twilio-docs/images/account-security-api-key.width-800.png)



  1. [Create a user](https://www.twilio.com/docs/authy/api/users#enabling-new-user)
  2. [Send a one-time password](https://www.twilio.com/docs/authy/api/one-time-passwords)
  3. [Verify a one-time password](https://www.twilio.com/docs/authy/api/one-time-passwords#verify-a-one-time-password)

  **OR**

  1. [Create a user](https://www.twilio.com/docs/authy/api/users#enabling-new-user)
  2. [Send a push authentication](https://www.twilio.com/docs/authy/api/push-authentications)
  3. [Check a push authentication status](https://www.twilio.com/docs/authy/api/push-authentications#check-approval-request-status)




  [Phone verification now lives in the Twilio API](https://www.twilio.com/docs/verify/api) and has [Python support through the official Twilio helper libraries](https://www.twilio.com/docs/libraries/python).

  [Legacy (V1) documentation here.](verify-legacy-v1.md) **Verify V1 is not recommended for new development. Please consider using [Verify V2](https://www.twilio.com/docs/verify/api)**.



  Install development dependencies with pip:

      sudo pip install -r requirements.txt

  To run tests:

      make test
  or

      make testfile tests/<test_case_file>



  Copyright (c) 2011-2020 Authy Inc. See [LICENSE](https://github.com/twilio/authy-python/blob/master/LICENSE) for further details.


pkgId: 50ee4797db2b383a6c68d506fd0ad3174fa720dab169196a67c7b47b71616626
name: python-authzed
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Client library for SpiceDB.
url: https://pypi.org/project/authzed/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-authzed-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/authzed?color=%23006dad)](https://pypi.org/project/authzed)
  [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0.html)
  [![Build Status](https://github.com/authzed/authzed-py/workflows/Test/badge.svg)](https://github.com/authzed/authzed-py/actions)
  [![Mailing List](https://img.shields.io/badge/email-google%20groups-4285F4)](https://groups.google.com/g/authzed-oss)
  [![Discord Server](https://img.shields.io/discord/844600078504951838?color=7289da&logo=discord "Discord Server")](https://discord.gg/jTysUaxXzM)
  [![Twitter](https://img.shields.io/twitter/follow/authzed?color=%23179CF0&logo=twitter&style=flat-square)](https://twitter.com/authzed)

  This repository houses the Python client library for Authzed.

  [Authzed] is a database and service that stores, computes, and validates your application's permissions.

  Developers create a schema that models their permissions requirements and use a client library, such as this one, to apply the schema to the database, insert data into the database, and query the data to efficiently check permissions in their applications.

  Supported client API versions:

  - [v1](https://docs.authzed.com/reference/api#authzedapiv1)

  You can find more info on each API on the [Authzed API reference documentation].
  Additionally, Protobuf API documentation can be found on the [Buf Registry Authzed API repository].

  See [CONTRIBUTING.md] for instructions on how to contribute and perform common tasks like building the project and running tests.

  [Authzed]: https://authzed.com
  [Authzed API Reference documentation]: https://docs.authzed.com/reference/api
  [Buf Registry Authzed API repository]: https://buf.build/authzed/api/docs/main
  [CONTRIBUTING.md]: CONTRIBUTING.md



  We highly recommend following the **[Protecting Your First App]** guide to learn the latest best practice to integrate an application with Authzed.

  If you're interested in examples of a specific version of the API, they can be found in their respective folders in the [examples directory].

  [Protecting Your First App]: https://docs.authzed.com/guides/first-app
  [examples directory]: /examples





  This project is packaged as the wheel `authzed` on the [Python Package Index].

  If you are using [pip], the command to install the library is:

  ```sh
  pip install authzed
  ```

  [Python Package Index]: https://pypi.org/project/authzed
  [pip]: https://pip.pypa.io



  With the exception of [gRPC] utility functions found in `grpcutil`, everything required to connect and make API calls is located in a module respective to API version.

  In order to successfully connect, you will have to provide a [Bearer Token] with your own API Token from the [Authzed dashboard] in place of `t_your_token_here_1234567deadbeef` in the following example:

  [grpc]: https://grpc.io
  [Bearer Token]: https://datatracker.ietf.org/doc/html/rfc6750#section-2.1
  [Authzed Dashboard]: https://app.authzed.com

  ```py
  from authzed.api.v1 import Client
  from grpcutil import bearer_token_credentials


  client = Client(
      "grpc.authzed.com:443",
      bearer_token_credentials("t_your_token_here_1234567deadbeef"),
  )
  ```



  ```py
  from authzed.api.v1 import (
      CheckPermissionRequest,
      CheckPermissionResponse,
      ObjectReference,
      SubjectReference,
  )


  post_one = ObjectReference(object_type="blog/post", object_id="1")
  emilia = SubjectReference(object=ObjectReference(
      object_type="blog/user",
      object_id="emilia",
  ))


  resp = client.CheckPermission(CheckPermissionRequest(
      resource=post_one,
      permission="reader",
      subject=emilia,
  ))
  assert resp.permissionship == CheckPermissionResponse.PERMISSIONSHIP_HAS_PERMISSION
  ```


  When running in a context like `docker compose`, because of Docker's virtual networking,
  the gRPC client sees the SpiceDB container as "remote." It has built-in safeguards to prevent
  calling a remote client in an insecure manner, such as using client credentials without TLS.

  However, this is a pain when setting up a development or testing environment, so we provide
  the `InsecureClient` as a convenience:

  ```py
  from authzed.api.v1 import Client
  from grpcutil import bearer_token_credentials

  client = Client(
      "spicedb:50051",
      "my super secret token"
  )
  ```


pkgId: c7533768605b99be64cad7b3b5e52354acfe4649e5824cdf4d10bc4e08f48dfa
name: python-autisto
arch: src
version: 1.1.1
epoch: 0
release: 1
url: https://pypi.org/project/autisto/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autisto-1.1.1-1.src.rpm
checksum_type: sha256
summary:
  Basic accounting (?) program integrated with Google Sheets to fulfill my own autistic needs of tracking the shit owned.

description:
  ![GH Actions](https://github.com/jan-grzybek/autisto/actions/workflows/python-package.yml/badge.svg)

  ```
  wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc |  gpg --dearmor | sudo tee /usr/share/keyrings/mongodb.gpg > /dev/null
  echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
  sudo apt update
  sudo apt install mongodb-org
  sudo systemctl enable mongod
  sudo systemctl start mongod


  sudo pip3 install autisto
  sudo autisto  # follow further CLI instructions
  ```
  IMPORTANT: After successful setup, consider setting up the back-up routine according to the instructions under /back_up .


pkgId: ab4f6451f2a10bc040d3495f85414edf7c755bfd945040ee4f5818ab17ce9d1b
name: python-auto-abi-checker
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Tool to facilitate the run of abi-compliance-checker
url: https://github.com/osrf/auto-abi-checker
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-abi-checker-0.1.14-1.src.rpm
checksum_type: sha256
description:
  Tool designed to facilitate the run the great ABI compliance checker by supporting easy inputs and no configuration files


pkgId: 6737dfd05fa742f914c2462be824886f360b6d1bff2f75678d7f381692d2606d
name: python-auto-archiver
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: Easily archive online media content
url: https://pypi.org/project/auto-archiver/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-archiver-0.12.0-1.src.rpm
checksum_type: sha256
description:
  Use `python -m src.auto_archiver --config secrets/orchestration.yaml` to run from the local development environment.

  working with docker locally:
    * `docker build . -t auto-archiver` to build a local image
    * `docker run --rm -v $PWD/secrets:/app/secrets auto-archiver  --config secrets/orchestration.yaml`
      * to use local archive, also create a volume `-v` for it by adding `-v $PWD/local_archive:/app/local_archive`
  manual release to docker hub
    * `docker image tag auto-archiver bellingcat/auto-archiver:latest`
    * `docker push bellingcat/auto-archiver`

  * update version in [version.py](src/auto_archiver/version.py)
  * go to github releases > new release > use `vx.y.z` for matching version notation
    * package is automatically updated in pypi
    * docker image is automatically pushed to dockerhup


pkgId: 97caf037538968e638b7b58f1e1907f511c42d1bab624f1798788b5ff5cb38f8
name: python-auto-changelog
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Simple tool to generate nice, formatted changelogs from vcs
url: https://github.com/Michael-F-Bryan/auto-changelog
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-changelog-0.6.0-1.src.rpm
checksum_type: sha256
description:
  |actions| |ci| |pypi| |version| |licence| |black|
  A quick script that will generate a changelog for any git repository using `conventional style`_ commit messages.


pkgId: 12211aa093ac6d88b63e7454093432aa31ceb794503a66c2c718b44fdfc9c2eb
name: python-auto-circuit
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/auto-circuit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-circuit-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/auto-circuit?logo=pypi&logoColor=white)](https://pypi.org/project/auto-circuit/)
  [![GitHub Release](https://img.shields.io/github/v/release/UFO-101/auto-circuit?logo=github&logoColor=white)](https://github.com/UFO-101/auto-circuit/releases)

  ![](docs/assets/Edge_Patching_Rounded.png)

  A library for efficient patching and automatic circuit discovery.

  [![Static Badge](https://img.shields.io/badge/Read%20the%20Docs-414A82?style=for-the-badge&logo=Google%20Docs&logoColor=white&labelColor=CB5AD9)](https://UFO-101.github.io/auto-circuit)


  [Transformer Circuit Metrics are not Robust](Transformer%20Circuit%20Metrics%20are%20not%20Robust.pdf)



  ```bash
  pip install auto-circuit
  ```


  https://github.com/UFO-101/auto-circuit/blob/03ce552ccdea98fc6fed3b05cfb2df9b0eb4e323/experiments/demos/zero_ablate_an_edge.py#L20-L26


  https://github.com/UFO-101/auto-circuit/blob/03ce552ccdea98fc6fed3b05cfb2df9b0eb4e323/experiments/demos/patch_an_edge.py#L37


  https://github.com/UFO-101/auto-circuit/blob/03ce552ccdea98fc6fed3b05cfb2df9b0eb4e323/experiments/demos/patch_an_edge.py#L49-L55


  https://github.com/UFO-101/auto-circuit/blob/5777057b445d55b7d4695eed8aface9d6bcefbe3/experiments/demos/patch_some_edges.py#L49
  ![](docs/assets/Small_Circuit_Viz.png)


pkgId: 386508aa1130d149cc20383bef508a2eb80600fbc5f5c07f03179755cfd62d60
name: python-auto-click-auto
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Automatically enable tab autocompletion for shells in Click CLI applications.
url: https://github.com/KAUTH/auto-click-auto
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-click-auto-0.1.5-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/auto-click-auto)
  [![Functional Tests](https://github.com/KAUTH/auto-click-auto/workflows/Functional%20tests/badge.svg)](https://github.com/KAUTH/auto-click-auto/actions/workflows/functional-tests.yml?query=workflow%3A%22Functional+tests%22)
  [![pypi](https://img.shields.io/pypi/v/auto-click-auto.svg)](https://pypi.python.org/pypi/auto-click-auto)
  [![GitHub license](https://img.shields.io/github/license/KAUTH/auto-click-auto)](https://github.com/KAUTH/auto-click-auto/blob/master/LICENSE)


  Automatically enable tab autocompletion for shells in Click CLI applications.

  `auto-click-auto` is a small Python library that is used to quickly and easily add tab shell completion support for
  _Bash_ (version 4.4 and up), _Zsh_, and _Fish_, for [Click](https://click.palletsprojects.com/en/8.1.x/#) CLI programs.


  ```commandline
  pip install auto-click-auto
  ```


  There are two functions that `auto-click-auto` makes available: `enable_click_shell_completion` (general use)
  and `enable_click_shell_completion_option` (to be used as a decorator).

  In the function docstrings, you can find a detailed analysis of the available parameters and their use.

  `auto-click-auto` will print the relative output when a shell completion is activated for the first time and can be
  set to an extra verbosity if you want to display information about already configured systems or debug.

  Here are some typical ways to enable autocompletion with `auto-click-auto`:

  1) **Check on every run of the CLI program if autocompletion is configured and enable it in case that it is not**

  This way you can seamlessly enable shell autocompletion without the user having to run any extra commands.

  Example:
  ```python
  import click

  from auto_click_auto import enable_click_shell_completion
  from auto_click_auto.constants import ShellType


  @click.command()
  @click.option('--count', default=1, help='Number of greetings.')
  @click.option('--name', prompt='Your name', help='The person to greet.')
  def hello(count, name):
      """Simple program that greets NAME for a total of COUNT times."""
      for x in range(count):
          click.echo(f"Hello {name}!")

      enable_click_shell_completion(
          program_name="example-1", shells={ShellType.BASH, ShellType.FISH},
      )
  ```

  2) **Make shell completion a Click command option**

  Example:
  ```python
  import click

  from auto_click_auto import enable_click_shell_completion_option


  @click.command()
  @enable_click_shell_completion_option(program_name="example-2")
  @click.option('--count', default=1, help='Number of greetings.')
  @click.option('--name', prompt='Your name', help='The person to greet.')
  def hello(count, name):
      """Simple program that greets NAME for a total of COUNT times."""
      for x in range(count):
          click.echo(f"Hello {name}!")
  ```

  3) **Make shell completion a command (or subcommand of a group)**

  This implementation option might be useful if you already have a "configuration" command in your CLI program.

  Example:
  ```python
  import click

  from auto_click_auto import enable_click_shell_completion
  from auto_click_auto.constants import ShellType


  @click.group()
  def cli():
      """Simple CLI program."""
      pass


  @cli.command()
  @click.option('--count', default=1, help='Number of greetings.')
  @click.option('--name', prompt='Your name', help='The person to greet.')
  def hello(count, name):
      """Simple command that greets NAME for a total of COUNT times."""
      for x in range(count):
          click.echo(f"Hello {name}!")


  @cli.group()
  def config():
      """Program configuration."""
      pass


  @config.command()
  def shell_completion():
      """Activate shell completion for this program."""
      enable_click_shell_completion(
          program_name="example-3",
          shells={ShellType.BASH, ShellType.FISH, ShellType.ZSH},
          verbose=True,
      )
  ```


  To run the examples, fork this repository and follow the instructions at
  https://github.com/KAUTH/auto-click-auto/tree/main/examples.


  `auto-click-auto` enables tab autocompletion based on [Click's documentation](https://click.palletsprojects.com/en/8.1.x/shell-completion/).


  `auto-click-auto`, as the name suggests, _auto_matically provides tab _auto_completion support for _Click_ CLI
  applications.


  In the search for other tools that enable shell completion for Click we come across a lot of repositories with example
  code or gists. This adds a bit of complexity to adapting the code and adding it to our use case quickly.

  A very nice tool is [`click-completion`](https://github.com/click-contrib/click-completion), which provides enhanced
  completion for Click. `click-completion`:
  - Adds automatic completion support for fish, Zsh, Bash and PowerShell
  - Currently, has one extra dependency, in addition to Click
  - Can customize the completion

  However, it is important to note that this repository could be duplicating currently integrated Click functionality and
  might need to be archived. You can monitor the issue
  [here](https://github.com/click-contrib/click-completion/issues/41).

  In summary, `auto-click-auto`:
  - Has one specific purpose, it "automatically" enables shell completion for Click programs
  - Does not have any 3rd party dependencies, besides Click
  - Provides an option for seamless enabling of the shell completion
  - Comes ready with ways to add shell completion as a command option or subcommand
  - Has simple examples of how to quickly use the library


  https://github.com/KAUTH/auto-click-auto/blob/main/CHANGELOG.md


  You can always submit a PR if you want to suggest improvements or fix issues.
  Check out the open issues at https://github.com/KAUTH/auto-click-auto/issues.


pkgId: 77f102d9019807cb882343e10b4622cb240c4b38794c2fbd01fd260f7ae4f03f
name: python-auto-cmake
arch: src
version: 2024.5.1
epoch: 0
release: 1
summary: Automate setup of CMake projects
url: https://github.com/a22agarw/auto-cmake.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-cmake-2024.5.1-1.src.rpm
checksum_type: sha256
description:
  <h2> Auto CMake </h2>

  Automate setup of CMake projects for large C & C++ projects on all platforms: Windows, MacOS, Linux, Android, iOS and Bare-Metal<br>
  - Automatically indexes .c, .h, .cpp, .hpp files and creates entries in CMakeLists.txt
  - Automatically generates CMakeLists.txt for subdirectories and create library entries in CMakeLists.txt
  - Automatically configures XCode projects with header, source and library paths
  - Automatically configures Android projects with header, source and library paths

  <h2> Contents </h2>

  ```
  1) auto_cmake......................Source
     1.1) resources..................CMake Toolchain Files
  2) scripts ........................Deployment Scripts
  3) tests...........................Unit Tests for Windows, MacOS, Linux, Android, iOS and Bare-Metal
     3.1) resources .................Sample
        3.1.1) sample_c_proj.........Generic Project to Validate Compilation on PC via Unit Tests
        3.1.2) sample_android_proj...Project to Validate Compilation on Android via Unit Tests
        3.1.3) sample_xcode_proj.....Project to Validate Compilation on iOS via Unit Tests
  ```

  <h2> Sample Usage </h2>

  Steps:

  1) Download auto-cmake from: https://pypi.org/project/auto-cmake/
  2) In your project define a auto cmake script (sample below)
  3) This file defines (among other things):
     1) The project name and version
     2) Directories and paths to include and exclude
     3) Compiler flags
     4) Build directory
  4) Run the script to generate the CMake project

  ```
  import os
  import unittest

  from auto_cmake.auto_cmake_exe import AutoCMakeExe


  proj_dir = os.path.abspath(os.path.join(os.getcwd(), "resources", "sample_c_proj"))
  build_dir = os.path.abspath(os.path.join(proj_dir, "build"))


  cmake_config = dict()
  cmake_config['proj_name'] = 'sample_c_proj'
  cmake_config['proj_dir'] = proj_dir
  cmake_config['version'] = "2024.03.08"
  cmake_config['cmake_version'] = '3.15'
  cmake_config['include_dirs'] = [proj_dir]
  cmake_config['libs'] = []
  cmake_config['flags'] = ["FLAG_DEMO"]
  cmake_config['exclude_dirs'] = []
  cmake_config['exclude_paths'] = []
  cmake_config['build_dir'] = build_dir

  ac = AutoCMakeExe(**cmake_config)
  ac.run()
  ```


pkgId: a3f290a6c5790b7963f001360207de243c35ad770763bfa51e46c67a63a892c1
name: python-auto-code-review
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Auto-code-review for GitHub Pull Requests via ChatGPT
url: https://github.com/yosuke-yuikimatsu/auto-code-review
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-code-review-0.1.3-1.src.rpm
checksum_type: sha256
description:
  This repository uses GitHub Actions for automatic code review on every Pull Request. The code review process is powered by the **auto-code-review** library, which connects to the OpenAI API to generate inline comments and suggestions for code improvements.



  Below is the configuration for the GitHub Actions workflow:

  ```yaml
  name: Auto Code Review

  on:
    pull_request:
      types:  [opened, synchronize, reopened]
      branches:
        - '*'

  jobs:
    review:
      runs-on: ubuntu-latest

      permissions:
        contents: write
        pull-requests: write

      steps:
        - name: Checkout repository
          uses: actions/checkout@v3

        - name: Set up Python
          uses: actions/setup-python@v4
          with:
            python-version: "3.12"

        - name: Install auto-code-review
          run: pip install auto-code-review

        - name: Run auto code review
          env:
            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
            OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
            GITHUB_HEAD_REF: ${{ github.head_ref }}
            GITHUB_BASE_REF: ${{ github.base_ref }}
            REPO_OWNER: ${{ github.repository_owner }}
            REPO_NAME: ${{ github.event.repository.name }}
            PULL_NUMBER: ${{ github.event.number }}
          run: python -m auto_code_review.cli --config config.yaml
  ```



  1. **Trigger on `pull_request`:** The workflow is triggered when a Pull Request is created, updated, or reopened.
  2. **Set Up Python Environment:** The workflow sets up Python version `3.12` and installs the `auto-code-review` package from PyPI.
  3. **Run Auto Code Review:** The `auto_code_review.cli` command is executed to analyze the changes in the Pull Request using OpenAIвЂ™s API. The tool will leave inline comments on the code changes with  potential issues.



  Before using this workflow, you need to add the following secrets to your repository settings:

  - **`GITHUB_TOKEN`**: A GitHub token automatically provided in your repository (no extra setup needed).
  - **`OPENAI_API_KEY`**: Your OpenAI API key, which must be added manually in `Settings` -> `Secrets and variables` -> `Actions` -> `New repository secret`.



  To enable automatic code review, simply create a Pull Request from any branch in your repository. GitHub Actions will automatically trigger the analysis, and inline comments will be added directly to the Pull Request with feedback on code style, potential optimizations, and any detected issues.



  - This workflow supports any branch (`branches: ['*']`), meaning it will run for Pull Requests involving any source or target branch.
  - The tool is configured via a `config.yaml` file, which should be present in the root directory of your repository. This file allows you to specify various settings such as the AI model, temperature and file extensions



  ```yaml


  analysis:
    file_extensions: [".py", ".cpp",".yaml"]

  ai_settings:
    ai_model: gpt-4o-mini
    temperature: 0.7
    max_tokens: 1000
  ```

  In this configuration:
  - **`ai_model`** sets the chatgpt model which will be used to create comments(gpt-4o-mini by default)
  - **`file_extensions`** sets the extensions of files which will be auto-reviewed(Necessary to write extensions)
  - **`temperature`** controls the randomness of the suggestions - higher values make responses more creative(0.7 by default).
  - **`max_tokens`** limits the number of tokens generated by the AI.(1000 by default)
  - **`code_style`** specifies the coding style to follow (the most basic code styles by default).



  If the workflow fails with a `422 Unprocessable Entity` error, it could be due to:
  - An incorrect `position` value for inline comments.
  - An invalid or outdated `commit_id`.
  - Missing or incorrect `path` for the file being commented on.

  Ensure that your configuration and API keys are set up correctly, and check the logs in GitHub Actions for more details.


pkgId: beac6efb63e6aebeabe798455ea64f83f4eccae8da3c42b23101a1b723c314c7
name: python-auto-coder
arch: src
version: 0.1.182
epoch: 0
release: 1
summary: AutoCoder: AutoCoder
url: https://pypi.org/project/auto-coder/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-coder-0.1.182-1.src.rpm
checksum_type: sha256
description:
  *Latest News* 🔥
  - [2024/09] Release Auto-Coder 0.1.163
  - [2024/08] Release Auto-Coder 0.1.143
  - [2024/07] Release Auto-Coder 0.1.115
  - [2024/06] Release Auto-Coder 0.1.82
  - [2024/05] Release Auto-Coder 0.1.73
  - [2024/04] Release Auto-Coder 0.1.46
  - [2024/03] Release Auto-Coder 0.1.25


pkgId: 8292d94927d863c0667ea9761e040db0efcae7cf2f8762153e35d695d1aa17b7
name: python-auto-coder-chat-lite
arch: src
version: 0.1.13
epoch: 0
release: 1
summary: a simple code chat tool inspired by auto coder
url: https://pypi.org/project/auto-coder-chat-lite/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-coder-chat-lite-0.1.13-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/auto-coder-chat-lite.svg)](https://pypi.org/project/auto-coder-chat-lite/)

  A lightweight AI code generation tool.

  [English](./README.md) | [中文](./readme-cn.md)



  `auto-coder-chat-lite` is a lightweight tool designed to facilitate code chat and project scaffolding. It provides a command-line interface for interacting with the project, allowing users to add, remove, and list files, as well as request AI-based code modifications.



  To install `auto-coder-chat-lite`, you need to have Python 3.6 or higher installed. Then, you can install the package using pip:

  ```bash
  pip install auto-coder-chat-lite
  ```



  After installation, you can run the tool using the following commands:



  ```bash
  chat.code
  ```

  This command starts the interactive command-line interface for code chat and project scaffolding. You can use the following commands within this interface:

  - `/add_files <file1> <file2> ...` - Add files to the current session.
  - `/remove_files <file1> <file2> ...` - Remove files from the current session.
  - `/list_files` - List all active files in the current session.
  - `/coding <query>` - Request the AI to modify code based on requirements.
  - `/exclude_dirs <dir1> <dir2> ...` - Exclude directories from file searches.
  - `/conf [<key> [<value>]]` - View or set configuration options.
  - `/commit_message` - Generate a commit message based on Git diff.
  - `/help` - Show this help message.
  - `/exit` - Exit the program.



  ```bash
  chat.agent
  ```

  This command is used to interact with the OpenAI API for chat completions. It requires the OpenAI API key and model configuration. You can set up the configuration using the following command:

  ```bash
  chat.agent setup --api_key YOUR_API_KEY --base_url https://api.openai.com/v1 --model gpt-3.5-turbo
  ```

  To test the configuration, you can use:

  ```bash
  chat.agent test
  ```



  ```bash
  chat.prompt
  ```

  This command is used to render a template using Jinja2. It requires two arguments:

  - `template_path`: Path to the template file.
  - `text_path`: Path to the text file to be used as content.

  Optionally, you can specify an output file path using the `-o` or `--output_path` flag (default is `output.txt`).

  Example usage:

  ```bash
  chat.prompt path/to/template.txt path/to/content.txt -o path/to/output.txt
  ```

  This command will render the template with the provided content, save the result to the specified output file, and copy the rendered content to the clipboard.



  The project relies on the following Python packages:

  - `colorama==0.4.6`
  - `pathspec==0.12.1`
  - `prompt_toolkit==3.0.47`
  - `pydantic==2.8.2`
  - `Pygments==2.18.0`
  - `pyperclip==1.9.0`
  - `rich==13.7.1`
  - `GitPython==3.1.43`
  - `Jinja2==3.1.4`
  - `pylint==3.2.7`
  - `openai==1.44.1`

  These dependencies are automatically installed when you install `auto-coder-chat-lite` using pip.



  Contributions are welcome! Please feel free to submit a pull request or open an issue on the [GitHub repository](https://github.com/zt8989/auto-coder-chat-lite).



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



  For any questions or feedback, please contact the author at [251027705@qq.com](mailto:251027705@qq.com).


pkgId: 04fb7132b25c8a14341dec947e2dee2eeff1934b079bffe7b47e3dd605d09394
name: python-auto-coder-web
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: auto-coder.web: A Python Project
url: https://pypi.org/project/auto-coder-web/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-coder-web-0.1.1-1.src.rpm
checksum_type: sha256
description:
  ```
  pip install auto_coder_web
  ```



  ```
  cd <project_dir>
  auto-coder.web
  ```



  http://localhost:8007

  开始你的编程！


pkgId: b6638378c663c399bf5e41c2f287ec4fe585cacfc58e90fa3b0f0b57715afd4d
name: python-auto-coder-web
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: auto-coder.web: A Python Project
url: https://pypi.org/project/auto-coder-web/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-coder-web-0.1.8-1.src.rpm
checksum_type: sha256
description:
  ```
  pip install auto_coder_web
  ```



  ```
  cd <project_dir>
  auto-coder.web
  ```



  http://localhost:8007

  开始你的编程！


  > 使用 docker 时，需要你的项目已经是一个被 auto-coder.chat 初始化过的项目。
  > 或者启动后，在界面 Terminal 中执行 `auto-coder init --source_dir .` 初始化项目。


  ```shell
  docker run  \
    --name auto-coder-web \
    -e BASE_URL=https://api.deepseek.com/v1 \
    -e API_KEY=$MODEL_DEEPSEEK_TOKEN \
    -e MODEL=deepseek-chat \
    -p 8006:8006 \
    -p 8007:8007 \
    -p 8265:8265 \
    -v <你的项目>:/app/work \
    -v <你的日志目录>:/app/logs \
    allwefantasy/auto-coder-web
  ```

  打开浏览器

  http://localhost:8007

  开始你的编程！


pkgId: dfd1c60fc06dd21afd5b31e2af9063855727dc388ba019bc2d7c06d554f57484
name: python-auto-diffusers
arch: src
version: 2.0.14
epoch: 0
release: 1
summary: Customized diffusers with model search and other functions.
url: https://github.com/suzukimain/auto_diffusers
rpm_license: Apache 2.0 License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-diffusers-2.0.14-1.src.rpm
checksum_type: sha256
description:
  <p>
      <a href="https://github.com/suzukimain/auto_diffusers/blob/main/LICENSE"><img alt="GitHub release" src="https://img.shields.io/badge/license-Apache%202.0-blue.svg?style=social"></a>
  </p>
  <p>
      <a href="https://pepy.tech/project/auto_diffusers"><img alt="GitHub release" src="https://static.pepy.tech/badge/auto_diffusers"></a>
      <a href="https://github.com/suzukimain/auto_diffusers/releases"><img alt="GitHub release" src="https://img.shields.io/github/release/suzukimain/auto_diffusers.svg"></a>
      <img src="https://visitor-badge.laobi.icu/badge?page_id=suzukimain.auto_diffusers" alt="Visitor Badge">
  </p>


  >CONTENTS
  + [About The Project](#About_The_Project)
  + [How to use](#How_to_use)
  + [Search Hubs](#Search_Civitai_and_Huggingfacee)
    - [Search Civitai](#Search_Civitai)
    - [Search Huggingface](#Search_Huggingface)
  + [License](#License)
  + [Acknowledgement](#Acknowledgement)


  Enhance the functionality of diffusers.
  * Search models from huggingface and Civitai.




  ```python
  pip install --quiet auto_diffusers
  ```

  ```python
  from auto_diffusers import EasyPipelineForText2Image


  pipe = EasyPipelineForText2Image.from_huggingface("any").to("cuda")
  img = pipe("cat").images[0]
  img.save("cat.png")



  pipe = EasyPipelineForText2Image.from_civitai("any").to("cuda")
  image = pipe("cat").images[0]
  image.save("cat.png")

  ```



  ```python
  from pipeline_easy import (
      search_huggingface,
      search_civitai,
  )


  Lora = search_civitai(
      "Keyword_to_search_Lora",
      model_type="LORA",
      base_model = "SD 1.5",
      download=True,
      )

  pipeline.load_lora_weights(Lora)



  TextualInversion = search_civitai(
      "EasyNegative",
      model_type="TextualInversion",
      base_model = "SD 1.5",
      download=True
  )

  pipeline.load_textual_inversion(TextualInversion, token="EasyNegative")
  ```



  > [!TIP]
  > **If an error occurs, insert the `token` and run again.**



  | Name            | Type                   | Default       | Description                                                                    |
  |:---------------:|:----------------------:|:-------------:|:-----------------------------------------------------------------------------------:|
  | search_word     | string, Path           | ー            | The search query string. Can be a keyword, Civitai URL, local directory or file path. |
  | model_type      | string                 | `Checkpoint`  | The type of model to search for.  <br>(for example `Checkpoint`, `TextualInversion`, `Controlnet`, `LORA`, `Hypernetwork`, `AestheticGradient`, `Poses`)      |
  | base_model      | string                 | None          | Trained model tag (for example  `SD 1.5`, `SD 3.5`, `SDXL 1.0`) |
  | torch_dtype     | string, torch.dtype    | None          | Override the default `torch.dtype` and load the model with another dtype.     |
  | force_download  | bool                   | False         | Whether or not to force the (re-)download of the model weights and configuration files, overriding the cached versions if they exist. |
  | cache_dir       | string, Path | None    | Path to the folder where cached files are stored. |
  | resume          | bool   | False         | Whether to resume an incomplete download. |
  | token           | string | None          | API token for Civitai authentication. |




  | Name            | Type           | Default       | Description                                                                    |
  |:---------------:|:--------------:|:-------------:|:-----------------------------------------------------------------------------------:|
  | search_word     | string, Path   | ー            | The search query string. Can be a keyword, Civitai URL, local directory or file path. |
  | model_type      | string         | `Checkpoint`  | The type of model to search for. <br>(for example `Checkpoint`, `TextualInversion`, `Controlnet`, `LORA`, `Hypernetwork`, `AestheticGradient`, `Poses`)   |
  | base_model      | string         | None          | Trained model tag (for example  `SD 1.5`, `SD 3.5`, `SDXL 1.0`)                        |
  | download        | bool           | False         | Whether to download the model.                                   |
  | force_download  | bool           | False         | Whether to force the download if the model already exists.                          |
  | cache_dir       | string, Path   | None          | Path to the folder where cached files are stored.                              |
  | resume          | bool           | False         | Whether to resume an incomplete download.                                           |
  | token           | string         | None          | API token for Civitai authentication.                                               |
  | include_params  | bool           | False         | Whether to include parameters in the returned data.           |
  | skip_error      | bool           | False         | Whether to skip errors and return None.                                             |



  > [!TIP]
  > **If an error occurs, insert the `token` and run again.**



  | Name                  | Type                | Default        | Description                                                      |
  |:---------------------:|:-------------------:|:--------------:|:----------------------------------------------------------------:|
  | search_word           | string, Path        | ー             | The search query string. Can be a keyword, Hugging Face URL, local directory or file path, or a Hugging Face path (`<creator>/<repo>`). |
  | checkpoint_format     | string              | `single_file`  | The format of the model checkpoint.<br>● `single_file` to search for `single file checkpoint` <br>●`diffusers` to search for `multifolder diffusers format checkpoint` |
  | torch_dtype           | string, torch.dtype | None           | Override the default `torch.dtype` and load the model with another dtype. |
  | force_download        | bool                | False          | Whether or not to force the (re-)download of the model weights and configuration files, overriding the cached versions if they exist. |
  | cache_dir             | string, Path        | None           | Path to a directory where a downloaded pretrained model configuration is cached if the standard cache is not used.   |
  | token                 | string, bool        | None           | The token to use as HTTP bearer authorization for remote files.  |




  | Name                  | Type                | Default        | Description                                                      |
  |:---------------------:|:-------------------:|:--------------:|:----------------------------------------------------------------:|
  | search_word           | string, Path        | ー             | The search query string. Can be a keyword, Hugging Face URL, local directory or file path, or a Hugging Face path (`<creator>/<repo>`). |
  | checkpoint_format     | string              | `single_file`  | The format of the model checkpoint. <br>● `single_file` to search for `single file checkpoint` <br>●`diffusers` to search for `multifolder diffusers format checkpoint` |
  | pipeline_tag          | string              | None           | Tag to filter models by pipeline.                                |
  | download              | bool                | False          | Whether to download the model.                                   |
  | force_download        | bool                | False          | Whether or not to force the (re-)download of the model weights and configuration files, overriding the cached versions if they exist. |
  | cache_dir             | string, Path        | None           | Path to a directory where a downloaded pretrained model configuration is cached if the standard cache is not used.   |
  | token                 | string, bool        | None           | The token to use as HTTP bearer authorization for remote files.  |
  | include_params        | bool                | False         | Whether to include parameters in the returned data.               |
  | skip_error            | bool                | False         | Whether to skip errors and return None.                           |



  In accordance with [Apache-2.0 license](https://github.com/suzukimain/auto_diffusers/blob/master/LICENSE)




  I have used open source resources and free tools in the creation of this project.

  I would like to take this opportunity to thank the open source community and those who provided free tools.


pkgId: a6836b73083e337dcaff412bbf1a2a43bbee63c6d344d64835f2971cbf3069fb
name: python-auto-editor
arch: src
version: 26.0.1
epoch: 0
release: 1
summary: Auto-Editor: Effort free video editing!
url: https://pypi.org/project/auto-editor/
rpm_license: Unlicense
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-editor-26.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/wyattblue/auto-editor/workflows/build/badge.svg)](https://github.com/wyattblue/auto-editor/actions)
  <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  Before doing the real editing, you first cut out the "dead space" which is typically silence. This is known as a "first pass". Cutting these is a boring task, especially if the video is very long.
  ```
  auto-editor path/to/your/video.mp4
  ```
  <h2 align="center">Installing</h2>
  ```
  pip install auto-editor
  ```
  See [Installing](https://auto-editor.com/installing) for additional information.
  <h2 align="center">Cutting</h2>
  Change the **pace** of the edited video by using `--margin`.
  `--margin` adds in some "silent" sections to make the editing feel nicer.
  ```


  auto-editor example.mp4 --margin 0.2sec

  auto-editor example.mp4 --margin 0.3s,1.5sec
  ```

  The `--edit` option is how auto-editor makes automated cuts.
  For example, edit out motionlessness in a video by setting `--edit motion`.
  ```

  auto-editor example.mp4 --edit motion:threshold=0.02

  auto-editor example.mp4

  auto-editor multi-track.mov --edit "(or audio:stream=0 audio:threshold=10%,stream=1)"
  ```
  Different editing methods can be used together.
  ```

  auto-editor example.mp4 --edit "(or audio:0.03 motion:0.06)"
  ```
  You can also use `dB` unit, a volume unit familiar to video-editors (case sensitive):
  ```
  auto-editor example.mp4 --edit audio:-19dB
  auto-editor example.mp4 --edit audio:-7dB
  auto-editor example.mp4 --edit motion:-19dB
  ```

  To export what auto-editor normally cuts out. Set `--video-speed` to `99999` and `--silent-speed` to `1`. This is the reverse of the usual default values.
  ```
  auto-editor example.mp4 --video-speed 99999 --silent-speed 1
  ```
  <h2 align="center">Exporting to Editors</h2>
  Create an XML file that can be imported to Adobe Premiere Pro using this command:
  ```
  auto-editor example.mp4 --export premiere
  ```
  Auto-Editor can also export to:
  - DaVinci Resolve with `--export resolve`
  - Final Cut Pro with `--export final-cut-pro`
  - ShotCut with `--export shotcut`
  - Individual media clips with `--export clip-sequence`

  Some editors support naming timelines. By default, auto-editor will use the name "Auto-Editor Media Group". For `premiere` `resolve` and `final-cut-pro` export options, you can change the name with the following syntax.
  ```

  auto-editor example.mp4 --export 'premiere:name="Your name here"'

  auto-editor example.mp4 --export 'premiere:name=""Your name here""'
  ```

  If you want to split the clips, but don't want auto-editor to do any more editing. There's a simple command.
  ```
  auto-editor example.mp4 --silent-speed 1 --video-speed 1 --export premiere
  ```
  <h2 align="center">Manual Editing</h2>
  Use the `--cut-out` option to always remove a section.
  ```

  auto-editor example.mp4 --cut-out 0,30sec

  auto-editor example.mp4 --cut-out 0,30

  auto-editor example.mp4 --add-in 0,30sec

  auto-editor example.mp4 --cut-out -10sec,end

  auto-editor example.mp4 --cut-out 0,10 15sec,20sec
  auto-editor example.mp4 --add-in 30sec,40sec 120,150sec
  ```
  And of course, you can use any `--edit` configuration.
  If you don't want **any automatic cuts**, you can use `--edit none` or `--edit all/e`
  ```

  auto-editor example.mp4 --edit none --cut-out 0,5sec

  auto-editor example.mp4 --edit all/e --add-in 0,5sec
  ```
  <h2 align="center">More Options</h2>
  List all available options:
  ```
  auto-editor --help
  ```
  Use `--help` with a specific option to learn more about it:
  ```
  auto-editor -c:v --help
  auto-editor --margin --help
  ```
  <h3 align="center">Auto-Editor is available on all major platforms</h3>
  <p align="center"><img src="https://auto-editor.com/img/cross-platform.webp" width="500" title="Windows, MacOS, and Linux"></p>

   - [How to Install Auto-Editor](https://auto-editor.com/installing)
   - [All the Options (And What They Do)](https://auto-editor.com/options)
   - [Docs](https://auto-editor.com/docs)
   - [Blog](https://auto-editor.com/blog)

  Auto-Editor is under the [Public Domain](https://github.com/WyattBlue/auto-editor/blob/master/LICENSE) and includes all directories besides the ones listed below. Auto-Editor was created by [these people.](https://auto-editor.com/blog/thank-you-early-testers)


pkgId: 4fb8ad42ede71d2704c27c1e84044a8c7e4026856736809f00e5a1c37e3d9577
name: python-auto-eval
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Using only one line of commmands to evaluate multiple models
url: https://github.com/muximus3/Auto-Eval
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-eval-0.4.3-1.src.rpm
checksum_type: sha256
description:
  [Question]: Janet’s ducks lay 16 eggs per day. She eats three for breakfast every morning and bakes muffins for her friends every day with four. She sells the remainder at the farmers' market daily for  per fresh duck egg. How much in dollars does she make every day at the farmers' market?
  [Correct answer]: Janet sells 16 - 3 - 4 = <<16-3-4=9>>9 duck eggs a day. She makes 9 * 2 = $<<9*2=18>>18 every day at the farmer’s market. #### 18
  [Candidate answer]:
  A. 20
  B. 100
  C. 21
  D. 18
  [System]:


pkgId: 0ee261b43693496e28176e800645a08947f2ff6348f0ec3d9024eb98cd9130bd
name: python-auto-everything
arch: src
version: 4.3
epoch: 0
release: 1
summary: do automate things on Linux
url: https://pypi.org/project/auto-everything/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-everything-4.3-1.src.rpm
checksum_type: sha256
description:
  ```python
  from auto_everything.terminal import Terminal
  t = Terminal()
  ```

  ```python
  reply = t.run_command('uname -a')
  print(reply)
  ```

  ```python
  commands = """
  sudo apt update
  uname -a
  """
  t.run(commands)
  ```

  ```python
  t.run_program('firefox')
  ```

  ```python
  t.run_py('your_file.py')
  ```

  ```python
  t.run_sh('your_file.sh')
  ```

  ```python
  status = t.is_running('terminal')
  print(status)
  ```

  ```python
  t.kill('terminal')


pkgId: 8a70125cb3c1c70d1ab41166bf7ab13ae9f812cc8aecb88dddd5dba5360f128a
name: python-auto-feishu
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Automation tools for feishu
url: https://pypi.org/project/auto-feishu/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-feishu-0.0.5-1.src.rpm
checksum_type: sha256
description:
  飞书官方接口的Python封装， 需要自行注册飞书应用，将应用的`app_id`和`app_secret`填入到环境变量`FEISHU_APP_ID`和`FEISHU_APP_SECRET`中。

  部分接口需要设置其他环境变量:

  - `Contact`: 通过`FEISHU_PHONE`或`FEISHU_EMAIL`或`FEISHU_OPEN_ID`获取默认的用户信息，可以用于`Message`

  > TODO: 文档`https://mkdocstrings.github.io/usage/`



  - `Approval`: 创建、同意、拒绝审批，获取审批详情
  - `Contact`: 根据手机号或邮箱获取open_id
  - `Message`: 向指定联系人或群发送文本、文件、图片、卡片
  - `SpreadSheet`: 读写多维表格


pkgId: 4e14c79920041f4a100bdd1d681481051f60653abc38622bdb757464c1e1e4f7
name: python-auto-find-date-pdf
arch: src
version: 0.2.22
epoch: 0
release: 1
summary: A simple lib to find dates from any txt/ pdf/ docx/ rtf source. For documentation see
url: https://pypi.org/project/auto-find-date-pdf/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-find-date-pdf-0.2.22-1.src.rpm
checksum_type: sha256
description:
  This is a simple package provided by Marvsai healthcare LTD. It can find any format regular dates in a str
  as python Datetime objects.

  Easy to use method


  ` def find_dates(file_contents: str): `

        Find any dates in a large python string usually taken from a file or pdf

        Args:
            file_contents (str): The string in which to find any format of dates


        Returns:
            List[datetime.datetime]: A list of datetime objects the latest can be found using max()


  Optimised replacement of multiple strings in a string

  ` replace_multiple_strings(input_string, replacements_dict) `

      Replace multiple strings in the input string using a dictionary of replacement pairs.

      Args:
          input_string (str): The string in which to replace the substrings.
          replacements_dict (dict): A dictionary of replacement pairs, where the keys are the
              substrings to be replaced and the values are the replacement strings.

      Returns:
          str: The input string with all instances of the substrings replaced with their
              corresponding replacement strings.
      """
  Easy to use extraction of text from PDF or RTF files:

  `def extract_rtf_pdf(name: str, get_ai_text:Callable=None)->str:`

        Find text from pdf and rtf

        Args:
            name (str): The string in which to find any format of dates
            get_ai_text: call back function that can call google vision api or AWS or Azure equivalents for text extraction
            Called for images and image PDFs.

        Returns:
            List[datetime.datetime]: A list of datetime objects the latest can be found using max()
        """


pkgId: 1dd2831bb26b57b831f06de2a7b313e12d4c095bebf84de4249786b28a5e5f7d
name: python-auto-function-serving
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: A python package to offload a function call to an http server automatically using a decorator.
url: https://github.com/arrmansa/auto-function-serving
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-function-serving-0.1.9-1.src.rpm
checksum_type: sha256
description:
  A python package to offload a function call to an http server running on localhost automatically using a decorator. Compatible with multiprocessing, pickle, flask, fastapi, async etc..



  Imagine a case of a multi threaded or multiprocessing application where 1 or few functions are heavily resource (cpu or memory) intensive, but the other functions can run in parallel.\
  Example - an api call followed by tokenization and classification using a large DL model followed by further API calls.\
  In such a case, it would make sense to create a server (generally using torchserve or tfserving) to serve requests, and replace the function call with a post request to the server.\
  ServerHandler creates a **synchronous** server and replaces any calls to the function automatically during runtime.\
  Requests are made to 1 instance of a process running a [http.server.HTTPServer](https://docs.python.org/3/library/http.server.html) which runs the function within it.\
  AsyncServerHandler is also available which makes the requests asynchronously.\
  Even calls made from different processes, threads, multiprocessing, flask, FastApi and async event loops are made to the same server process.



  In general :
  ```
  some code with a callable
  ```
  can be replaced with an instance of Either ServerHandler or AsyncserverHandler that accepts the code as a string in it's first argument and the name of the callable as the second argument.
  ```python
  from auto_function_serving.ServerHandler import ServerHandler
  callable_name = ServerHandler("""
  some independent code with a callable
  """, "callable_name")
  ```
  Example :
  ```python
  import module1
  import module2
  def functionname(someinput):
      a = module1.function1(someinput)
      return module2.function2(a)
  ```
  can be replaced with
  ```python
  from auto_function_serving.ServerHandler import AsyncserverHandler
  functionname = AsyncServerHandler("""
  import module1
  import module2
  def functionname(someinput):
      a = module1.function1(someinput)
      return module2.function2(a)
  """, "functionname", port="Any")
  ```
  Decorators (@AsyncserverHandler.decorator and @ServerHandler.decorator) and AsyncServerHandler details in more usage.



  ```python
  from auto_function_serving.ServerHandler import ServerHandler
  callable_name = ServerHandler("""
  some independent code with a callable
  """, "callable_name", port=None, backend='Popen', wait=100, backlog = 1024))
  ```
  1. port
      * if None, then the input code is hashed and a port is chosen from 50000 to 60000 using the hash
      * if int, then int is chosen
      * otherwise, a random open port is chosen
  2. backend - either 'Popen' or 'multiprocessing'. Popen Should be used in general.
  3. wait - approx max number of seconds to wait for the server to run. No waiting done if set to 0, default 100
  4. backlog - max number of backlogged requests before returning errors, python default is 5, but default in ServerHandler is 1024.



  runs [http.server.HTTPServer](https://docs.python.org/3/library/http.server.html).\
  ServerHandler and AsyncServerHandler objects can be loaded and unloaded with pickle.\
  Uses Popen or multiprocessing to run the server.\
  Uses only a single external dependency (aiohttp), and only for async.\
  http, not https.\
  chooses a port based on hash of input. (unless specified otherwise)



  Minimal code changes.\
  Should be compatible with almost all functions in almost all CPython envs. (Not sure where it could fail? Please add an issue if you find one.)\
  Memory leaks or errors (from the server) are extremely unlikely since it is minimal, single threaded, single process and a default component of python stdlib.\
  Exceptions cause 5xx errors without closing the server.\
  Even Separate Processes will make requests to 1 instance of the same server unless specified otherwise. (Because it's looking for a server on a specific port.).\
  Can specify otherwise by set the port to any free port so that a new ServerHandler object starts a new server.\
  http post requests : lightweight, few ms overhead, reliable.\
  Async is a good feature.\
  now with tests.



  Having a string of code as an argument to a class is not pythonic, unless the decorator is used.\
  Importing inside functions is not ideal, even when the decorator is used.\
  http post requests : insecure, few ms overhead.\
  Exceptions inside the server are not sent back.\
  No batching.\
  No inbuilt logging. (Could be added).
  Initialization delay of upto few seconds to start the server.
  Async functions will not work on the server.



  No auto server restart in case server closes.\
  May leave some resources locked for a while (<1min) if not closed properly.\
  Problems might occur if Popen or multiprocessing are not available.\
  Possible nested async errors with jupyter or other? Please look into [nest-asyncio](https://pypi.org/project/nest-asyncio/) and the [iss](https://github.com/python/cpython/issues/93462)[ues](https://github.com/python/cpython/issues/66435).\
  Warnings from somewhat hacky (but legit and completely functional) workarounds. \
  Closing of server process in __del__ and atexit.redister(__del__) fail for some reason (tested and unlikely).




  Use the package manager pip to install [auto_function_serving](https://pypi.org/project/auto-function-serving/)
  ```bash
  pip install auto_function_serving
  ```



  Code for the server is stored in [ServerHandler](https://github.com/arrmansa/auto-function-serving/blob/main/src/auto_function_serving/ServerHandler.py).base_code and some string formatting is used to fill in the blanks.\
  The server process is started with Popen (or multiprocessing if specified). The first thing it does is import socket and bind the port - if it's not available the code stops after an exception. Therefore only 1 instance of the server runs at a time on a machine.\
  We know the function is ready after we can receive a valid get request from the server.\
  Inputs and outputs are sent as bytes, converted to and from objects using pickle.\
  If port is None in while initializing (default), a port from 50000 to 60000 is chosen by hashing the input code to make it independent of the source of a function. Collisions of different functions are possible, but unlikely. The collision of the same function in multiple processes is used to make sure only 1 server process runs at a time. The port can be specified if needed.



  overhead for small input and output (few bytes) - \
  ~2ms for requests with urllib.request\
  ~4ms for async requests with aiohttp.ClientSession \
  overhead for large input and output\
  ~10ms for 0.5 mb input and output (1mb total transfer).\
  ~60ms for 5 mb input and output (10 mb total transfer).\
  ~600ms for 50 mb input and output (100 mb total transfer).



  It can also be used with the provided decorator for functions with no dependencies outside the function.
  ```python
  from auto_function_serving.ServerHandler import ServerHandler
  @ServerHandler.decorator
  def someheavyfunction(args,**kwargs):
      for i in range(big_number)
          someexpensivecomputation
  ```
  imports inside the function will work
  ```python
  from auto_function_serving.ServerHandler import ServerHandler
  @ServerHandler.decorator
  def someheavyfunction(args,**kwargs):
      import numpy as np
  ```
  ```python
  from auto_function_serving.ServerHandler import ServerHandler
  @ServerHandler.decorator
  def someheavyfunction(args,**kwargs):
      if not hasattr(someheavyfunction,'RunOnce'):
  	    global np
          import numpy as np
      setattr(someheavyfunction,'RunOnce',None)
  	... etc
  ```

  When the somemodule does not have any expensive global loading.
  ```python
  from auto_function_serving.ServerHandler import ServerHandler
  from somemodule import someheavyfunction
  someheavyfunction = ServerHandler.decorator(someheavyfunction)
  ```
  Ip address can be changed by setting ServerHandler.ip_address (default "127.0.0.1") before creating a new instance.



  AsyncServerHandler is also available which uses [aiohttp](https://docs.aiohttp.org/) to make the requests asynchronously, for use with fastapi and other async use cases. \
  AsyncServerHandler has the same usage as ServerHandler, except calls need to be awaited or used with asyncio.run() or with asyncio.get_event_loop().run_until_complete().\
  Number of async calls can be limited by setting AsyncServerHandler.TCPConnector_limit which controls the [TCPconnector](https://docs.aiohttp.org/en/stable/client_reference.html?highlight=connector#aiohttp.TCPConnector) limit (default 100). Using [Semaphore](https://docs.python.org/3/library/asyncio-sync.html#asyncio.Semaphore) is also something to consider.


  Libraries : Celery, Tfserving, Torchserve, Flask\
  Sending globals and locals to exec\
  ast trees


  Pull requests are welcome.


  [Apache License 2.0](https://choosealicense.com/licenses/apache-2.0/)


pkgId: 0f88233551315d5bcbba85568caf9cc6c5849fd59261ab2ed2f37cd8b42e19de
name: python-auto-instr
arch: src
version: 0.9.5
epoch: 0
release: 1
summary: Library for automating scientific instruments.
url: https://github.com/arvind0790/auto_instr
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-instr-0.9.5-1.src.rpm
checksum_type: sha256
description:
  - auto-instr is a simple and user-friendly library for automating scientific instruments.
  - It offers quick-set functions for configuring and measuring in a single line of code.
  - It supports all common bench instruments such as power supply, oscilloscope, function generator, source meter, multimeter,temperature controller etc.


pkgId: 623316f9def5e2194320bce56bdca2ee4bebb2e3b06bb74054c722463561c59f
name: python-auto-iserv
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: A Library that can be used to create tools to automate Iserv without an API key
url: https://github.com/RedstoneMedia/auto-iserv
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-iserv-0.1.12-1.src.rpm
checksum_type: sha256
description:
  This is a library for python, that can be used to create tools to automate Iserv **without** an API key
  The only thing that is needed is a Iserv account with a username and password.
  It is recommended to use a credential file, but you can hardcode your password and username.
  This can be done by typing : `gen-iserv-credential`

  There are pre written Modules, but you can also create your own module automation.



  You can make pull requests and I will be happy to look at them.
  If you don't know what to contribute you could add more pre written modules.


  If you want an example you might want to look at [this](https://github.com/RedstoneMedia/IServ-exercise-discord-bot)


  Install this package using pip :
  `pip install auto-iserv`


pkgId: 8d6be488f4e6fb2ad2883d24248e316c44c0cc4852e8b52d32b8cc77b483966f
name: python-auto-labeling-pipeline
arch: src
version: 0.1.23
epoch: 0
release: 1
summary: Auto labeling pipeline for doccano
url: https://github.com/doccano/auto-labeling-pipeline
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-labeling-pipeline-0.1.23-1.src.rpm
checksum_type: sha256
description:
  Auto labeling pipeline helps doccano to annotate a document automatically. This package is intended to be used from the inside of doccano. You shouldn't use this package directly.



  To install auto-labeling-pipeline, simply run:

  ```bash
  pip install auto-labeling-pipeline
  ```



  You can contribute this project by adding new templates as follows:

  1. Add a new request model class to [models.py](https://github.com/doccano/auto-labeling-pipeline/blob/master/auto_labeling_pipeline/models.py).
  2. Add a new template(Jinja2 format) to [templates/](https://github.com/doccano/auto-labeling-pipeline/tree/master/auto_labeling_pipeline/templates) directory.
  3. Add a new template class to [mappings.py](https://github.com/doccano/auto-labeling-pipeline/blob/master/auto_labeling_pipeline/mappings.py).
  4. Add a new option to [menu.py](https://github.com/doccano/auto-labeling-pipeline/blob/master/auto_labeling_pipeline/menu.py).
  5. Testing.



  [MIT](https://github.com/doccano/auto-labeling-pipeline/blob/master/LICENSE)


pkgId: d1b550b24b9c4b10be4752dc26703126b49544affddc996bc7a11ae833a30068
name: python-auto-llm-chatbot
arch: src
version: 0.1.4
epoch: 0
release: 1
url: https://github.com/dipeshpaulsystango/auto_llm_chatbot
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-llm-chatbot-0.1.4-1.src.rpm
checksum_type: sha256
summary:
  Auto LLM Chatbot is a Python package that simplifies chatbot development by automatically managing chat history using local vector databases like Chroma DB.

description:
  ⚡ Auto LLM Chatbot is a Python package designed to simplify the development of chatbot applications that use Large Language Models (LLMs). It offers automatic chat history management using a local vector database (ChromaDB), ensuring efficient context retrieval for ongoing conversations.



  ```
  pip install auto-llm-chatbot
  ```


  1. Effortless History Management: No need to manage extensive chat history manually; the package automatically handles it.
  2. Simple Integration: Build a chatbot with just a few lines of code.
  3. Full Customization: Maintain complete control over your data and conversations.
  4. Framework Compatibility: Easily integrate with any existing framework or codebase.



  1. Easy Chatbot Creation: Set up a chatbot with minimal code.
  2. Automated History Management: Automatically stores and fetches chat history for context-aware conversations.


  1. Project Setup: Create a basic project structure.
  2. Automatic Storage: Auto LLM Chatbot stores your conversations (user inputs and AI outputs) in Chroma DB.
  3. Contextual Conversations: The chatbot fetches relevant chat history whenever you engage with the LLM.




  1. Python: Ensure Python is installed on your system.
  2. GenAI Knowledge: Familiarity with Generative AI models.



  ```
  from auto_llm_chatbot.chatbot import chat


  llm_settings = {
      "provider": 'ollama',
      "base_url": 'http://localhost:11434',
      "model": "llama3.1",
      "options": {},
      "api_key": None
  }
  embedding_model_settings = {
      "provider": 'ollama',
      "base_url": 'http://localhost:11434',
      "model": "nomic-embed-text",
      "api_key": None
  }













  chroma_settings = {
      "host": None,
      "port": None,
      "settings": None
  }

  memory_settings = {
      "try_queries": True,
      "results_per_query": 3,
  }
  collection_name = "conversation"
  unique_session_id = "012"
  unique_message_id = "A01"
  system_message = "You are a helpful assistant."
  buffer_window_chats = [
      {'role': 'user', 'content': 'what is 7*5?'},
      {'role': 'assistant', 'content': '35'},
  ]
  query = "Who is PM of India?"
  response = chat(query=query, system_message=system_message,
                  llm_settings=llm_settings,
                  chroma_settings=chroma_settings,
                  embedding_model_settings=embedding_model_settings,
                  memory_settings=memory_settings,
                  memory=True,
                  collection_name=collection_name,
                  unique_session_id=unique_session_id,
                  unique_message_id=unique_message_id,
                  buffer_window_chats=buffer_window_chats)
  print("Assistant: ", response)
  ```

  *You can see, we are having initial conversation with assistant, where it is not aware of context (check next output also)-*

  ```
  Vector Database Queries sliced: ['What is the date of the conversation?', 'Has the user asked about politics or current events before?', 'who is PM of India?']

  Processing queries to vector database: 100%|██████████| 3/3 [00:01<00:00,  2.21it/s]
  0 past conversation fetched.'
  system: You are a helpful assistant.
  Here is the memory of old conversations-
  {'memories': '[]'}

  user: what is 7*5?
  assistant: 35
  user: who is PM of India?
  Assistant:  As of my last knowledge update in October 2023, the Prime Minister of India is Narendra Modi. He has been in office since May 2014. Please verify with a current source to confirm this information, as political positions can change.
  ```

  *Below you can see assistant remember the context in next run, fetched context as memories-*

  ```
  Vector Database Queries sliced: ["Who is 'him' referring to?", "What information does the user already have about 'him'?", 'Tell me more about him?']

  Processing queries to vector database:   0%|          | 0/3 [00:00<?, ?it/s]Number of requested results 3 is greater than number of elements in index 1, updating n_results = 1
  Processing queries to vector database:  33%|███▎      | 1/3 [00:00<00:01,  1.84it/s]Number of requested results 3 is greater than number of elements in index 1, updating n_results = 1
  Processing queries to vector database:  67%|██████▋   | 2/3 [00:00<00:00,  2.27it/s]Number of requested results 3 is greater than number of elements in index 1, updating n_results = 1
  Processing queries to vector database: 100%|██████████| 3/3 [00:01<00:00,  2.14it/s]
  3 past conversation fetched.'
  system: You are a helpful assistant.
  Here is the memory of old conversations-
  {'memories': "['user: who is PM of India?\\nassistant: As of my last knowledge update in October 2023, the Prime Minister of India is Narendra Modi. He has been in office since May 2014. Please verify with a current source to confirm this information, as political positions can change.', 'user: who is PM of India?\\nassistant: As of my last knowledge update in October 2023, the Prime Minister of India is Narendra Modi. He has been in office since May 2014. Please verify with a current source to confirm this information, as political positions can change.', 'user: who is PM of India?\\nassistant: As of my last knowledge update in October 2023, the Prime Minister of India is Narendra Modi. He has been in office since May 2014. Please verify with a current source to confirm this information, as political positions can change.']"}

  user: what is 7*5?
  assistant: 35
  user: Tell me more about him?
  Insert of existing embedding ID: A01
  Add of existing embedding ID: A01
  Assistant:  Narendra Modi is the Prime Minister of India, having been in office since May 2014. He is a member of the Bharatiya Janata Party (BJP) and the Rashtriya Swayamsevak Sangh (RSS), a Hindu nationalist volunteer organization. Modi was born on September 17, 1950, in Vadnagar, Gujarat.

  Before becoming Prime Minister, he served as the Chief Minister of Gujarat from 2001 to 2014. His tenure as Prime Minister has been marked by significant economic reforms, such as the Goods and Services Tax (GST), the Make in India initiative, and efforts to improve infrastructure and digital connectivity.

  Modi's government has also been known for its focus on national security, and he has taken a strong stance on issues concerning terrorism and cross-border relations, especially with Pakistan. He has been a polarizing figure in Indian politics, with both supporters praising his leadership and critics raising concerns about religious tensions and democratic backsliding.

  Modi's foreign policy emphasizes strengthening India's global standing and relationships, particularly in the Indo-Pacific region. His leadership style is characterized by a strong central authority and a focus on development and progress.

  For the latest developments or specific policies, it is recommended to consult current and authoritative sources.
  ```




  - **llm_settings-**
    - provider: can be `openai` or `ollama` only for now.
    - base_url: base url of provider
    - model: name of model
    - options: This is optional, by default it usages default settings of provider
    - api_key: API key from provider
       ```
       
       llm_settings = {
           "provider": 'openai',
           "base_url": "https://api.openai.com/v1",
           "model": "gpt-4o-mini",
           "options": {},
           "api_key": ""
       }

      
      llm_settings = {
          "provider": 'ollama',
          "base_url": 'http://localhost:11434',
          "model": "llama3.1",
          "options": {},
          "api_key": None
      }
      ```

  - **embedding_model_settings-**
    - provider: can be `openai` or `ollama` only for now.
    - base_url: base url of provider
    - model: name of model
    - options: This is optional, by default it usages default settings of provider
    - api_key: API key from provider
       ```
       
       embedding_model_settings = {
           "provider": 'openai',
           "base_url": "https://api.openai.com/v1",
           "model": "text-embedding-ada-002",
           "api_key": ""
       }

       
       embedding_model_settings = {
           "provider": 'ollama',
           "base_url": 'http://localhost:11434',
           "model": "nomic-embed-text",
           "api_key": None
       }
      ```


  - **chroma_settings-**
    - host: host url of chromadb
    - port: port of chromadb
    - settings: chromadb settings, including authentication. Read chromadb documentation.
       ```
        chroma_settings = {
            "host": None,
            "port": None,
            "settings": None
        }
      ```

  - **memory_settings-**
    - try_queries: It means, assistant will refine your query to search for similar embeddings in chromadb.

      Example: Your input is 'My name is Dipesh'

      Assistant might try these queries in vector db: 'who is Dipesh?', 'is there any conversation with Dipesh?', 'My name is Dipesh' etc.
    - results_per_query: How many relevant chats you want to fetch from vector db.
      ```
       memory_settings = {
           "try_queries": True,
           "results_per_query": 3,
       }
      ```

  - `collection_name = "conversation"`: (str) This the collection name you want to create in vector db.
  - `unique_session_id = "012"`: (str) This you need to manage. Example if user-A is having conversation in session-1 or user-A is having conversation in session-2.
  - `unique_message_id = "A01"`: (str) This you need to manage. It can be any unique message id. You can use uuid as string here,
  - `system_message = "You are a helpful assistant."`: (str) Any system message or prompt.
  - `buffer_window_chats`: If you want to manage sliding window chat history, you can pass last-n message (last-n conversation) like this in OpenAI's format.

    Example:

    ```
    buffer_window_chats = [
        {'role': 'user', 'content': 'what is 7*5?'},
        {'role': 'assistant', 'content': '35'},
    ]
    ```
  - `query = "Tell me more about him?"`: Any current / last human message.



  1. Can I customize LLM endpoints / Groq or other models?
      - Yes, any OpenAI-compatible endpoints and models can be used.

  2. Can I use custom hosted chromadb
      - Yes, you can specify custom endpoints for Chroma DB. If not provided, a Chroma directory will be created in your project's root folder.

  3. I don't want to manage history. Just wanted to chat.
      - Yes, set `memory=False` to disable history management and chat directly.

  4. Need help or have suggestions?
      - Raise an issue or contact me at dipesh.paul@systango.com


pkgId: 2086022e43ae0f2453cc0b748a9f135465c8b8cc86c506478c92cf6685a5404c
name: python-auto-logout-django
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Django auto logout não oficial para Django
url: https://pypi.org/project/auto-logout-django/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-logout-django-1.0.5-1.src.rpm
checksum_type: sha256
description:
  O projeto AUTO_LOGOUT_DJANGO é uma ferramenta desenvolvida para gerenciar automaticamente o logout de usuários inativos em sistemas web. Esta solução visa aumentar a segurança e a eficiência, garantindo que sessões inativas sejam encerradas após um período de tempo configurável.


  - Monitoramento de inatividade do usuário
  - Configuração de tempo limite para logout automático
  - Fácil integração com sistemas web existentes




  Para utilizar o AUTO_LOGOUT_DJANGO, importe o módulo e configure o tempo limite de inatividade conforme necessário:





  Contribuições são bem-vindas! Sinta-se à vontade para abrir issues e pull requests no repositório do GitHub.


  Este projeto está licenciado sob a Licença MIT. Veja o arquivo [LICENSE](LICENSE) para mais detalhes.


  Para mais informações, entre em contato pelo email: jcsilva.tenorio@gmail.com


pkgId: b4b0186ec5802474886b0c92fa3636890da7c12d2b3dd49a6572e2e2d1ccb2a5
name: python-auto-metamask2
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Web3 automation testing tool.
url: https://github.com/miklisanton/auto-metamask
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-metamask2-2.0.0-1.src.rpm
checksum_type: sha256
description:
  To streamline the testing process for developers, this tool automates the management of the MetaMask component, a wallet operation often essential for the functionality of Web3 applications.



  auto-metamask can be installed using pip:

  ```shell
  $ pip install auto-metamask
  ```

  Ensure you have either the [Chromium](https://www.chromium.org/getting-involved/download-chromium) or [Chrome](https://www.google.com/chrome/) browser installed. Without a specified directory, the system's default Chrome will be utilized. It's advisable to avoid the newest Chrome version due to potential Chrome driver mismatches.

  For compatibility, use the Metamask extension version 10.34.0 dated July 10, 2023. If opting for an older version, install version 0.1.3 of this package.

  For manual installations, you can download a specific version of the Chromium browser and its corresponding Chrome driver. Then, provide its path to the setupWebdriver function.

  For a comprehensive list of Chromium browser versions and their matching Chrome drivers, visit [here](https://commondatastorage.googleapis.com/chromium-browser-snapshots/index.html).



  ```python
  import os
  import sys
  import time
  from selenium.webdriver.common.by import By
  from selenium.webdriver.support import expected_conditions as EC
  from selenium.webdriver.support.wait import WebDriverWait
  sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
  from auto_metamask import *

  if __name__ == '__main__':

      metamask_path = downloadMetamask(
          'https://github.com/MetaMask/metamask-extension/releases/download/v10.34.0/metamask-chrome-10.34.0.zip')
      driver = setupWebdriver(metamask_path, '/Applications/Chromium.app/Contents/MacOS/Chromium', None, 'chromedriver_mac64/chromedriver')
      
      setupMetamask(
          'whip squirrel shine cabin access spell arrow review spread code fire marine', 'testtest')
      
      addNetwork('MY_MATIC', 'https://rpc-mumbai.maticvigil.com', '80001', 'MATIC')
      changeNetwork('MY_MATIC')
      
      importPK("bb334564f93fc3a40a3b6a89e0560101bb86e5b75c773381f1e6d2f37fc5c5ba")

      driver.switch_to.new_window()
      driver.get('https://metamask.github.io/test-dapp/')

      
      wait = WebDriverWait(driver, 20, 1)
      wait.until(EC.element_to_be_clickable(
          (By.CSS_SELECTOR, "button[id='connectButton']"))).click()
      
      connect()

      
      wait.until(EC.element_to_be_clickable(
          (By.CSS_SELECTOR, "button[id='requestPermissions']"))).click()
      
      connect()

      
      wait.until(EC.element_to_be_clickable(
          (By.CSS_SELECTOR, "button[id='personalSign']"))).click()
      
      confirm()

      
      wait.until(EC.element_to_be_clickable(
          (By.CSS_SELECTOR, "button[id='sendButton']"))).click()
      
      confirm()
      waitPending(20)

      
      wait.until(EC.element_to_be_clickable(
          (By.CSS_SELECTOR, "button[id='createToken']"))).click()
      
      confirm()
      waitPending(20)

      
      wait.until(EC.element_to_be_clickable(
          (By.CSS_SELECTOR, "button[id='approveTokens']"))).click()
      
      approveTokens(6)
      waitPending(20)

      time.sleep(60)
      driver.quit()
  ```



  <a id="auto_metamask.core.downloadMetamask"></a>



  ```python
  def downloadMetamask(url)
  ```

  Download the metamask extension

  **Arguments**:

  - `url` (`String`): Metamask extension download address (.zip)

  **Returns**:

  `String`: Extension file path

  <a id="auto_metamask.core.setupWebdriver"></a>



  ```python
  def setupWebdriver(metamask_path,
                     chrome_path=None,
                     version=None,
                     chromedriver_path=None)
  ```

  Initialize chrome browser and install metamask extension

  **Arguments**:

  - `metamask_path` (`String`): Extension file path
  - `chrome_path` (`String`): Chrome browser path, default is None.
  - `version` (`String`): Chrome browser version, make sure it matches the chromedriver version, if not provided, the latest version will be used, default is None. if chromedriver_path is provided, this parameter will be ignored.
  - `chromedriver_path` (`String`): Chromedriver file path, default is None.

  **Returns**:

  `WebDriver`: Selenium Chrome WebDriver

  <a id="auto_metamask.core.setupMetamask"></a>



  ```python
  @switchPage
  def setupMetamask(recovery_phrase, password)
  ```

  Setup metamask wallet

  **Arguments**:

  - `recovery_phrase` (`String`): Recovery phrase (12 words)
  - `password` (`String`): Wallet password (minimum 8 characters)

  <a id="auto_metamask.core.addNetwork"></a>



  ```python
  @switchPage
  def addNetwork(network_name, rpc_url, chain_id, currency_symbol)
  ```

  Add a custom network

  **Arguments**:

  - `network_name` (`String`): Network name
  - `rpc_url` (`String`): RPC URL
  - `chain_id` (`String`): Chain ID
  - `currency_symbol` (`String`): Currency symbol

  <a id="auto_metamask.core.changeNetwork"></a>



  ```python
  @switchPage
  def changeNetwork(network_name)
  ```

  Switch to a network

  **Arguments**:

  - `network_name` (`String`): Network name

  <a id="auto_metamask.core.importPK"></a>



  ```python
  @switchPage
  def importPK(priv_key)
  ```

  Import private key

  **Arguments**:

  - `priv_key` (`String`): Private key

  <a id="auto_metamask.core.connect"></a>



  ```python
  @switchPage
  def connect()
  ```

  Connect wallet

  <a id="auto_metamask.core.approve"></a>



  ```python
  @switchPage
  def approve()
  ```

  Approve wallet

  <a id="auto_metamask.core.approveTokens"></a>



  ```python
  @switchPage
  def approveTokens(cap=None)
  ```

  Approve tokens

  **Arguments**:

  - `cap` (`Number`): Spending limit, must be greater than 0, default is None.

  <a id="auto_metamask.core.confirm"></a>



  ```python
  @switchPage
  def confirm()
  ```

  Confirm wallet

  Use for Transaction, Sign, Deploy Contract, Create Token, Add Token, Sign In, etc.

  <a id="auto_metamask.core.waitPending"></a>



  ```python
  @switchPage
  def waitPending(timeout=40)
  ```

  Wait pending

  **Arguments**:

  - `timeout` (`Number`): Timeout (seconds)



  * [metamask-extension](https://github.com/MetaMask/metamask-extension)
  * [selenium](https://github.com/SeleniumHQ/selenium)
  * [selenium-stealth](https://github.com/diprajpatra/selenium-stealth)


pkgId: 9bc9326faacd37df5aecfb6415eabc63f93765be872a9511dd58266e7c69737e
name: python-auto-mind
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: AutoMind: A Comprehensive Machine Learning Library
url: https://github.com/lucasbasquerotto/auto-mind
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-mind-0.3.2-1.src.rpm
checksum_type: sha256
description:
  **AutoMind** is a flexible and extensible Python package designed to streamline the development and deployment of machine learning solutions. At its core, the package features a powerful manager classes that orchestrate various machine learning workflows, allowing users to focus on their specific applications without getting bogged down by implementation details. The package is built to be adaptable, enabling seamless integration of custom algorithms and models.


  - **Supervised Learning Management**: Effortlessly handle the training process for models with labeled datasets. While basic algorithms are provided, the focus is on managing and optimizing the workflow.
  - **Reinforcement Learning Orchestration** *(to be done)*: A robust framework for managing RL environments and training processes, making it easy to experiment and deploy RL agents.
  - **Semantic Processing Coordination** *(to be done)*: Tools for handling the end-to-end process of vectorizing meanings, processing them through neural architectures, and decoding them into useful formats.

  Whether you're building traditional models, exploring reinforcement learning, or working with complex semantic vectors, **AutoMind** provides the infrastructure to manage your projects efficiently while allowing room for customization and expansion.



  To see **AutoMind** in action, explore our dedicated repository for examples and tutorials: [auto-mind-examples](https://github.com/lucasbasquerotto/auto-mind-examples).

  This repository contains a variety of examples, including:

  - **Supervised Learning**: Learn how to manage and train models using labeled datasets.
  - **Reinforcement Learning** *(to be done)*: Set up RL environments, train agents, and analyze their performance.
  - **Semantic Processing** *(to be done)*: Work with vectorized meanings and process semantic information.

  Whether you're getting started or looking to expand your understanding of the **AutoMind** package, these examples will provide valuable insights and practical guidance.



  This section demonstrates how to use the provided code for supervised learning tasks. Supervised learning involves training a model on a labeled dataset, where the input data is paired with the correct output. The model learns to map inputs to outputs and can then make predictions on new, unseen data.

  Below is a demo example of how to set up and train a supervised learning model using this codebase. The example uses synthetic data that reaches 100% accuracy and is intended to provide an initial introduction to the manager class. For more complex cases, please refer to the repository [auto-mind-examples](https://github.com/lucasbasquerotto/auto-mind-examples).

  ```python
  import torch
  from auto_mind import supervised # type: ignore[import-untyped]
  from auto_mind.supervised.handlers import ( # type: ignore[import-untyped]
      GeneralBatchExecutor, MaxProbBatchEvaluator, GeneralBatchAccuracyCalculator,
      AccuracyEarlyStopper)
  from auto_mind.supervised.data import SplitData, ItemsDataset # type: ignore[import-untyped]


  class SimpleNN(torch.nn.Module):
      def __init__(self, input_size: int, hidden_size: int, num_classes: int):
          super().__init__()
          self.fc1 = torch.nn.Linear(input_size, hidden_size)
          self.fc2 = torch.nn.Linear(hidden_size, num_classes)

      def forward(self, x: torch.Tensor) -> torch.Tensor:
          x = torch.relu(self.fc1(x))
          return torch.softmax(self.fc2(x), dim=1)

  input_size = 10
  hidden_size = 128
  num_classes = 3
  num_samples = 100
  epochs = 5
  seed = 1


  def sample(idx: int) -> tuple[torch.Tensor, int]:
      y = idx % num_classes
      x = [float((j+1) == 0) for j in range(input_size)]
      return torch.tensor(x), y

  full_dataset = ItemsDataset([sample(i) for i in range(num_samples)])

  datasets = SplitData(val_percent=0.1, test_percent=0.1).split(
      full_dataset,
      shuffle=True,
      random_seed=seed)

  torch.manual_seed(seed)


  model = SimpleNN(input_size=input_size, hidden_size=hidden_size, num_classes=num_classes)

  manager = supervised.Manager(
      data_params=supervised.ManagerDataParams.from_datasets(
          datasets=datasets,
          batch_size=num_samples // 20,
      ),
      model_params=supervised.ManagerModelParams(
          model=model,
          criterion=torch.nn.CrossEntropyLoss(),
          executor=GeneralBatchExecutor(),
          use_best=False,
      ),
      optimizer_params=supervised.ManagerOptimizerParams(
          optimizer=torch.optim.Adam(model.parameters(), lr=0.01),
          train_early_stopper=AccuracyEarlyStopper(min_accuracy=0.99, patience=3)
      ),
      metrics_params=supervised.ManagerMetricsParams(
          evaluator=MaxProbBatchEvaluator(executor=GeneralBatchExecutor()),
          accuracy_calculator=GeneralBatchAccuracyCalculator(),
          batch_interval=True,
          default_interval=1,
      ),
      config=supervised.ManagerConfig(
          save_path=None,
          random_seed=seed,
      ),
  )

  info = manager.train(epochs=epochs)

  assert info is not None, 'Info should not be None'
  assert info.train_results is not None, 'Train results should not be None'
  assert info.test_results is not None, 'Test results should not be None'

  early_stopped_suffix = ' (early stopped)' if info.train_results.early_stopped else ''
  print(f'Finished training after {info.train_results.epoch} epochs{early_stopped_suffix}')

  accuracy = info.test_results.accuracy
  if accuracy is not None:
      min_acc = 0.999
      print(f'Test Accuracy: {accuracy * 100:.2f}%')
      assert accuracy > min_acc, f'Test Accuracy ({accuracy * 100:.2f}%) should be more than {min_acc * 100:.2f}%' # pylint: disable=line-too-long

  assert datasets.test is not None, 'Test dataset should not be None'
  X_test = torch.stack([x for x, _ in datasets.test])
  y_test = [y for _, y in datasets.test]
  eval_result = manager.evaluate(X_test).prediction
  for (_, predicted), label in zip(eval_result, y_test):
      assert predicted == label, f'Predicted: {predicted}, Label: {label}'
  ```



  The `Manager` class is responsible for orchestrating the training, validation, and testing of machine learning models. It can also be used to evaluate an already trained model. It integrates various components such as data loaders, models, optimizers, and metrics to provide a streamlined interface for supervised learning tasks.

  The `Executor` is a component used to run a batch of data through the model. It is responsible for executing the forward pass of the model with the given input data and returning the output. The `Executor` can be customized to handle different types of input and output processing, making it versatile for various tasks

  For example, the [GeneralBatchExecutor](/src/auto_mind/supervised/_action_handlers.py#L120) is the simplest case: it implements the `run` method to pass the input data to the model and return the model's output. The executor of the [NLP From Scratch: Classifying Names with a Character-Level RNN](https://github.com/lucasbasquerotto/auto-mind-examples/blob/main/supervised/char_rnn_classification.ipynb) example process the model output along with a `hidden` tensor during the iterations over the input tokens.

  The executor has no access to the targets. If the targets are required during training, create a dataloader that returns them along with the inputs in the first element of a 2-element tuple, with the dataloader returning data in the form `(batch[(input, target)], batch[target])`. However, this approach is generally advised against in most scenarios to avoid data leaks during training. More frequently, you might want to use data that is part of the target but not the entire target, returning from the dataloader as `(batch[(input, target_in)], batch[target_out])`. The `batch` must be a sized object (that can be called with `len()`, such as a list or a `Tensor`), where the number of items corresponds to the batch size (the dataloader must conform to this specification).

  The [TorchVision Object Detection Finetuning Tutorial](https://github.com/lucasbasquerotto/auto-mind-examples/blob/main/supervised/torchvision_tutorial.ipynb) provides an example of a custom evaluator that receives the inputs and targets used to train the model.

  The manager expects a single model. If more than one model is trained for a task, they should be included as components of a larger model. The manager also expects a single optimizer, and an [OptimizerChain](/src/auto_mind/supervised/_action_handlers.py#L80) can be used to allow several optimizers.

  For reference, the example [NLP From Scratch: Translation with a Sequence to Sequence Network and Attention](https://github.com/lucasbasquerotto/auto-mind-examples/blob/main/supervised/seq2seq_translation.ipynb), from the examples repository, has the encoder and decoder used together in the `EncoderDecoder` model class, and an optimizer chain with both the encoder and decoder optimizers.

  The criterion passed to the manager is the loss function and can either be a torch module that receives the output (returned by the `run()` method of the executor) and the target batch from the dataloader, or a function that expects a single parameter of type [BatchInOutParams](/src/auto_mind/supervised/_action_data.py#L562) that has properties related to the input, target, and the output of the executor, and should return a tensor. The function form is useful if you want to use the batch input, which is not passed to the module class (this requirement should be rare).

  The `Evaluator` is an important component used to leverage the model for various tasks. For instance, if you want `manager.evaluate(input)` to return the string of a category based on an input that is the URL of an image, you can create an evaluator that performs the following steps: loads the image from the URL, converts it into a tensor, passes the tensor to the model, retrieves the category index from the model's output tensor, and then maps the index to the category name to return it. The `Evaluator` is versatile and not necessarily focused on performance assessment; it can handle a wide range of tasks involving model usage, including preprocessing inputs and post-processing outputs. It can even be used in scenarios where the goal is to just print or plot results rather than return a value. That said, the `Evaluator` is an optional component, and any actions can be performed on the trained model by calling `manager.load_model()` method first and using the model.

  An example of a custom evaluator can be seen in the [Transfer Learning for Computer Vision Tutorial](https://github.com/lucasbasquerotto/auto-mind-examples/blob/main/supervised/transfer_learning.ipynb). In this tutorial, the input is a string representing the path of an image. The evaluator displays the image along with the predicted class given by the model. Note that the method does not return any value.

  Both training and testing can use an `EarlyStopper` to determine if the process should be stopped. There are two types of early stoppers:

  1. **General EarlyStopper**: This can be used in both training and testing. It should implement the `check(self) -> bool` method of the `EarlyStopper` base class to verify if the process should be temporarily stopped. This temporary stop will cease the entire process and return a partial result. The training can be continued later. This is useful for stopping a long-running process to release some resources and continue in the future, for example.

  2. **TrainEarlyStopper**: This is specific to training and behaves similarly to the general early stopper but with additional functionality. It should implement the `check_finish(self) -> bool` method to stop the process completely, considering that it has ended. It should also implement `update_epoch(self, loss, accuracy, metrics)` to update the state with metrics related to the epoch (to be able to determine if it should stop). Additionally, it should implement `state_dict(self) -> dict` and `load_state_dict(self, state_dict) -> typing.Self` to manage the state of the early stopper and allow the persistence of the state even if the run is interrupted. The loss and accuracy considered are the validation metrics if the training includes a validation step; otherwise, the training metrics are used.

  One example of a `TrainEarlyStopper` is the [AccuracyEarlyStopper](/src/auto_mind/supervised/_action_handlers.py#L54), which stops and finishes the training after the accuracy meets or exceeds a minimum threshold consecutively across a specified number of epochs. You can use more than one early stopper (either a basic `EarlyStopper`, a `TrainEarlyStopper`, or a combination of both) by passing them to the constructor of [ChainedEarlyStopper](/src/auto_mind/supervised/_action_handlers.py#L26).



  | Attribute | Description |
  |-----------|-------------|
  | `data_params` | Parameters related to data loading and splitting. |
  | `model_params` | Parameters related to the model, loss function, and execution. |
  | `optimizer_params` | Parameters related to the optimizer and learning rate scheduler. |
  | `metrics_params` | Parameters related to metrics calculation and evaluation. |
  | `config` | Configuration parameters such as save paths and device settings. |





  | Parameter | Type | Description |
  |-----------|------|-------------|
  | `train_dataloader` | `DataLoader` | DataLoader for the training dataset. |
  | `validation_dataloader` | `DataLoader` \| `None` | DataLoader for the validation dataset. |
  | `test_dataloader` | `DataLoader` \| `None` | DataLoader for the test dataset. |



  | Parameter | Type | Description |
  |-----------|------|-------------|
  | `model` | `nn.Module` | The neural network model to be trained. |
  | `criterion` | `nn.Module` | The loss function. |
  | `executor` | `BatchExecutor` | Executor for batch operations. See [GeneralBatchExecutor](/src/auto_mind/supervised/_action_handlers.py#L120) for the simplest case.  |
  | `use_best` | `bool` | Whether to use the best model based on validation performance when evaluating. Defaults to `False`. |
  | `clip_grad_max` | `float` \| `None` | Maximum gradient clipping value. |



  | Parameter | Type | Description |
  |-----------|------|-------------|
  | `optimizer` | `torch.optim.Optimizer` | The optimizer for training the model. |
  | `scheduler` | `Scheduler` \| `None` | Learning rate scheduler. |
  | `step_only_on_accuracy_loss` | `bool` | Whether to step the scheduler only on accuracy loss. |
  | `train_early_stopper` | `EarlyStopper` \| `None` | Early stopper for training. |
  | `test_early_stopper` | `EarlyStopper` \| `None` | Early stopper for testing. |



  | Parameter | Type | Description |
  |-----------|------|-------------|
  | `evaluator` | `Evaluator` \| `None` | Evaluator for utilizing the model in various tasks, including input preprocessing and output post-processing. |
  | `accuracy_calculator` | `BatchAccuracyCalculator` \| `None` | Calculator for batch accuracy (an example is [GeneralBatchAccuracyCalculator](/src/auto_mind/supervised/_action_handlers.py#L132)). |
  | `metrics_calculator` | `MetricsCalculator` \| `None` | Calculator for additional metrics. |
  | `batch_interval` | `bool` | Whether to calculate metrics and execute other actions (like saving) at batch intervals (instead of epochs). Defaults to `False`. |
  | `default_interval` | `int` \| `None` | Default interval for metric calculation and other actions (like saving). |
  | `save_every` | `int` \| `None` | Interval for saving the model (defaults to `default_interval`). |
  | `print_every` | `int` \| `None` | Interval for printing training information (defaults to `default_interval`). |
  | `metric_every` | `int` \| `None` | Interval for calculating metrics (defaults to `default_interval`). |
  | `get_epoch_info` | `Callable` \| `None` | Custom function to retrieve epoch information (to be printed), overriding the default behavior. |
  | `get_batch_info` | `Callable` \| `None` | Custom function to retrieve batch information (to be printed), overriding the default behavior. |
  | `train_metrics_handler` | `MetricsHandler` \| `None` | Handler for training metrics, updated periodically (according to `metric_every`). |



  | Parameter | Type | Description |
  |-----------|------|-------------|
  | `save_path` | `str` \| `None` | Path to save the model (`.pth` file). |
  | `random_seed` | `int` \| `None` | Random seed for reproducibility (it may be necessary to call `torch.manual_seed(seed)` and similar functions before creating the model and performing any stochastic operations outside the manager to ensure full reproducibility). |
  | `device` | `torch.device` \| `None` | Device to run the model on (CPU, GPU). |
  | `train_hook` | `Callable` \| `None` | Hook function for training. |
  | `validation_hook` | `Callable` \| `None` | Hook function for validation. |
  | `test_hook` | `Callable` \| `None` | Hook function for testing. |



  | Method | Description |
  |--------|-------------|
  | `clear()` | Deletes the file that contains the model weights and training information. |
  | `info()` | Returns an object with information about the training, tests, and metrics. |
  | `train(epochs: int)` | Trains the model for a specified number of epochs. |
  | `evaluate(input: EI) -> EO` | Evaluates the model on the given input, according to the `Evaluator` passed to the manager. |
  | `debug(input: DI, evaluator: Evaluator[DI, DO]) -> DO` | Debugs the model using the provided evaluator. |
  | `load_model()` | Loads the model from the specified save path. |


pkgId: 44aea2d3902225098e69f203987259503a2b7862bea6727ca04f37287c1a78a2
name: python-auto-mix-prep
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Application for automatically preparing stems for mixing.
url: https://github.com/dashj/auto-mix-prep
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-mix-prep-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Performs operations on wave files in preperation for mixing.
  Current features
  ^^^^^^^^^^^^^^^^
  - Gain staging, i.e. adjusting peak dB to desired level
  - Backup stems before editing
  - Split stereo files into separate mono tracks (L/R)
  Planned features
  ^^^^^^^^^^^^^^^^
  -  Interactive usage
  -  Renaming files
  -  Ability to exclude files


pkgId: 2cf6d8140347b744f6604b47a30fc79f94477afe1cf4ee659e463b12a5796d0c
name: python-auto-ml-cl
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: Auto machine learning with scikit-learn and TensorFlow framework.
url: https://github.com/lugq1990/auto-ml-cl
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-ml-cl-0.0.21-1.src.rpm
checksum_type: sha256
description:
  ![Evalution result](https://drive.google.com/file/d/1-IZA5ca2CPv3_TivCkab_jV-On-7CW-3/view?usp=sharing)





  Get best models with only **3** lines of code no matter what type of data with **auto-ml-cl**.

  How to create a machine learning and deep learning models with just a few lines of code by just provide data, then framework will get best trained models based on the data we have? We don't need to care about `Data Loading`, `Feature Engineering`, `Model Training`, `Model Selection`, `Model Evaluation` and `Model Sink`, even `RESTful` with best trained model. Now **Auto-ML** comes in to show power!

  This repository is based on **scikit-learn** and **TensorFlow** to create both machine learning models and nueral network models with **3** lines of code by just providing a training file, if there is a test file will be nicer to evaluate trained model without any bias, but if with just one file will also be fine.

  Happy to accounce:

  Both **classification** and **regression** problems are supported now!




  It's highly recommended that to create a **virtual environment** to install `auto-ml-cl` as this will be at least of affect for root user path.



  1. Install virtual env: `sudo apt-get install python3-venv`
  2. Create virtual env folder: `python3 -m venv your_env_name`
  3. activate your virtual env: `source your_env_name/bin/activate`
  4. Install `auto-ml-cl` package: `pip install auto-ml-cl`




  1. Install virtual env: `python -m pip install virtualenv`
  2. Create virtual env folder: `python -m venv your_env_name`
  3. activate your virtual env: `.\your_env_name\Scripts\activate`
  4. Install `auto-ml-cl` package: `pip install auto-ml-cl`








  Sample code to use `auto_ml` package by using `Titanic` dataset from Kaggle competion, as this dataset contain different kinds of data types also contain some missing values with different threasholds.

  ```python
  from auto_ml.automl import ClassificationAutoML, FileLoad

  file_load = FileLoad(file_name="train.csv", file_path = r"C:\auto_ml\test", label_name='Survived')
  auto_est = ClassificationAutoML()
  auto_est.fit(file_load=file_load, val_split=0.2)
  ```

  That's it all you need to get best models based on your dataset!

  If you need to get model prediction based on best trained model, that's easy just call `predict` function based on test data file like bellow code.
  ```python

  file_load_test = FileLoad(file_name="test.csv", file_path = r"C:\auto_ml\test")

  pred = auto_est.predict(file_load=file_load_test)
  ```

  Then we could get whole trained models' evaluation score for each trained model score, we could get best trained model based on validation score if we would love to use trained model for production, one important thing is that these models are stored in local server, we could use them any time with RESTFul API calls.
  ![Evalution result](https://drive.google.com/file/d/1Nu344CnKrCu-eaPRliYCVKGFupEUvrHs/view?usp=sharing)

  If we want to use GCP cloud storage as a data source for train and test data, what needed is just get the service account file with proper authority, last is just provide with parameter: `service_account_name` and file local path: `service_account_file_path` to `FileLoad` object, then training will start automatically.

  ```python
  file_name="train.csv"
  file_path = "gs://bucket_name"
  service_account_name = "service_account.json"
  service_account_file_path = r"C:\auto_ml\test"

  file_load = FileLoad(file_name, file_path, label_name='Survived',
      service_account_file_name=service_account_name, service_account_file_path=service_account_file_path)

  auto_est = ClassificationAutoML()
  auto_est.fit(file_load=file_load)
  ```

  If we have data `in memory`, we could also use memory objects to train, test and predict with `auto_ml` object, just like `scikit-learn`.

  ```python
  from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split

  x, y = load_iris(return_X_y=True)
  xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size=.2)

  auto_est = ClassificationAutoML()
  auto_est.fit(xtrain, ytrain)

  score = auto_est.score(xtest, ytest)
  pred = auto_est.predict(xtest)
  prob = auto_est.predict_proba(xtest)
  ```



  Full functionality for both `classification` and `regression` is same, so the only difference is to change imported class from `ClassificationAutoML` to `RegressionAutoML` just like snippet code

  ```python
  from auto_ml.automl import RegressionAutoML, FileLoad

  file_load = FileLoad(file_name="train.csv", file_path = r"C:\auto_ml\test", label_name="label")

  auto_est = RegressionAutoML()
  auto_est.fit(file_load=file_load, val_split=0.2)
  ```



   - `machine learning` and `neural network models` are supported.
   - `Automatically data pre-processing` with missing, unstable, categorical various data types.
   - `Ensemble logic` to combine models to build more powerful models.
   - `Nueral network models search` with `kerastunner` to find best hyper-parameter for specific type of algorithm.
   - `Cloud files` are supported like: `Cloud storage` for GCP or local files.
   - `Logging` different processing information into one date file for future reference.
   - `Processing monitoring` for each algorithm training status.
   - `RESTful API` for API call to get prediction based on best trained model.




  Current supported algorithms:
   - Logistic Regression
   - Support vector machine
   - Gradient boosting tree
   - Random forest
   - Decision Tree
   - Adaboost Tree
   - K-neighbors
   - XGBoost
   - LightGBM
   - Deep nueral network

  Also supported with `Ensemble` logic to combine different models to build more powerful model by adding model diversity:
   - Voting
   - Stacking

  For raw data file, will try with some common pre-procesing steps to create dataset for algorithms, currently some pre-processing algorithms are supported:
   - Imputation with statistic analysis for continuous and categorical columns, also support with KNN imputaion for categorical columns.
   - Standarize with data standard data
   - Normalize
   - OneHot Encoding for categorical columns
   - MinMax for continuous columns to avoid data volumn bias
   - PCA to demension reduction with threashold
   - Feature selection with variance or LinearRegression or ExtraTree




  Insight for logics to `auto` machine learning training steps.

  1. Load data from file or memory for both training and testinig with class `FileLoad`, support with GCP's `GCS` files as source file.
  2. Build processing pipeline object based on data.

      (1). `Imputation` for both categorical and numerical data with different logic, if data missing column is over a threshold, will delete that column. Support with algorithm `KNNImputer` to impute data or `SimpleImputer` to fill missing data.

      (2). `OneHot Encoding` for categorical columns and add created columns into original data.

      (3). `Standardize` data to avoid data range, also benefit for some algorithms like `SVM` etc.

      (4). `MinMax` data to keep data into a 0-1 range.

      (5). `FeatureSelection` to keep features with a default threshold or using algorithm with `ExtraTree` or `LinearRegreesion` to select features.

      (6). `PCA` to reduce dimenssion if feature variance over a threshold and just keep satisfied features.
  3. Build a `Singleton` backend object to do file or data related functions.
  4. Build training pipeline to instant each algorithm with a `factory` class based on pre-defined used algorithms.
  5. Build a `SearchModel` class for each algorithm to find best parameters based on `RandomSearch` or `GridSearch`.
  6. Pre-processing pipeline `fit` and `tranform`, save trained pipeline into disk for future use.
  7. Start `training` with training pipeline with processed data with doing parameters search to find `best parameter's model`, also combined with Neural network search to find best neural models. If need `validation` will use some data to do validation that will reduce training data size, or could use trainded `auto_ml` object to do validation will also be fine.
  8. Use `Ensemble` logic to do `voting` or `stacking` to combine trained models as a new more diverse model based on best trained model.
  9.  `Evaluate` each trained models based on validation data and return a ditionary with `training model name`, `training score` and `validation score`.
  10.  Support to `export trained models into a pre-defined folder` that we want.
  11.  Support `RESTful API` call based on best trained model based on `test score`.


pkgId: 408fd2174c465fe237397360303001bbddb74f0a4511ea13eb1e5a5efa6a67f2
name: python-auto-ninja
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A lightweight library to quickly build CRUD API endpoints for Django Ninja.
url: https://github.com/fa-krug/auto-ninja
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-ninja-1.0.1-1.src.rpm
checksum_type: sha256
description:
  If you encounter any issues or have questions, please open an issue on GitHub or contact us.
  Happy coding with Auto Ninja!


pkgId: bf4ee603bc00099716da558ea3104d407d54e0bb1af20cae4b99bf9e2e92f29b
name: python-auto-nlp
arch: src
version: 0.40
epoch: 0
release: 1
summary: Automated NLP tools. Plug N Play.
url: https://github.com/aryxns/auto_nlp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-nlp-0.40-1.src.rpm
checksum_type: sha256
description:
  Auto NLP is an open-source automated NLP library. It is an abstraction layer over existing NLP packages like Tensorflow and spaCy. You can perform complex NLP tasks in very few lines of code.


pkgId: 98a69abc4a0af0237239c3e3a9e55116152237e7d8dac443d64550d9671494ef
name: python-auto-play-in-mpv
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Automatically redirect to mpv player when playing online video
url: https://github.com/lxl66566/auto-play-in-mpv
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-play-in-mpv-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Automatically redirect to mpv player when playing online video.



  1. install auto-play-in-mpv: `pipx install auto-play-in-mpv`, start as `apim`.
  2. install tampermonkey in your browser
  3. [install the script from greasyfork](https://greasyfork.org/zh-CN/scripts/505562-auto-play-in-mpv)
  4. just click a video from supported sites.



  Note that this is just [my config example](https://github.com/lxl66566/nixos-config/tree/main/config/mpv/profile.conf). You may need to change some settings.



  It's better to start the websocket server at startup.

  - On NixOS: Add this to your `configuration.nix`
    ```nix
    systemd.user.services.apim = {
      enable = true;
      description = "Open online video in local mpv player";
      script = "~/.local/bin/apim";
      wantedBy = [ "default.target" ];
      path = with pkgs; [
        mpv
        yt-dlp
        kdePackages.kwallet
      ];
    };
    ```



  - [x] bilibili (video, live)
  - [x] youtube



  - [ ] auto start
  - [ ] fix behavior on youtube



  MIT


pkgId: 7ba018130602abeaff3918cab9c44b966dc959e52f5c1ec8f5f8d4b486b97200
name: python-auto-py-to-exe
arch: src
version: 2.44.1
epoch: 0
release: 1
summary: Converts .py to .exe using a simple graphical interface.
url: https://github.com/brentvollebregt/auto-py-to-exe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-py-to-exe-2.44.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Auto PY to EXE</h1>
  <p align="center">A .py to .exe converter using a simple graphical interface and <a href="https://pyinstaller.readthedocs.io/en/stable/index.html">PyInstaller</a> in Python.</p>

  <p align="center">
      <img src="https://nitratine.net/posts/auto-py-to-exe/feature.png" alt="Empty interface">
  </p>

  <p align="center">
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/v/auto-py-to-exe.svg" alt="PyPI Version"></a>
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/pyversions/auto-py-to-exe.svg" alt="PyPI Supported Versions"></a>
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/l/auto-py-to-exe.svg" alt="License"></a>
      <a href="https://pepy.tech/project/auto-py-to-exe"><img src="https://static.pepy.tech/badge/auto-py-to-exe/month" alt="Downloads Per Month"></a>
      <a href="https://pyinstaller.readthedocs.io/en/stable/requirements.html"><img src="https://img.shields.io/badge/platform-windows%20%7C%20linux%20%7C%20macos-lightgrey" alt="Supported Platforms"></a>
      <a href="https://www.buymeacoffee.com/brentvollebregt"><img src="https://img.shields.io/badge/-buy_me_a%C2%A0beer-gray?logo=buy-me-a-coffee" alt="Donate"></a>
  </p>



  阅读中文版的 README ，点击 [这里](./README-Chinese.md)

  Suomenkieliset käyttöohjeet löydät [täältä](./README-Finnish.md)

  Türkçe Talimatları [burada](./README-Turkish.md) bulabilirsiniz.

  دستور العمل های [فارسی](./README-Persian.md)

  한국어로 된 설명은 [여기](./README-Korean.md)를 참고하세요.

  Български README [тук](README-Bulgarian.md)

  Беларускамоўны README [тут](README-Belarusian.md)



  <p align="center">
      <img src="https://nitratine.net/posts/auto-py-to-exe/auto-py-to-exe-demo.gif" alt="auto-py-to-exe Demo">
  </p>





  - Python: 3.6-3.12

  _To have the interface displayed in the images, you will need Chrome. If Chrome is not installed or `--no-chrome` is passed, the default browser will be used._





  You can install this project using PyPI:

  ```
  $ pip install auto-py-to-exe
  ```

  Then to run it, execute the following in the terminal:

  ```
  $ auto-py-to-exe
  ```

  > If you have more than one version of Python installed, you can use `python -m auto_py_to_exe` instead of `auto-py-to-exe`.



  ```
  $ git clone https://github.com/brentvollebregt/auto-py-to-exe.git
  $ cd auto-py-to-exe
  $ python setup.py install
  ```

  Then to run it, execute the following in the terminal:

  ```
  $ auto-py-to-exe
  ```



  You can run this project locally by following these steps:

  1. Clone/download the [repo](https://github.com/brentvollebregt/auto-py-to-exe)
  2. Open cmd/terminal and cd into the project's root folder
  3. Execute `python -m pip install -r requirements.txt`
  4. Execute `python -m auto_py_to_exe` to run the application



  1. Select your script location (paste in or use a file explorer)
     - The outline will become blue if the file exists
  2. Select other options and add things like an icon or other files
  3. Click the big blue button at the bottom to convert
  4. Find your converted files in /output when completed

  _Easy._



  Use the help flag to get the usage: `auto-py-to-exe --help`

  | Argument                                                     | Type                | Description                                                                                                                       |
  | ------------------------------------------------------------ | ------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
  | filename                                                     | positional/optional | Pre-fill the "Script Location" field in the UI.                                                                                   |
  | -nc, --no-chrome                                             | optional            | Open the UI using the default browser (which may be Chrome). Will not try to find Chrome.                                         |
  | -nu, --no-ui                                                 | optional            | Don't try to open the UI in a browser and simply print out the address where the application can be accessed.                     |
  | -c [CONFIG], --config [CONFIG]                               | optional            | Provide a configuration file (JSON) to pre-fill the UI. These can be generated in the settings tab.                               |
  | -o [PATH], --output-dir [PATH]                               | optional            | Set the default output directory. This can still be changed in the UI.                                                            |
  | -bdo [FOLDER_PATH], --build-directory-override [FOLDER_PATH] | optional            | Override the default build directory. Useful if you need to whitelist a folder to stop your antivirus from removing files.        |
  | -lang [LANGUAGE_CODE], --language [LANGUAGE_CODE]            | optional            | Hint the UI what language it should default to when opening. Language codes can be found in the table under "Translations" below. |



  Instead of inserting the same data into the UI over and over again, you can export the current state by going to the "Configuration" section within the settings tab and exporting the config to a JSON file. This can then be imported into the UI again to re-populate all fields.

  This JSON config export action does not save the output directory automatically as moving hosts could mean different directory structures. If you want to have the output directory in the JSON config, add the directory under `nonPyinstallerOptions.outputDirectory` in the JSON file (will need to create a new key).



  If you need something visual to help you get started, [I made a video for the original release of this project](https://youtu.be/OZSZHmWSOeM); some things may be different but the same concepts still apply.



  Check out [CONTRIBUTING.md](./CONTRIBUTING.md) to see guidelines on how to contribute. This outlines what to do if you have a new feature, a change, translation update or have found an issue with auto-py-to-exe.



  If you're having issues with the packaged executable or using this tool in general, I recommend you read [my blog post on common issues when using auto-py-to-exe](https://nitratine.net/blog/post/issues-when-using-auto-py-to-exe/?utm_source=auto_py_to_exe&utm_medium=readme_link&utm_campaign=auto_py_to_exe_help). This post covers things you should know about packaging Python scripts and fixes for things that commonly go wrong.

  If you believe you've found an issue with this tool, please follow the ["Reporting an Issue" section in CONTRIBUTING.md](./CONTRIBUTING.md#reporting-an-issue).



  | Language                                    | Translator                                                                                   | Translated                            |
  | ------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------- |
  | Arabic (العربية)                            | [Tayeb-Ali](https://github.com/tayeb-ali)                                                    | UI                                    |
  | Belarusian (Беларуская)                     | [Zmicier21](https://github.com/Zmicier21)                                                    | UI and [README](README-Belarusian.md) |
  | Brazilian Portuguese (Português Brasileiro) | [marleyas](https://github.com/marleyas), [reneoliveirajr](https://github.com/reneoliveirajr) | UI                                    |
  | Bulgarian (Български)                       | [kbkozlev](https://github.com/kbkozlev)                                                      | UI and [README](README-Bulgarian.md)  |
  | Chinese Simplified (简体中文)               | [jiangzhe11](https://github.com/jiangzhe11)                                                  | UI and [README](./README-Chinese.md)  |
  | Chinese Traditional (繁體中文)              | [startgo](https://github.com/ystartgo)                                                       | UI                                    |
  | Czech (Čeština)                             | [Matto58](https://github.com/Matto58)                                                        | UI                                    |
  | Dutch (Nederlands)                          | [barremans](https://github.com/barremans)                                                    | UI                                    |
  | English                                     | -                                                                                            | UI and README                         |
  | Finnish (Suomen kieli)                      | [ZapX5](https://github.com/ZapX5)                                                            | UI and [README](./README-Finnish.md)  |
  | French (Français)                           | [flaviedesp](https://github.com/flaviedesp)                                                  | UI                                    |
  | German (Deutsch)                            | [hebens](https://github.com/hebens), [ackhh](https://github.com/ackhh)                       | UI                                    |
  | Greek (Ελληνικά)                            | [sofronas](https://github.com/sofronas)                                                      | UI                                    |
  | Hebrew (עברית)                              | [ronbentata](https://github.com/ronbentata)                                                  | UI and [README](./README-Hebrew.md)   |
  | Hindi (हिन्दी)                              | [triach-rold](https://github.com/triach-rold)                                                | UI and [README](./README-Hindi.md)    |
  | Indonesian (Bahasa Indonesia)               | [MarvinZhong](https://github.com/MarvinZhong)                                                | UI                                    |
  | Italian (Italiano)                          | [itsEmax64](https://github.com/itsEmax64)                                                    | UI                                    |
  | Japanese (日本語)                           | [NattyanTV](https://github.com/nattyan-tv)                                                   | UI                                    |
  | Korean (한국어)                             | [jhk1090](https://github.com/jhk1090)                                                        | UI and [README](./README-Korean.md)   |
  | Persian (فارسی)                             | [DrunkLeen](https://github.com/drunkleen), [Ar.dst](https://github.com/Ar-dst)               | UI and [README](./README-Persian.md)  |
  | Polish (Polski)                             | [Akuczaku](https://github.com/Akuczaku)                                                      | UI                                    |
  | Russian (Русский)                           | Oleg                                                                                         | UI                                    |
  | Serbian                                     | [rina](https://github.com/sweatshirts)                                                       | UI                                    |
  | Spanish (Español)                           | [enriiquee](https://github.com/enriiquee)                                                    | UI                                    |
  | Spanish Latam (Español Latam)               | [Matyrela](https://github.com/Matyrela)                                                      | UI                                    |
  | Thai (ภาษาไทย)                              | [teerut26](https://github.com/teerut26)                                                      | UI (partial)                          |
  | Turkish (Türkçe)                            | [mcagriaksoy](https://github.com/mcagriaksoy)                                                | UI and [README](./README-Turkish.md)  |
  | Ukrainian (Українська)                      | [AndrejGorodnij](https://github.com/AndrejGorodnij)                                          | UI                                    |
  | Vietnamese (Tiếng Việt)                     | [7777Hecker](https://github.com/7777Hecker)                                                  | UI                                    |

  > Want to add a translation for another language? follow the ["Add or Update a Translation" section in CONTRIBUTING.md](./CONTRIBUTING.md#add-or-update-a-translation).



  As of [PyInstaller v4.0](https://github.com/pyinstaller/pyinstaller/releases/tag/v4.0) released on Aug 9 2020, Python 2.7 is no longer supported; although you can still use this tool with Python 2.7 by installing an older version of PyInstaller. [PyInstaller v3.6](https://github.com/pyinstaller/pyinstaller/releases/tag/v3.6) was the last version that supported Python 2.7; to install this, first uninstall any existing versions of PyInstaller and then execute `python -m pip install pyinstaller==3.6`.



  Tests are located in `tests/` and are run using pytest:

  ```
  $ pip install pytest
  $ pip install -e .
  $ pytest
  ```



  | <!-- -->                                                                                                                                             | <!-- -->                                                                                                                              |
  | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
  | [![Empty interface](https://nitratine.net/posts/auto-py-to-exe/empty-interface.png)](https://nitratine.net/posts/auto-py-to-exe/empty-interface.png) | [![Filled out](https://nitratine.net/posts/auto-py-to-exe/filled-out.png)](https://nitratine.net/posts/auto-py-to-exe/filled-out.png) |
  | [![Converting](https://nitratine.net/posts/auto-py-to-exe/converting.png)](https://nitratine.net/posts/auto-py-to-exe/converting.png)                | [![Completed](https://nitratine.net/posts/auto-py-to-exe/completed.png)](https://nitratine.net/posts/auto-py-to-exe/completed.png)    |


pkgId: 38a6de7e344a8e745f0d6600bd2503e14aaa8d867ef501579daa9e3795d353c7
name: python-auto-py-to-exe
arch: src
version: 2.44.3
epoch: 0
release: 1
summary: Converts .py to .exe using a simple graphical interface.
url: https://github.com/brentvollebregt/auto-py-to-exe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-py-to-exe-2.44.3-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Auto PY to EXE</h1>
  <p align="center">A .py to .exe converter using a simple graphical interface and <a href="https://pyinstaller.readthedocs.io/en/stable/index.html">PyInstaller</a> in Python.</p>

  <p align="center">
      <img src="https://nitratine.net/posts/auto-py-to-exe/feature.png" alt="Empty interface">
  </p>

  <p align="center">
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/v/auto-py-to-exe.svg" alt="PyPI Version"></a>
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/pyversions/auto-py-to-exe.svg" alt="PyPI Supported Versions"></a>
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/l/auto-py-to-exe.svg" alt="License"></a>
      <a href="https://pepy.tech/project/auto-py-to-exe"><img src="https://static.pepy.tech/badge/auto-py-to-exe/month" alt="Downloads Per Month"></a>
      <a href="https://pyinstaller.readthedocs.io/en/stable/requirements.html"><img src="https://img.shields.io/badge/platform-windows%20%7C%20linux%20%7C%20macos-lightgrey" alt="Supported Platforms"></a>
      <a href="https://www.buymeacoffee.com/brentvollebregt"><img src="https://img.shields.io/badge/-buy_me_a%C2%A0beer-gray?logo=buy-me-a-coffee" alt="Donate"></a>
  </p>



  阅读中文版的 README ，点击 [这里](./README-Chinese.md)

  Suomenkieliset käyttöohjeet löydät [täältä](./README-Finnish.md)

  Türkçe Talimatları [burada](./README-Turkish.md) bulabilirsiniz.

  دستور العمل های [فارسی](./README-Persian.md)

  한국어로 된 설명은 [여기](./README-Korean.md)를 참고하세요.

  Български README [тук](README-Bulgarian.md)

  Беларускамоўны README [тут](README-Belarusian.md)



  <p align="center">
      <img src="https://nitratine.net/posts/auto-py-to-exe/auto-py-to-exe-demo.gif" alt="auto-py-to-exe Demo">
  </p>





  - Python: 3.6-3.12

  _To have the interface displayed in the images, you will need Chrome. If Chrome is not installed or `--no-chrome` is passed, the default browser will be used._





  You can install this project using PyPI:

  ```
  $ pip install auto-py-to-exe
  ```

  Then to run it, execute the following in the terminal:

  ```
  $ auto-py-to-exe
  ```

  > If you have more than one version of Python installed, you can use `python -m auto_py_to_exe` instead of `auto-py-to-exe`.



  ```
  $ git clone https://github.com/brentvollebregt/auto-py-to-exe.git
  $ cd auto-py-to-exe
  $ python setup.py install
  ```

  Then to run it, execute the following in the terminal:

  ```
  $ auto-py-to-exe
  ```



  You can run this project locally by following these steps:

  1. Clone/download the [repo](https://github.com/brentvollebregt/auto-py-to-exe)
  2. Open cmd/terminal and cd into the project's root folder
  3. Execute `python -m pip install -r requirements.txt`
  4. Execute `python -m auto_py_to_exe` to run the application



  1. Select your script location (paste in or use a file explorer)
     - The outline will become blue if the file exists
  2. Select other options and add things like an icon or other files
  3. Click the big blue button at the bottom to convert
  4. Find your converted files in /output when completed

  _Easy._



  Use the help flag to get the usage: `auto-py-to-exe --help`

  | Argument                                                     | Type                | Description                                                                                                                       |
  | ------------------------------------------------------------ | ------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
  | filename                                                     | positional/optional | Pre-fill the "Script Location" field in the UI.                                                                                   |
  | -nc, --no-chrome                                             | optional            | Open the UI using the default browser (which may be Chrome). Will not try to find Chrome.                                         |
  | -nu, --no-ui                                                 | optional            | Don't try to open the UI in a browser and simply print out the address where the application can be accessed.                     |
  | -c [CONFIG], --config [CONFIG]                               | optional            | Provide a configuration file (JSON) to pre-fill the UI. These can be generated in the settings tab.                               |
  | -o [PATH], --output-dir [PATH]                               | optional            | Set the default output directory. This can still be changed in the UI.                                                            |
  | -bdo [FOLDER_PATH], --build-directory-override [FOLDER_PATH] | optional            | Override the default build directory. Useful if you need to whitelist a folder to stop your antivirus from removing files.        |
  | -lang [LANGUAGE_CODE], --language [LANGUAGE_CODE]            | optional            | Hint the UI what language it should default to when opening. Language codes can be found in the table under "Translations" below. |



  Instead of inserting the same data into the UI over and over again, you can export the current state by going to the "Configuration" section within the settings tab and exporting the config to a JSON file. This can then be imported into the UI again to re-populate all fields.

  This JSON config export action does not save the output directory automatically as moving hosts could mean different directory structures. If you want to have the output directory in the JSON config, add the directory under `nonPyinstallerOptions.outputDirectory` in the JSON file (will need to create a new key).



  The [examples/](./examples/) directory offers some examples of how to write your scripts and package them with auto-py-to-exe.

  - [Basic (console application)](./examples/1-basic/readme.md)
  - [No Console (as typically desired for GUI-based applications)](./examples/2-no-console/readme.md)
  - [Images and other non-.py files (static files to be included)](./examples/3-images-and-other-non-py-files/readme.md)
  - [Persistent data (like databases)](./examples/4-persistent-data/readme.md)



  If you need something visual to help you get started, [I made a video for the original release of this project](https://youtu.be/OZSZHmWSOeM); some things may be different but the same concepts still apply.



  Check out [CONTRIBUTING.md](./CONTRIBUTING.md) to see guidelines on how to contribute. This outlines what to do if you have a new feature, a change, translation update or have found an issue with auto-py-to-exe.



  If you're having issues with the packaged executable or using this tool in general, I recommend you read [my blog post on common issues when using auto-py-to-exe](https://nitratine.net/blog/post/issues-when-using-auto-py-to-exe/?utm_source=auto_py_to_exe&utm_medium=readme_link&utm_campaign=auto_py_to_exe_help). This post covers things you should know about packaging Python scripts and fixes for things that commonly go wrong.

  If you believe you've found an issue with this tool, please follow the ["Reporting an Issue" section in CONTRIBUTING.md](./CONTRIBUTING.md#reporting-an-issue).



  | Language                                    | Translator                                                                                   | Translated                            |
  | ------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------- |
  | Arabic (العربية)                            | [Tayeb-Ali](https://github.com/tayeb-ali)                                                    | UI                                    |
  | Belarusian (Беларуская)                     | [Zmicier21](https://github.com/Zmicier21)                                                    | UI and [README](README-Belarusian.md) |
  | Brazilian Portuguese (Português Brasileiro) | [marleyas](https://github.com/marleyas), [reneoliveirajr](https://github.com/reneoliveirajr) | UI                                    |
  | Bulgarian (Български)                       | [kbkozlev](https://github.com/kbkozlev)                                                      | UI and [README](README-Bulgarian.md)  |
  | Chinese Simplified (简体中文)               | [jiangzhe11](https://github.com/jiangzhe11)                                                  | UI and [README](./README-Chinese.md)  |
  | Chinese Traditional (繁體中文)              | [startgo](https://github.com/ystartgo)                                                       | UI                                    |
  | Czech (Čeština)                             | [Matto58](https://github.com/Matto58)                                                        | UI                                    |
  | Dutch (Nederlands)                          | [barremans](https://github.com/barremans)                                                    | UI                                    |
  | English                                     | -                                                                                            | UI and README                         |
  | Finnish (Suomen kieli)                      | [ZapX5](https://github.com/ZapX5)                                                            | UI and [README](./README-Finnish.md)  |
  | French (Français)                           | [flaviedesp](https://github.com/flaviedesp)                                                  | UI                                    |
  | German (Deutsch)                            | [hebens](https://github.com/hebens), [ackhh](https://github.com/ackhh)                       | UI                                    |
  | Greek (Ελληνικά)                            | [sofronas](https://github.com/sofronas)                                                      | UI                                    |
  | Hebrew (עברית)                              | [ronbentata](https://github.com/ronbentata)                                                  | UI and [README](./README-Hebrew.md)   |
  | Hindi (हिन्दी)                              | [triach-rold](https://github.com/triach-rold)                                                | UI and [README](./README-Hindi.md)    |
  | Indonesian (Bahasa Indonesia)               | [MarvinZhong](https://github.com/MarvinZhong)                                                | UI                                    |
  | Italian (Italiano)                          | [itsEmax64](https://github.com/itsEmax64)                                                    | UI                                    |
  | Japanese (日本語)                           | [NattyanTV](https://github.com/nattyan-tv)                                                   | UI                                    |
  | Korean (한국어)                             | [jhk1090](https://github.com/jhk1090)                                                        | UI and [README](./README-Korean.md)   |
  | Persian (فارسی)                             | [DrunkLeen](https://github.com/drunkleen), [Ar.dst](https://github.com/Ar-dst)               | UI and [README](./README-Persian.md)  |
  | Polish (Polski)                             | [Akuczaku](https://github.com/Akuczaku)                                                      | UI                                    |
  | Russian (Русский)                           | Oleg                                                                                         | UI                                    |
  | Serbian                                     | [rina](https://github.com/sweatshirts)                                                       | UI                                    |
  | Spanish (Español)                           | [enriiquee](https://github.com/enriiquee)                                                    | UI                                    |
  | Spanish Latam (Español Latam)               | [Matyrela](https://github.com/Matyrela)                                                      | UI                                    |
  | Thai (ภาษาไทย)                              | [teerut26](https://github.com/teerut26)                                                      | UI (partial)                          |
  | Turkish (Türkçe)                            | [mcagriaksoy](https://github.com/mcagriaksoy)                                                | UI and [README](./README-Turkish.md)  |
  | Ukrainian (Українська)                      | [AndrejGorodnij](https://github.com/AndrejGorodnij)                                          | UI                                    |
  | Vietnamese (Tiếng Việt)                     | [7777Hecker](https://github.com/7777Hecker)                                                  | UI                                    |

  > Want to add a translation for another language? follow the ["Add or Update a Translation" section in CONTRIBUTING.md](./CONTRIBUTING.md#add-or-update-a-translation).



  As of [PyInstaller v4.0](https://github.com/pyinstaller/pyinstaller/releases/tag/v4.0) released on Aug 9 2020, Python 2.7 is no longer supported; although you can still use this tool with Python 2.7 by installing an older version of PyInstaller. [PyInstaller v3.6](https://github.com/pyinstaller/pyinstaller/releases/tag/v3.6) was the last version that supported Python 2.7; to install this, first uninstall any existing versions of PyInstaller and then execute `python -m pip install pyinstaller==3.6`.



  Tests are located in `tests/` and are run using pytest:

  ```
  $ pip install pytest
  $ pip install -e .
  $ pytest
  ```



  | <!-- -->                                                                                                                                             | <!-- -->                                                                                                                              |
  | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
  | [![Empty interface](https://nitratine.net/posts/auto-py-to-exe/empty-interface.png)](https://nitratine.net/posts/auto-py-to-exe/empty-interface.png) | [![Filled out](https://nitratine.net/posts/auto-py-to-exe/filled-out.png)](https://nitratine.net/posts/auto-py-to-exe/filled-out.png) |
  | [![Converting](https://nitratine.net/posts/auto-py-to-exe/converting.png)](https://nitratine.net/posts/auto-py-to-exe/converting.png)                | [![Completed](https://nitratine.net/posts/auto-py-to-exe/completed.png)](https://nitratine.net/posts/auto-py-to-exe/completed.png)    |


pkgId: e7b3352f1a5216087809f5c8498d4ec3ad41553058f1562d1ccb48318593a766
name: python-auto-py-to-exe
arch: src
version: 2.45.0
epoch: 0
release: 1
summary: Converts .py to .exe using a simple graphical interface.
url: https://github.com/brentvollebregt/auto-py-to-exe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-py-to-exe-2.45.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Auto PY to EXE</h1>
  <p align="center">A .py to .exe converter using a simple graphical interface and <a href="https://pyinstaller.readthedocs.io/en/stable/index.html">PyInstaller</a> in Python.</p>

  <p align="center">
      <img src="https://nitratine.net/posts/auto-py-to-exe/feature.png" alt="Empty interface">
  </p>

  <p align="center">
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/v/auto-py-to-exe.svg" alt="PyPI Version"></a>
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/pyversions/auto-py-to-exe.svg" alt="PyPI Supported Versions"></a>
      <a href="https://pypi.org/project/auto-py-to-exe/"><img src="https://img.shields.io/pypi/l/auto-py-to-exe.svg" alt="License"></a>
      <a href="https://pepy.tech/project/auto-py-to-exe"><img src="https://static.pepy.tech/badge/auto-py-to-exe/month" alt="Downloads Per Month"></a>
      <a href="https://pyinstaller.readthedocs.io/en/stable/requirements.html"><img src="https://img.shields.io/badge/platform-windows%20%7C%20linux%20%7C%20macos-lightgrey" alt="Supported Platforms"></a>
      <a href="https://www.buymeacoffee.com/brentvollebregt"><img src="https://img.shields.io/badge/-buy_me_a%C2%A0beer-gray?logo=buy-me-a-coffee" alt="Donate"></a>
  </p>



  阅读中文版的 README ，点击 [这里](./README-Chinese.md)

  Suomenkieliset käyttöohjeet löydät [täältä](./README-Finnish.md)

  Türkçe Talimatları [burada](./README-Turkish.md) bulabilirsiniz.

  دستور العمل های [فارسی](./README-Persian.md)

  한국어로 된 설명은 [여기](./README-Korean.md)를 참고하세요.

  Български README [тук](README-Bulgarian.md)

  Беларускамоўны README [тут](README-Belarusian.md)



  <p align="center">
      <img src="https://nitratine.net/posts/auto-py-to-exe/auto-py-to-exe-demo.gif" alt="auto-py-to-exe Demo">
  </p>





  - Python: 3.6-3.12

  _To have the interface displayed in the images, you will need Chrome. If Chrome is not installed or `--default-browser` is passed, the default browser will be used._





  You can install this project using PyPI:

  ```
  $ pip install auto-py-to-exe
  ```

  Then to run it, execute the following in the terminal:

  ```
  $ auto-py-to-exe
  ```

  > If you have more than one version of Python installed, you can use `python -m auto_py_to_exe` instead of `auto-py-to-exe`.



  ```
  $ git clone https://github.com/brentvollebregt/auto-py-to-exe.git
  $ cd auto-py-to-exe
  $ python setup.py install
  ```

  Then to run it, execute the following in the terminal:

  ```
  $ auto-py-to-exe
  ```



  You can run this project locally by following these steps:

  1. Clone/download the [repo](https://github.com/brentvollebregt/auto-py-to-exe)
  2. Open cmd/terminal and cd into the project's root folder
  3. Execute `python -m pip install -r requirements.txt`
  4. Execute `python -m auto_py_to_exe` to run the application



  1. Select your script location (paste in or use a file explorer)
     - The outline will become blue if the file exists
  2. Select other options and add things like an icon or other files
  3. Click the big blue button at the bottom to convert
  4. Find your converted files in /output when completed

  _Easy._



  Use the help flag to get the usage: `auto-py-to-exe --help`

  | Argument                                                     | Type                | Description                                                                                                                       |
  | ------------------------------------------------------------ | ------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
  | filename                                                     | positional/optional | Pre-fill the "Script Location" field in the UI.                                                                                   |
  | -db, --default-browser                                       | optional            | Open the UI using the default browser (which may be Chrome). Will not try to find Chrome.                                         |
  | -nu, --no-ui                                                 | optional            | Don't try to open the UI in a browser and simply print out the address where the application can be accessed.                     |
  | -c [CONFIG], --config [CONFIG]                               | optional            | Provide a configuration file (JSON) to pre-fill the UI. These can be generated in the settings tab.                               |
  | -o [PATH], --output-dir [PATH]                               | optional            | Set the default output directory. This can still be changed in the UI.                                                            |
  | -bdo [FOLDER_PATH], --build-directory-override [FOLDER_PATH] | optional            | Override the default build directory. Useful if you need to whitelist a folder to stop your antivirus from removing files.        |
  | -lang [LANGUAGE_CODE], --language [LANGUAGE_CODE]            | optional            | Hint the UI what language it should default to when opening. Language codes can be found in the table under "Translations" below. |



  Instead of inserting the same data into the UI over and over again, you can export the current state by going to the "Configuration" section within the settings tab and exporting the config to a JSON file. This can then be imported into the UI again to re-populate all fields.

  This JSON config export action does not save the output directory automatically as moving hosts could mean different directory structures. If you want to have the output directory in the JSON config, add the directory under `nonPyinstallerOptions.outputDirectory` in the JSON file (will need to create a new key).



  The [examples/](./examples/) directory offers some examples of how to write your scripts and package them with auto-py-to-exe.

  - [Basic (console application)](./examples/1-basic/readme.md)
  - [No Console (as typically desired for GUI-based applications)](./examples/2-no-console/readme.md)
  - [Images and other non-.py files (static files to be included)](./examples/3-images-and-other-non-py-files/readme.md)
  - [Persistent data (like databases)](./examples/4-persistent-data/readme.md)



  If you need something visual to help you get started, [I made a video for the original release of this project](https://youtu.be/OZSZHmWSOeM); some things may be different but the same concepts still apply.



  Check out [CONTRIBUTING.md](./CONTRIBUTING.md) to see guidelines on how to contribute. This outlines what to do if you have a new feature, a change, translation update or have found an issue with auto-py-to-exe.



  If you're having issues with the packaged executable or using this tool in general, I recommend you read [my blog post on common issues when using auto-py-to-exe](https://nitratine.net/blog/post/issues-when-using-auto-py-to-exe/?utm_source=auto_py_to_exe&utm_medium=readme_link&utm_campaign=auto_py_to_exe_help). This post covers things you should know about packaging Python scripts and fixes for things that commonly go wrong.

  If you believe you've found an issue with this tool, please follow the ["Reporting an Issue" section in CONTRIBUTING.md](./CONTRIBUTING.md#reporting-an-issue).



  | Language                                    | Translator                                                                                   | Translated                            |
  | ------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------- |
  | Arabic (العربية)                            | [Tayeb-Ali](https://github.com/tayeb-ali)                                                    | UI                                    |
  | Belarusian (Беларуская)                     | [Zmicier21](https://github.com/Zmicier21)                                                    | UI and [README](README-Belarusian.md) |
  | Brazilian Portuguese (Português Brasileiro) | [marleyas](https://github.com/marleyas), [reneoliveirajr](https://github.com/reneoliveirajr) | UI                                    |
  | Bulgarian (Български)                       | [kbkozlev](https://github.com/kbkozlev)                                                      | UI and [README](README-Bulgarian.md)  |
  | Chinese Simplified (简体中文)               | [jiangzhe11](https://github.com/jiangzhe11)                                                  | UI and [README](./README-Chinese.md)  |
  | Chinese Traditional (繁體中文)              | [startgo](https://github.com/ystartgo)                                                       | UI                                    |
  | Czech (Čeština)                             | [Matto58](https://github.com/Matto58)                                                        | UI                                    |
  | Dutch (Nederlands)                          | [barremans](https://github.com/barremans)                                                    | UI                                    |
  | English                                     | -                                                                                            | UI and README                         |
  | Finnish (Suomen kieli)                      | [ZapX5](https://github.com/ZapX5)                                                            | UI and [README](./README-Finnish.md)  |
  | French (Français)                           | [flaviedesp](https://github.com/flaviedesp)                                                  | UI                                    |
  | German (Deutsch)                            | [hebens](https://github.com/hebens), [ackhh](https://github.com/ackhh)                       | UI                                    |
  | Greek (Ελληνικά)                            | [sofronas](https://github.com/sofronas)                                                      | UI                                    |
  | Hebrew (עברית)                              | [ronbentata](https://github.com/ronbentata)                                                  | UI and [README](./README-Hebrew.md)   |
  | Hindi (हिन्दी)                              | [triach-rold](https://github.com/triach-rold)                                                | UI and [README](./README-Hindi.md)    |
  | Indonesian (Bahasa Indonesia)               | [MarvinZhong](https://github.com/MarvinZhong)                                                | UI                                    |
  | Italian (Italiano)                          | [itsEmax64](https://github.com/itsEmax64)                                                    | UI                                    |
  | Japanese (日本語)                           | [NattyanTV](https://github.com/nattyan-tv)                                                   | UI                                    |
  | Korean (한국어)                             | [jhk1090](https://github.com/jhk1090)                                                        | UI and [README](./README-Korean.md)   |
  | Persian (فارسی)                             | [DrunkLeen](https://github.com/drunkleen), [Ar.dst](https://github.com/Ar-dst)               | UI and [README](./README-Persian.md)  |
  | Polish (Polski)                             | [Akuczaku](https://github.com/Akuczaku)                                                      | UI                                    |
  | Russian (Русский)                           | Oleg                                                                                         | UI                                    |
  | Serbian                                     | [rina](https://github.com/sweatshirts)                                                       | UI                                    |
  | Spanish (Español)                           | [enriiquee](https://github.com/enriiquee)                                                    | UI                                    |
  | Spanish Latam (Español Latam)               | [Matyrela](https://github.com/Matyrela)                                                      | UI                                    |
  | Thai (ภาษาไทย)                              | [teerut26](https://github.com/teerut26)                                                      | UI (partial)                          |
  | Turkish (Türkçe)                            | [mcagriaksoy](https://github.com/mcagriaksoy)                                                | UI and [README](./README-Turkish.md)  |
  | Ukrainian (Українська)                      | [AndrejGorodnij](https://github.com/AndrejGorodnij)                                          | UI                                    |
  | Vietnamese (Tiếng Việt)                     | [7777Hecker](https://github.com/7777Hecker)                                                  | UI                                    |

  > Want to add a translation for another language? follow the ["Add or Update a Translation" section in CONTRIBUTING.md](./CONTRIBUTING.md#add-or-update-a-translation).



  As of [PyInstaller v4.0](https://github.com/pyinstaller/pyinstaller/releases/tag/v4.0) released on Aug 9 2020, Python 2.7 is no longer supported; although you can still use this tool with Python 2.7 by installing an older version of PyInstaller. [PyInstaller v3.6](https://github.com/pyinstaller/pyinstaller/releases/tag/v3.6) was the last version that supported Python 2.7; to install this, first uninstall any existing versions of PyInstaller and then execute `python -m pip install pyinstaller==3.6`.



  Tests are located in `tests/` and are run using pytest:

  ```
  $ pip install pytest
  $ pip install -e .
  $ pytest
  ```



  | <!-- -->                                                                                                                                             | <!-- -->                                                                                                                              |
  | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
  | [![Empty interface](https://nitratine.net/posts/auto-py-to-exe/empty-interface.png)](https://nitratine.net/posts/auto-py-to-exe/empty-interface.png) | [![Filled out](https://nitratine.net/posts/auto-py-to-exe/filled-out.png)](https://nitratine.net/posts/auto-py-to-exe/filled-out.png) |
  | [![Converting](https://nitratine.net/posts/auto-py-to-exe/converting.png)](https://nitratine.net/posts/auto-py-to-exe/converting.png)                | [![Completed](https://nitratine.net/posts/auto-py-to-exe/completed.png)](https://nitratine.net/posts/auto-py-to-exe/completed.png)    |


pkgId: 2be68fa3faa43208c1fb11a4bf3a54886ad57a4a485233a29d8ec6adfe5f951b
name: python-auto-pytabs
arch: src
version: 0.5.0
epoch: 0
release: 1
url: https://pypi.org/project/auto-pytabs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-pytabs-0.5.0-1.src.rpm
checksum_type: sha256
summary:
  Automatically generate code examples for different Python versions in mkdocs or Sphinx based documentations

description:
      ```python
      from typing import Optional, Dict
      def foo(bar: Optional[str]) -> Dict[str, str]:


pkgId: 7fac2ac81c86529f115d6a2673f026bbe99feafdd9d06ca9bab00d8819560167
name: python-auto-shap
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Calculate SHAP values in parallel and automatically detect what explainer to use
url: https://github.com/micahmelling/auto-shap
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-shap-1.0.0-1.src.rpm
checksum_type: sha256
description:
  The auto-shap library is your best friend when calculating SHAP values!

  [SHAP](https://christophm.github.io/interpretable-ml-book/shap.html) is a
  state-of-the-art technique for explaining model predictions.
  Model explanation can be valuable in many regards. For one, understanding
  how a model devised a prediction can engender trust. Conversely, it could
  inform us if our model is using features in a nonsensical or unrealistic way,
  potentially helping us to catch leakage issues. Likewise, feature importance
  scores can be useful for external presentations. For further details on SHAP
  values and their underlying mathematical properties, see the hyperlink at the
  beginning of this paragraph.

  The Python [SHAP library](https://shap.readthedocs.io/en/latest/index.html)
  is often the go-to source for computing SHAP values. It's handy and can
  explain virtually any model we would like. However, we must be aware of the
  following when using the library.

  * The correct type of explainer class must be declared.
  * Our code for extracting SHAP values will be slightly different when we
  have a regression model compared to when we have a classifier.
  * SHAP cannot natively handel scikit-learn's CalibratedClassifierCV, voting models,
  or stacking models.
  * Boosting models often have distinct behavior when it comes to SHAP values. For
  boosting models, auto-shap will employ the SHAP settings to return probabilities.

  Likewise, the native SHAP library does not take advantage of multiprocessing.
  The auto-shap library will run SHAP calculations in parallel to speed them
  up when possible! When we are using a Tree or Linear Explainer, we can calculate our
  SHAP values in parallel without issue. The results will be the same compared
  to when we run our calculations on a single core. Such situations are heavily
  tested in tests/tests.py in the
  [GitHub Repo](https://github.com/micahmelling/auto-shap). However, the situation
  is slightly different when we are using the KernelExplainer. The KernelExplainer
  is not deterministic, even when we are not using parallel processing. In fact,
  especially on small datasets, if we re-run the KernelExplain back-to-back on the
  same data with the same model, we won't get the exact same feature-level attribution,
  though the total attribution will stay the same (which is tested in tests/tests.py).
  The foregoing points can be substantiated by looking at the
  [SHAP documentation](https://shap-lrjball.readthedocs.io/en/latest/generated/shap.KernelExplainer.html#shap.KernelExplainer.shap_values).
  [This article](https://edden-gerber.github.io/shapley-part-2/) discusses the deterministic
  nature of certain SHAP calculations.

  In auto-shap, we still employ multiprocessing when using the KernelExplainer, knowing
  that our results would still not be perfectly deterministic even on a single core,
  and by using multiprocessing, we get a nice speed improvement. To turn off
  multiprocessing in this case if desired, set n_jobs=1 when calling
  generate_shap_values(). See more details on this function call below.

  Additionally, there is a pickle error when using multiprocessing with a scikit-learn Voting or
  Stacking model with SHAP. Therefore, no multiprocessing is used in such cases.

  At a high level, the library will automatically detect the type of model
  that has been trained (regressor vs. classifier, boosting model vs. other
  model, etc.) and apply the correct handling. If your model is not accurately
  identified by the library, it's easy to specify how it should be handled.


  The easiest way to install the library is with pip.

  ```buildoutcfg
  $ pip3 install auto-shap
  ```

  Once installed, SHAP values can be calculated as follows.

  ```buildoutcfg
  $ python3
  >>> from auto_shap.auto_shap import generate_shap_values
  >>> from sklearn.datasets import load_breast_cancer
  >>> from sklearn.ensemble import ExtraTreesClassifier
  >>> x, y = load_breast_cancer(return_X_y=True, as_frame=True)
  >>> model = ExtraTreesClassifier()
  >>> model.fit(x, y)
  >>> shap_values_df, shap_expected_value, global_shap_df = generate_shap_values(model, x)
  ```

  There you have it!
  * A dataframe of SHAP values for every row in the x predictors dataframe.
  * The expected value of the SHAP explainer (in the above, the average
  predicted positive probability).
  * A dataframe of the global SHAP values covering every feature in the x dataframe.

  What's more, you can change to a completely new model without changing any
  of the auto-shap code.

  ```buildoutcfg
  $ python3
  >>> from auto_shap.auto_shap import generate_shap_values
  >>> from sklearn.datasets import load_diabetes
  >>> from sklearn.ensemble import GradientBoostingRegressor
  >>> x, y = load_diabetes(return_X_y=True, as_frame=True)
  >>> model = GradientBoostingRegressor()
  >>> model.fit(x, y)
  >>> shap_values_df, shap_expected_value, global_shap_df = generate_shap_values(model, x)
  ```
  auto-shap detected this was a boosted regressor and handled such a case
  appropriately.


  The library also provides a helper function for saving output and plots to a
  local directory.

  ```buildoutcfg
  $ python3
  >>> from auto_shap.auto_shap import produce_shap_values_and_summary_plots
  >>> from sklearn.datasets import load_diabetes
  >>> from sklearn.ensemble import GradientBoostingRegressor
  >>> x, y = load_diabetes(return_X_y=True, as_frame=True)
  >>> model = GradientBoostingRegressor()
  >>> model.fit(x, y)
  >>> produce_shap_values_and_summary_plots(model=model, x_df=x, save_path='shap_output')
  ```
  The above code will save three files into a "files" subdirectory in the specified
  save_path directory.
  * A csv of SHAP values for every row in x_df.
  * A txt file containing the expected value of the SHAP explainer.
  * A csv of the global SHAP values covering every feature in x_df.

  Likewise, two plots will be saved into a "plots" subdirectory.
  * A bar plot of the top global SHAP values.
  * A dot plot of SHAP values to show the influence of features across observations
  in x_df.


  By default, the maximum number of cores available is used to calculate SHAP
  values in parallel. To manually set the number of cores to use, you can do
  the following.

  ```buildoutcfg
  >>> generate_shap_values(model, x_df, n_jobs=4)
  ```

  For small datasets, multiprocessing may not add much in terms of performance and
  could even slow down computation times due to the overhead of spinning up a
  multiprocessing pool. To turn off multiprocessing, set n_jobs=1.


  Using generate_shap_values() or produce_shap_values_and_summary_plots() will
  leverage auto-detection of certain model characteristics. Those characteristics
  are as follows, which are all controlled with Booleans:
  * linear_model
  * tree_model
  * boosting_model
  * calibrated_model
  * regression_model
  * voting_or_stacking_model

  Though auto-shap will natively handle most common models, it is not yet
  tuned to handle every possible type of model. Therefore, in some cases, you may
  have to manually set one or more of the above Booleans in the function calls.
  At present and at minimum, auto-shap will work with the following models.
  * XGBClassifier
  * XGBRegressor
  * CatBoostClassifier
  * CatBoostRegressor
  * LGBMClassifier
  * LGBMRegressor
  * ExtraTreesClassifier
  * ExtraTreesRegressor
  * GradientBoostingClassifier
  * GradientBoostingRegressor
  * RandomForestClassifier
  * RandomForestRegressor
  * ElasticNet
  * Lasso
  * LinearRegression
  * LogisticRegression
  * Ridge
  * DecisionTreeClassifier
  * DecisionTreeRegressor
  * VotingClassifier
  * VotingRegressor
  * StackingClassifier
  * StackingRegressor

  For models cannot detect model qualities, it will fallback to using the
  Kernel Explainer, which is model agnostic.


  The auto-shap library provides support for scikit-learn's CalibratedClassifierCV.
  This implementation will extract the SHAP values for every base estimator in the
  calibration ensemble. The SHAP values will then be averaged. For details on the
  CalibratedClassifierCV, please go to the
  [documentation](https://scikit-learn.org/stable/modules/generated/sklearn.calibration.CalibratedClassifierCV.html).
  Since we are extracting only the SHAP values for the base estimator, we will miss
  some detail since we are not using the full calibrator pair. Therefore, while
  these SHAP values will still be instructive, they will not be perfectly precise.
  For more precision, we would need to use the KernelExplainer. The main benefit of
  averaging the results of the base estimators is computational as the
  KernelExplainer can be quite slow.

  To use KernelShap, one can do the following. More or less, this will ignore the
  auto-generated model qualities.

  ```buildoutcfg
  >>> generate_shap_values(model, x_df, use_kernel=True)
  ```

  Since the Kenel Explainer can be computationally expensive, x_df can be subsampled
  by either the sample_size or the k parameters. The former will take random samples,
  and the latter will take k-means summarized samples.


  If auto-shap detects a voting or stacking model, it will automatically use the
  Kernel Explainer. The Kernel SHAP is computationally expensive, so you may
  want to use a sample of x_df or use the previously-discussed arguments.

  Additionally, there is a pickle error when using
  multiprocessing with a scikit-learn Voting or Stacking model with SHAP. Therefore, no
  multiprocessing is used in such cases, which is more motivation for subsetting
  x_df.


  The generate_shap_values function relies on a few underlying functions that can
  be accessed directly and have the corresponding arguments and datatypes.

  ```buildoutcfg
  get_shap_expected_value(explainer: callable, boosting_model: bool, linear_model) -> float

  generate_shap_global_values(shap_values: np.array, x_df: pd.DataFrame) -> pd.DataFrame

  def produce_shap_output_with_agnostic_explainer(model: callable, x_df: pd.DataFrame, boosting_model: bool,
                                                  regression_model: bool, linear_model: bool,
                                                  return_df: bool = True, n_jobs: int = None,
                                                  sample_size: int = None, k: int = None) -> tuple

  produce_shap_output_with_tree_explainer(model: callable, x_df: pd.DataFrame, boosting_model: bool,
                                          regression_model: bool, linear_model: bool,
                                          return_df: bool = True, n_jobs: int = None) -> tuple

  produce_shap_output_with_linear_explainer(model: callable, x_df: pd.DataFrame, regression_model: bool,
                                            linear_model: bool, return_df: bool = True, n_jobs: int = None) -> tuple

  produce_shap_output_for_calibrated_classifier(model: callable, x_df: pd.DataFrame, boosting_model: bool,
                                                linear_model: bool, n_jobs: int = None) -> tuple

  def produce_raw_shap_values(model: callable, x_df: pd.DataFrame, use_agnostic: bool, linear_model: bool,
                              tree_model: bool, calibrated_model: bool, boosting_model: bool, regression_model: bool,
                              voting_or_stacking_model: bool = False, n_jobs: int = None, sample_size: int = None,
                              k: int = None) -> tuple


  generate_shap_summary_plot(shap_values: np.array, x_df: pd.DataFrame, plot_type: str, save_path: str,
                             file_prefix: str = None)
  ```


  Enjoy explaining your models with auto-shap! Feel free to report any issues.


pkgId: 7b154d28cdda5d4d2ba797aa5ce0e4e694b48b979aafd093236f64a2f4226757
name: python-auto-sklearn
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Automated machine learning.
url: https://automl.github.io/auto-sklearn
rpm_license: BSD3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-sklearn-0.15.0-1.src.rpm
checksum_type: sha256
description:
  **Auto-Sklearn 2.0: The Next Generation**
  *Matthias Feurer, Katharina Eggensperger, Stefan Falkner, Marius Lindauer and Frank Hutter**
  arXiv:2007.04074 [cs.LG], 2020
  [Link](https://arxiv.org/abs/2007.04074) to publication.
  ```
  @article{feurer-arxiv20a,
      title     = {Auto-Sklearn 2.0: Hands-free AutoML via Meta-Learning},
      author    = {Feurer, Matthias and Eggensperger, Katharina and Falkner, Stefan and Lindauer, Marius and Hutter, Frank},
      booktitle = {arXiv:2007.04074 [cs.LG]},
      year      = {2020}
  }


pkgId: 23c0db48c05d0f502cbac769bae3fc6572a45f9f7ee6d373b941a0ab4840e692
name: python-auto-stretch
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Stretch linear astro data for easier visualization.
url: https://pypi.org/project/auto-stretch/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-stretch-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Automatically stretch astronomical images in numpy array format. Useful for creating easy-to-see, non-linear jpgs from fits files.

  linear (no stretch) | arcsin stretch | auto-stretch (using this library)
  :-:|:-:|:-:
  ![unstretched image](img/linear.jpg) | ![arcsin stretch](img/arcsin.jpg) | ![auto-stretched image](img/auto-stretch.jpg)



  `$ pip install auto-stretch`



  The stretch function operates on numpy arrays. Example use:

  ```python
  import numpy as np
  import astropy
  from auto_stretch import apply_stretch

  image = np.array([[1,2],[3,1]])
  stretched_image = apply_stretch(image)
  print(stretched_image)




  ```


pkgId: 739a9dce6c8f2fac7c4885ba8f2c7b8cb028e12cf27372f1837efc0760e19349
name: python-auto-tensorflow
arch: src
version: 1.3.4
epoch: 0
release: 1
url: https://github.com/rafiqhasan/auto-tensorflow
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-tensorflow-1.3.4-1.src.rpm
checksum_type: sha256
summary:
  Build Low Code Automated Tensorflow, What-IF explainable models in just 3 lines of code. To make Deep Learning on Tensorflow absolutely easy for the masses with its low code framework and also increase trust on ML models through What-IF model explainability.

description:
  <img src="/logo.png" width="100%"/>

  [![Downloads](https://static.pepy.tech/personalized-badge/auto-tensorflow?period=total&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/auto-tensorflow)
  [![Generic badge](https://img.shields.io/pypi/v/auto-tensorflow.svg?logo=pypi&logoColor=white&color=orange)](https://pypi.org/project/auto-tensorflow/)
  ![Generic badge](https://img.shields.io/badge/python-v3.6%20%7C%203.7%20%7C%203.8-blue)
  ![example workflow](https://github.com/rafiqhasan/auto-tensorflow/actions/workflows/codeql-analysis.yml/badge.svg)
  ![Open issues](https://img.shields.io/github/issues-raw/rafiqhasan/auto-tensorflow?color=red)


  **Build Low Code Automated Tensorflow, What-IF explainable models in just 3 lines of code.**

  To make Deep Learning on Tensorflow absolutely easy for the masses with its low code framework and also increase trust on ML models through What-IF model explainability.


  Built on top of the powerful **Tensorflow** ecosystem tools like **TFX** , **TF APIs** and **What-IF Tool** , the library automatically does all the heavy lifting internally like EDA, schema discovery, feature engineering, HPT, model search etc. This empowers developers to focus only on building end user applications quickly without any knowledge of Tensorflow, ML or debugging. Built for handling large volume of data / BigData - using only TF scalable components. Moreover the models trained with auto-tensorflow can directly be deployed on any cloud like GCP / AWS / Azure.

  <img src="/header.png" width="100%"/>




  1. Build Classification / Regression models on CSV data
  2. Automated Schema Inference
  3. Automated Feature Engineering
      - Discretization
      - Scaling
      - Normalization
      - Text Embedding
      - Category encoding
  5. Automated Model build for mixed data types( Continuous, Categorical and Free Text )
  6. Automated Hyper-parameter tuning
  7. Automated GPU Distributed training
  8. Automated UI based What-IF analysis( Fairness, Feature Partial dependencies, What-IF )
  9. Control over complexity of model
  10. No dependency over Pandas / SKLearn
  11. Can handle dataset of any size - including multiple CSV files


  1. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/rafiqhasan/auto-tensorflow/blob/main/tutorials/TFAuto_%7C_Classification.ipynb) - Auto Classification on CSV data
  2. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/rafiqhasan/auto-tensorflow/blob/main/tutorials/TFAuto_%7C_Regression.ipynb) - Auto Regression on CSV data


  1. Install library
      - PIP(Recommended): ```pip install auto-tensorflow```
      - Nightly: ```pip install git+https://github.com/rafiqhasan/auto-tensorflow.git```
  2. Works best on UNIX/Linux/Debian/Google Colab/MacOS


  1. Initialize TFAuto Engine
  ```
  from auto_tensorflow.tfa import TFAuto
  tfa = TFAuto(train_data_path='/content/train_data/', test_data_path='/content/test_data/', path_root='/content/tfauto')
  ```

  2. Step 1 - Automated EDA and Schema discovery
  ```
  tfa.step_data_explore(viz=True) ##Viz=False for no visualization
  ```

  3. Step 2 - Automated ML model build and train
  ```
  tfa.step_model_build(label_column = 'price', model_type='REGRESSION', model_complexity=1)
  ```

  4. Step 3 - Automated What-IF Tool launch
  ```
  tfa.step_model_whatif()
  ```


  - Method **TFAuto**
    - ```train_data_path```: Path where training data is stored
    - ```test_data_path```: Path where Test / Eval data is stored
    - ```path_root```: Directory for running TFAuto( Directory should NOT exist )

  - Method **step_data_explore**
    - ```viz```: Is data visualization required ? - True or False( Default )

  - Method **step_model_build**
    - `label_column`: The feature to be used as Label
    - `model_type`: Either of 'REGRESSION'( Default ), 'CLASSIFICATION'
    - `model_complexity`:
      - `0` : Model with default hyper-parameters
      - `1` (Default): Model with automated hyper-parameter tuning
      - `2` : Complexity 1 + Advanced fine-tuning of Text layers


  There are a few limitations in the initial release but we are working day and night to resolve these and **add them as future features**.
  1. Doesn't support Image / Audio data


  1. Add support for Timeseries / Audio / Image data
  2. Add feature to download full pipeline model Python code for advanced tweaking


  **1.3.3** - 09/12/2022 - [Release Notes](https://github.com/rafiqhasan/auto-tensorflow/releases/tag/1.3.3)

  **1.3.2** - 27/11/2021 - [Release Notes](https://github.com/rafiqhasan/auto-tensorflow/releases/tag/1.3.2)

  **1.3.1** - 18/11/2021 - [Release Notes](https://github.com/rafiqhasan/auto-tensorflow/releases/tag/1.3.1)

  **1.2.0** - 24/07/2021 - [Release Notes](https://github.com/rafiqhasan/auto-tensorflow/releases/tag/1.2.0)

  **1.1.1** - 14/07/2021 - [Release Notes](https://github.com/rafiqhasan/auto-tensorflow/releases/tag/1.1.1)

  **1.0.1** - 07/07/2021 - [Release Notes](https://github.com/rafiqhasan/auto-tensorflow/releases/tag/1.0.1)


pkgId: cd46c08020a6d8d0e1ec99a8ec4f53fef45a9fb952f9052d0b5bf3139b01b51a
name: python-auto-ts
arch: src
version: 0.0.92
epoch: 0
release: 1
summary: Automatically Build Multiple Time Series models fast - now with Facebook Prophet!
url: https://github.com/AutoViML/Auto_TS
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-ts-0.0.92-1.src.rpm
checksum_type: sha256
description:
  <h1 id="auto-ts">Auto_TS: Auto_TimeSeries</h1>
  <p style="font-family:verdana">Automatically build multiple Time Series models using a Single Line of Code. Now updated with Dask.

  ![auto-ts](images/logo.png)

  `auto_timeseries` is a complex model building utility for time series data. Since it automates many
  Tasks involved in a complex endeavor, it assumes many intelligent defaults. But you can change them.
  Auto_Timeseries will rapidly build predictive models based on Statsmodels ARIMA, Seasonal ARIMA, Prophet
  and Scikit-Learn ML. It will automatically select the best model which gives best score specified.


  <ul>
  <li><a href="#Latest">Latest updates</a></li>
  <li><a href="#Citation">Citation</a></li>
  <li><a href="#introduction">What is auto_ts</a></li>
  <li><a href="#install">How to install auto_ts</a></li>
  <li><a href="#usage">Usage</a></li>
  <li><a href="#requirements">Requirements</a></li>
  <li><a href="#tips">Tips</a></li>
  <li><a href="#license">License</a></li>
  <li><a href="#copyright">Copyright</a></li>
  <li><a href="#disclaimer">Disclaimer</a></li>
  </ul>


  If you are looking for the latest and greatest updates about our library, check out our [updates page](https://github.com/AutoViML/Auto_TS/blob/master/updates.md).
  <br>


  If you use Auto_TS in your research project or paper, please use the following format for citations:

  "Seshadri, Ram (2020). GitHub - AutoViML/Auto_TS: enables you to build and deploy multiple time series models using ML and statistical techniques with a single line of code. Source code: https://github.com/AutoViML/Auto_TS"

  <h2 id="introduction">Introduction</h2>

  Auto_TS (Auto_TimeSeries) enables you to build and select multiple time series models using techniques such as ARIMA, SARIMAX, VAR, decomposable (trend+seasonality+holidays) models, and ensemble machine learning models.

  Auto_TimeSeries is an Automated ML library for time series data. Auto_TimeSeries was initially conceived and developed by [Ram Seshadri](https://www.linkedin.com/in/ram-seshadri-nyc-nj/) and was significantly expanded in functionality and scope and upgraded to its present status by [Nikhil Gupta](https://github.com/ngupta23).

  auto-ts.Auto_TimeSeries is the main function that you will call with your train data. You can then choose what kind of models you want: stats, ml or Prophet based model. You can also tell it to automatically select the best model based on the scoring parameter you want it to be based on. It will return the best model and a dictionary containing predictions for the number of forecast_periods you mentioned (default=2).



  ```bash
  pip install auto-ts
  ```

  Use `pip3 install auto-ts` if the above doesn’t work

  ```bash
  pip install git+https://github.com/AutoViML/Auto_TS.git
  ```


  If you are using Colab or Kaggle kernel and want to install auto_ts, please use the following steps (otherwise you will get an error!):

  ```
  !pip install auto-ts --no-deps --ignore-installed
  !pip install 'fsspec>=0.3.3'
  !pip install statsmodels --upgrade
  !pip install pmdarima
  ```

  ![auto_ts_colab](images/install_auto_ts.png)



  Windows users may experience difficulties with the Prophet and pystan dependency installations.  Because of this, we recommend installing Prophet using instructions from the [Prophet documentation page](https://facebook.github.io/prophet/docs/installation.html) prior to installing auto-ts.  For Anaconda users, this can be accomplished via:
  ```bash
  conda install -c conda-forge prophet
  pip install auto-ts
  ```

  <h2 id="usage">Usage</h2>



  ```py
  from auto_ts import auto_timeseries
  ```



  ```py
  model = auto_timeseries(
      score_type='rmse',
      time_interval='Month',
      non_seasonal_pdq=None, seasonality=False,
      seasonal_period=12,
      model_type=['Prophet'],
      verbose=2,
  )
  ```



  - **score_type (default='rmse')**: The metric used for scoring the models. Type is string.
  Currently only the following two types are supported:
    1. "rmse": Root Mean Squared Error (RMSE)
    1. "normalized_rmse": Ratio of RMSE to the standard deviation of actuals
  - **time_interval (default is None)**: Used to indicate the frequency at which the data is collected.
  This is used for two purposes (1) in building the Prophet model and (2) used to impute the seasonal period for SARIMAX in case it is not provided by the user (None). Type is String. We use the following [pandas date range frequency](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases) aliases that Prophet uses to make the prediction dataframe. <p>Hence, please note that these are the list of allowed aliases for frequency:
            `['B','C','D','W','M','SM','BM','CBM',
           'MS','SMS','BMS','CBMS','Q','BQ','QS','BQS',
           'A,Y','BA,BY','AS,YS','BAS,BYS','BH',
           'H','T,min','S','L,ms','U,us','N']`
  For a start, you can test the following codes for your data and see how the results are (or you can leave it as None and auto_timeseries will try and impute it for you):
    - `'MS', 'M', 'SM', 'BM', 'CBM', 'SMS', 'BMS'` for monthly frequency data
    - `'D', 'B', 'C'` for daily frequency data
    - `'W'` for weekly frequency data
    - `'Q', 'BQ', 'QS', 'BQS'` for quarterly frequency data
    - `'A,Y', 'BA,BY', 'AS,YS', 'BAS,YAS'` for yearly frequency data
    - `'BH', 'H', 'h'` for hourly frequency data
    - `'T,min'` for minute frequency data
    - `'S', 'L,milliseconds', 'U,microseconds', 'N,nanoseconds'` for second frequency data
  - **non_seasonal_pdq (default = (3,1,3))**: Indicates the maximum value of (p, d, q) to be used in the search for statistical ARIMA models.
  If None, then the following values are assumed `max_p = 3, max_d = 1, max_q = 3`. Type is Tuple.
  - **seasonality (default=False)**: Used in the building of the SARIMAX model only at this time. True or False. Type is bool.
  - **seasonal_period (default is None)**: Indicates the seasonal period in your data. This depends on the peak (or valley) period that occurs regularly in your data.
  Used in the building of the SARIMAX model only at this time.
  There is no impact of this argument if seasonality is set to False
  If None, the program will try to infer this from the time_interval (frequency) of the data
  We assume the following as defaults but feel free to change them.
      1. If frequency is Monthly, then seasonal_period is assumed to be 12
      1. If frequency is Daily, then seasonal_period is assumed to be 30 (but it could be 7)
      1. If frequency is Weekly, then seasonal_period is assumed to be 52
      1. If frequency is Quarterly, then seasonal_period is assumed to be 4
      1. If frequency is Yearly, then seasonal_period is assumed to be 1
      1. If frequency is Hourly, then seasonal_period is assumed to be 24
      1. If frequency is Minutes, then seasonal_period is assumed to be 60
      1. If frequency is Seconds, then seasonal_period is assumed to be 60
  Type is integer
  - **conf_int (default=0.95)**: Confidence Interval for building the Prophet model. Default: 0.95. Type is float.
  - **model_type (default: 'stats'**: The type(s) of model to build. Default to building only statistical models. If a list is provided, then only those models will be built. Can be a string or a list of models. Allowed values are:
  `'best', 'prophet', 'stats', 'ARIMA', 'SARIMAX', 'VAR', 'ML'`.
    - `"prophet"` will build a model using Prophet -> this means you must have Prophet installed
    - `"stats"` will build statsmodels based ARIMA, SARIMAX and VAR models
    - `"ML"` will build a machine learning model using Random Forests provided explanatory vars are given
    - `"best"` will try to build all models and pick the best one
  - **verbose (default=0)**: Indicates the verbosity of printing. Type is integer.

  WARNING: "best" might take some time for large data sets. We recommend that you
  choose a small sample from your data set before attempting to run entire data.



  ```py
  model.fit(
      traindata=train_data,
      ts_column=ts_column,
      target=target,
      cv=5,
      sep=","
  )
  ```

  Here are how the parameters defined:
  - **traindata (required)**: It can be either a dataframe or a file. You must give the name of the file along with its data path in case if a file. It also accepts a pandas dataframe in case you already have a dataframe loaded in your notebook.
  - **ts_column (required)**: name of the datetime column in your dataset (it could be a name of column or index number in the columns index).
  - **target (required)**: name of the column you   are trying to predict. Target could also be the only column in your dataset.
  - **cv (default=5)**: You can enter any integer for the number of folds you want in your cross validation data set.
  - **sep (default=",")**: Sep is the separator in your traindata file. If your separator is ",", "\t", ";", make sure you enter it here. If not, it is ignored.



  ```py
  predictions = model.predict(
      testdata = ...,  # can be either a dataframe or an integer standing for the forecast_period,
      model = 'best'  # or any other string that stands for the trained model
  )
  ```

  Here are how the parameters are defined. You can choose to send either testdata in the form of a dataframe or send in an integer to decide how many periods you want to forecast. You need only
  - **testdata (required)**: It can be either a dataframe containing test data or you can use an integer standing for the forecast_period (you want).
  - **model (optional, default = 'best')**: The name of the model you want to use among the many different models you have trained. Remember that the default is the best model. But you can choose any model that you want to forecast with. Type is String.

  <h2 id="requirements">Requirements</h2>
  dask, scikit-learn, prophet, statsmodels, pmdarima, XGBoost

  <h2 id="license">License:</h2>
  Apache License 2.0

  <h2 id="Tips">Tips</h2>

  - We recommend that you choose a small sample from your data set before attempting to run entire data. and the evaluation metric, so it can select the best model. Currently models within “stats” are compared using AIC and BIC. However, models across different types are compared using RMSE. The results of models are shown using RMSE and Normalized RMSE (ratio of RMSE to the standard deviation of actuals).
  - You must clean the data and not have any missing values. Make sure the target variable is numeric, otherwise, it won’t run. If there is more than one target variable in your data set, just specify only one for now, and if you know the time interval that is in your data, you can specify it. Otherwise it auto-ts will try to infer the time interval on its own.
  - If you give Auto_Timeseries a different time interval than what the data has, it will automatically resample the data to the given time interval and use the mean of the target for the resampled period.
  - Notice that except for filename and ts_column input arguments, which are required, all other arguments are optional.
  - Note that optionally you can give a separator for the data in your file. Default is comma (",").
  - “time_interval” options are any codes that you can find in this page below.
  [Pandas date-range frequency aliases](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases)
  - Optionally, you can give seasonal_period as any integer that measures the seasonality in the data. If not given, seasonal_period is assumed automatically as follows:
    - Months = 12,
    - Days = 30,
    - Weeks = 52,
    - Qtr = 4,
    - Year = 1,
    - Hours = 24,
    - Minutes = 60 and
    - Seconds = 60.
  - If you want to give your own non-seasonal order, please input it as non_seasonal_pdq and for seasonal order, use seasonal_PDQ as the input. Use tuples. For example, `seasonal_PDQ = (2,1,2)` and `non_seasonal_pdq = (0,0,3)`. It will accept only tuples. The default is None and Auto_Timeseries will automatically search for the best p,d,q (for Non Seasonal) and P, D, Q (for Seasonal) orders by searching for all parameters from 0 to 12 for each value of p,d,q and 0-3 for each P, Q and 0-1 for D.

  <h2 id="disclaimer">DISCLAIMER:</h2>

  This is not an Officially supported Google project.

  <h2 id="copyright">Copyright</h2>

  © Google


pkgId: e49428fa88da60fc6f8cc39d148b27267e6b5403d4595b4b2e49f81dcbf15e34
name: python-auto-typing-final
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Automagically set typing.Final inside your functions
url: https://pypi.org/project/auto-typing-final/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-typing-final-0.7.2-1.src.rpm
checksum_type: sha256
description:
  Auto-fixer for Python code that adds `typing.Final` annotation to variable assignments inside functions that are not reassigned, and removes the annotation from variables that _are_ mutated.

  ```diff
   def foo() -> None:
  -    a = 2
  +    a: typing.Final = 2

  -    b: typing.Final = 2
  +    b = 2
       b = 3
  ```

  Basically, this, but handles different operations (like usage of `nonlocal`, augmented assignments: `+=`, etc) as well.

  - Keeps mypy happy.
  - Ignores global variables to avoid confusion with the type aliases like `Fruit = Apple | Banana`.
  - Ignores class variables: it is common to use `typing.ClassVar` instead of `typing.Final`.
  - Adds global import if it's not imported yet.
  - Inspects one file at a time.



  Having uv installed:

  ```sh
  uvx auto-typing-final .
  ```

  or:

  ```sh
  pipx run auto-typing-final .
  ```




  You can specify `--check` flag to check the files instead of actually fixing them:

  ```sh
  auto-typing-final . --check
  ```

  Also, you can choose import style from two options: `typing-final` (default) and `final`:

  ```sh
  auto-typing-final . --import-style typing-final
  ```

  - `typing-final` enforces `import typing` and `typing.Final`,
  - `final` enforces `from typing import Final` and `Final`.




  <img width="768" alt="image" src="https://github.com/vrslev/auto-typing-final/assets/75225148/f1541056-06f5-4caa-8c94-0a5eaf98ba15">

  The extension uses LSP server bundled with the CLI. To get started, add `auto-typing-final` to your project:

  ```sh
  uv add auto-typing-final --dev
  ```

  or:

  ```sh
  poetry add auto-typing-final --group=dev
  ```

  After that, install the extension: https://marketplace.visualstudio.com/items?itemName=vrslev.auto-typing-final. In Python environments that have `auto-typing-final` installed, extension will be activated automatically.

  Import style can be configured in settings: `"auto-typing-final.import-style": "typing-final"` or `"auto-typing-final.import-style": "final"`.

  Library code of currently activated environment will be ignored (for example, `.venv/bin/python` is active interpreter, all code inside `.venv` will be ignored).


pkgId: f20b613f150758a76046495e9045139bb0f7f0d48166b9b6cbb153d4f02cb73c
name: python-auto-uncertainties
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Linear Uncertainty Propagation with Auto-Differentiation
url: https://pypi.org/project/auto-uncertainties/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-uncertainties-0.5.0-1.src.rpm
checksum_type: sha256
description:
  AutoUncertainties is a package that makes handling linear uncertainty propagation for scientific applications straightforward and automatic using auto-differentiation.
  Supported Features

  ☑ Scalars
  ☑ Arrays, with support for most NumPy ufuncs and functions
  ☐ Pandas Extension Type


pkgId: 1dde38abb89959d829aed7821c1159ec96b2281c5347074228e2fac2176c974f
name: python-auto-uncertainties
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Linear Uncertainty Propagation with Auto-Differentiation
url: https://pypi.org/project/auto-uncertainties/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-uncertainties-0.6.0-1.src.rpm
checksum_type: sha256
description:
  AutoUncertainties is a package that makes handling linear uncertainty propagation for scientific applications
  straightforward and automatic using auto-differentiation.

  * View the [full documentation here](https://autouncertainties.readthedocs.io/en/latest/).



  - [x] Scalars
  - [x] Arrays, with support for most NumPy ufuncs and functions
  - [x] Integration with [Pint](https://pint.readthedocs.io/en/stable/user/defining-quantities.html) Quantity objects
  - [ ] Pandas Extension Type (see [here](https://pandas.pydata.org/docs/reference/api/pandas.api.extensions.ExtensionDtype.html))



  For array support:

  * `jax`
  * `jaxlib`
  * `numpy`




  To install, simply run:

  ```
  pip install auto_uncertainties
  ```



  To build the documentation locally, clone the repository, create a virtual Python environment
  (if desired), and run the following commands within the repository directory:

  ```bash
  pip install auto_uncertainties[docs]
  sphinx-build docs/source docs/build
  ```

  Once built, the docs can be found under the `docs/build` subdirectory.



  * Creating a scalar `Uncertainty` variable is relatively simple:

    ```python
    >>> from auto_uncertainties import Uncertainty
    >>> value = 1.0
    >>> error = 0.1
    >>> u = Uncertainty(value, error)
    >>> u
    1 +/- 0.1
    ```

    As is creating a `numpy` array of Uncertainties:

    ```python
    >>> from auto_uncertainties import Uncertainty
    >>> import numpy as np
    >>> value = np.linspace(start=0, stop=10, num=5)
    >>> error = np.ones_like(value)*0.1
    >>> u = Uncertainty(value, error)
    ```

    - (though, they are actually different classes!)

      ```python
      >>> from auto_uncertainties import Uncertainty
      >>> value = 1.0
      >>> error = 0.1
      >>> u = Uncertainty(value, error)
      >>> type(u)
      <class 'auto_uncertainties.uncertainty.uncertainty_containers.ScalarUncertainty'>
      ```

      ```python
      >>> from auto_uncertainties import Uncertainty
      >>> import numpy as np
      >>> value = np.linspace(start=0, stop=10, num=5)
      >>> error = np.ones_like(value)*0.1
      >>> u = Uncertainty(value, error)
      >>> type(u)
      <class 'auto_uncertainties.uncertainty.uncertainty_containers.VectorUncertainty'>
      ```

  * Scalar uncertainties implement all mathematical and logical
    [dunder methods](https://docs.python.org/3/reference/datamodel.html#object.__repr__>) explicitly using linear
    uncertainty propagation.

    ```python
    >>> from auto_uncertainties import Uncertainty
    >>> u = Uncertainty(10.0, 3.0)
    >>> v = Uncertainty(20.0, 4.0)
    >>> u + v
    30 +/- 5
    ```

  * Array uncertainties implement a large subset of the numpy ufuncs and methods using `jax.grad` or
    `jax.jacfwd`, depending on the output shape.

    ```python
    >>> from auto_uncertainties import Uncertainty
    >>> import numpy as np
    >>> value = np.linspace(start=0, stop=10, num=5)
    >>> error = np.ones_like(value)*0.1
    >>> u = Uncertainty(value, error)
    >>> np.exp(u)
    [1 +/- 0.1, 12.1825 +/- 1.21825, 148.413 +/- 14.8413, 1808.04 +/- 180.804, 22026.5 +/- 2202.65]
    >>> np.sum(u)
    25 +/- 0.223607
    >>> u.sum()
    25 +/- 0.223607
    >>> np.sqrt(np.sum(error**2))
    0.223606797749979
    ```

  * The central value, uncertainty, and relative error are available as attributes:

    ```python
    >>> from auto_uncertainties import Uncertainty
    >>> u = Uncertainty(10.0, 3.0)
    >>> u.value
    10.0
    >>> u.error
    3.0
    >>> u.rel
    0.3
    ```

  * To strip central values and uncertainty from arbitrary variables, accessor functions `nominal_values`
    and `std_devs` are provided:

    ```python
    >>> from auto_uncertainties import nominal_values, std_devs
    >>> u = Uncertainty(10.0, 3.0)
    >>> v = 5.0
    >>> nominal_values(u)
    10.0
    >>> std_devs(u)
    3.0
    >>> nominal_values(v)
    5.0
    >>> std_devs(v)
    0.0
    ```

  * Displayed values are automatically rounded according to the Particle Data Group standard.
    This can be turned off using `set_display_rounding`:

    ```python
    >>> from auto_uncertainties import set_display_rounding
    >>> set_display_rounding(False)
    >>> from auto_uncertainties import Uncertainty
    >>> import numpy as np
    >>> value = np.linspace(start=0, stop=10, num=5)
    >>> error = np.ones_like(value)*0.1
    >>> u = Uncertainty(value, error)
    >>> np.sum(u)
    25 +/- 0.223607
    ```

  * If `numpy.array` is called on an `Uncertainty` object, it will automatically get cast down to a numpy array (and lose
    uncertainty information!), and emit a warning. To make this an error, use `set_downcast_error`:

    ```python
    >>> from auto_uncertainties import set_downcast_error
    >>> set_downcast_error(True)
    >>> from auto_uncertainties import Uncertainty
    >>> import numpy as np
    >>> value = np.linspace(start=0, stop=10, num=5)
    >>> error = np.ones_like(value)*0.1
    >>> u = Uncertainty(value, error)
    >>> np.array(u)
    Traceback (most recent call last):
        ...
    auto_uncertainties.exceptions.DowncastError: The uncertainty is stripped when downcasting to ndarray.
    ```



  The class structure of `Uncertainty`, and the `numpy` ufunc implementation is heavily inspired by the
  excellent package [Pint](https://github.com/hgrecco/pint).


pkgId: 48faa31c37a90b397124ba857e0df762d1a9459cd3c2d64e0b6de454f4a80e94
name: python-auto-unpack
arch: src
version: 2.11.0
epoch: 0
release: 1
summary: 压缩包自动解压工具，支持多种压缩包格式。通过组合各种插件，编排流程，则可满足日常解压需求。
url: https://github.com/xiaohuohumax/auto-unpack#readme
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-unpack-2.11.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/xiaohuohumax/auto-unpack/main/logo.png">
      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/xiaohuohumax/auto-unpack/main/logo-dark.png">
      <img alt="auto-unpack" src="https://raw.githubusercontent.com/xiaohuohumax/auto-unpack/main/logo.png">
    </picture>

    <div>
      <img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/xiaohuohumax/auto-unpack/publish-package.yaml?label=Build">
      <img alt="GitHub Issues" src="https://img.shields.io/github/issues/xiaohuohumax/auto-unpack?label=Issues">
      <img alt="GitHub Pull Requests" src="https://img.shields.io/github/issues-pr/xiaohuohumax/auto-unpack?label=Pull%20Requests">
      <img alt="PyPI - License" src="https://img.shields.io/pypi/l/auto-unpack?label=License">
      <img alt="PyPI - Version" src="https://img.shields.io/pypi/v/auto-unpack?label=PyPi">
      <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/auto-unpack?label=PyPi%20Downloads">
      <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/xiaohuohumax/auto-unpack">
      <img alt="GitHub forks" src="https://img.shields.io/github/forks/xiaohuohumax/auto-unpack">
    </div>
  </div>



  **压缩包自动解压工具，支持多种压缩包格式。通过组合各种内置插件，编排解压流程，则可满足日常解压需求。**



  + 新流程请先测试，确保功能正常，防止压缩包处理意外造成重要数据丢失或损坏。
  + 项目处于开发阶段，使用时最好限定版本，避免因版本更新导致功能异常。
  + 欢迎提出宝贵建议[🚧](https://github.com/xiaohuohumax/auto-unpack/pulls)，反馈问题 [🐛](https://github.com/xiaohuohumax/auto-unpack/issues)。若觉得项目不错，欢迎 [⭐](https://github.com/xiaohuohumax/auto-unpack) 鼓励！



  + 场景一：大量压缩包需要识别、测试、解压等。
  + 场景二：大量文件需要分类、重命名、移动、复制、删除等。
  + 场景三：需要定时、周期性处理文件。



  + 文档：[https://xiaohuohumax.github.io/auto-unpack/](https://xiaohuohumax.github.io/auto-unpack/)



  + **压缩/解压缩**：7z、XZ、BZIP2、GZIP、TAR、ZIP 以及 WIM
  + **仅解压缩**：AR、ARJ、CAB、CHM、CPIO、CramFS、DMG、EXT、FAT、GPT、HFS、IHEX、ISO、LZH、LZMA、MBR、MSI、NSIS、NTFS、QCOW2、RAR、RPM、SquashFS、UDF、UEFI、VDI、VHD、VMDK、WIM、XAR 以及 Z



  + [Rye](https://rye.astral.sh/)：项目管理
  + [7-zip](https://7-zip.org/)：解压缩软件


pkgId: a9ddb1bc1c1b614143b78d585e7854cb6236bcc7b56583dc15c44fa2276b33b3
name: python-auto-upload
arch: src
version: 0.0.92
epoch: 0
release: 1
summary: Upload local resources to PT trackers automatically.
url: https://github.com/dongshuyan/Auto_Upload
rpm_license: MIT Licence
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-upload-0.0.92-1.src.rpm
checksum_type: sha256
description:
  自动将本地资源发布到PT站
  Upload local resources to PT trackers automatically.



  - 最适合发布追更资源，可以自动识别资源集数
  - 支持Windows，Linux，Macos系统
  - 自由度高，智能识别能力强


  - 20201006 更新抓取资源集数算法
  - 20201005 douban简介改为使用doubaninfo接口抓取，支持cookie。并修改了upload tools里面获取链接的bug。
  - 20201005 修改了发布种子后做种可能失败的bug。发布合集后，如果发布失败不再重新制种种子。
  - 20201004 允许截图0张，重写了豆瓣info的抓取，变为直接从豆瓣网站抓取，允许cookie
  - 20200913 完成HHCLUB的适配
  - 20200912 开始种子变成全部发布完成后统一开始
  - 20200908 取消使用mktorrent的-f参数，添加制作种子失败原因的提示
  - 20200907 尝试修复check参数设置为1但是不停止的bug
  - 20200902 增加了发布前手动检查的功能，设置方法参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml) 中 `basic模块`中 `check参数`
  - 20200902 增加了自定义是否在资源文件外部套0day文件夹的功能，设置方法参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml) 中 `basic模块`中 `new_folder参数`
  - 20200902 修复了文件在0day文件夹里找不到的问题
  - 20200902 修正了柠檬tracker无法选择https的问题
  - 20200902 增加了大量自定义信息，当然这些信息大部分并不需要自己设置，只有当程序无法自动识别时候需要手动设置。设置方法参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml)
  - 20200902 增加了自定义文件夹的功能，外层文件夹随便命名。
  - 20200902 修复了发布电视剧需要bgm的bug
  - 20200902 目前所有资源发种时候会自动在外层套一个0day名字的文件夹
  - 20200825 已支持新图床freeimage，设置方法参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml) 中 `image hosting模块`
  - 20200825 添加了有cookie的情况绕过静态模式登录的功能
  - 20200825 在github里面增加了一个install文件夹，里面存放了win下需要下载安装的几个安装包
  - 20200825 配置文件实例只保留一个[au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml)
  - 20200825 修复登录失败反复登录的bug
  - 20200823 优化结果的高亮显示
  - 20200821 修复发布合集路径错误的bug,修复mktorrent制作种子概率失败的问题。
  - 20200821 优化结果的高亮显示
  - 20200821 增加日志写入文件，优化日志显示结果，设置方法参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml) 中 `basic模块log参数`
  - 20200820 修正qb自动管理带来的bug; 增加给资源分类功能，体现在qb的分类里面，设置方法参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml)
  - 20220820 增加对HDFans的支持
  - 20220819 优化内存使用，增强标签识别性能，柠檬下载链接改用https
  - 20220818 添加从文件名识别类型的功能，添加自动将mediainfo文件路径修改到只剩文件名，pter的info改用hide标签
  - 20220818 修正download的拼写错误
  - 20220818 增加对wintersakura(冬樱)的支持
  - 20220817 增加副标题附加内容
  - 20220817 修正find_elements_by_path等问题，并添加柠檬官组识别，下载路径配置功能
  - 20220817 修正au.yaml内容丢失的bug并增加提醒
  - 20220817 增加用户名密码登录，验证码自动识别功能以及cookie自动备份功能
  - 20220817 增加yaml文件备份功能(生成au.yaml.bak文件)，以防文件损坏
  - 20220817 增加对于PTNap的支持
  - 20220815 增加对于SSD,明教以及CarPT的支持，增加禁转识别,参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml)
  - 20220815 增加对于天空，观众以及柠檬剧集板块的支持
  - 20220814 增加直接在命令行获取豆瓣链接/获取视频截图链接的功能
  - 20220809 修复找不到bgm豆瓣链接的bug，增加识别发种dupe
  - 20220808 增加qb添加种子稳定性、增加qb种子自动开始功能、增加后台运行的选项添加考虑通过url下载站点种子失败的情况的判断增加qb种子自动开始功能、增加后台运行的选项参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml)
  - 20220808 修复Windows系统上对于最终路径有空格等制作种子出错的bug
    但是需要确保在制作种子期间，该 `文件`或者 `文件夹`没有被其他应用占用。仅对Windows系统有这个限制











  全平台支持了以下功能:

  - 根据配置文件分析待发布资源的中英文名
  - 根据配置文件分析已经发布的资源并自动找到未发布的资源
  - 可选是否在资源外层套一个0day名字的文件夹
  - 大量参数可以自动抓取也可以自己配置，包括且不限于 视频格式，音频格式，字幕信息，音轨信息等
  - 将未发布的资源有序发布
  - 自动获取待发布资源的豆瓣链接/动漫资源的bgm链接
  - 自动获取待发布资源的豆瓣简介
  - 自动获取待发布资源的截图并上传到图床获取bbcode
  - 自动获取待发布资源的mediainfo信息
  - 自动制作种子
  - 根据上述信息自动发布到各个站点（分集发布/打包发布）
  - 自动获取下载链接并传递给Qbittorrent自动做种
  - 自动记录发布资源信息生成excel表格(csv文件)
  - 自动统计目前已发布的总量(可以用来统计每月发种数量)

  目前支持的平台:

  - MacOS
  - Windows
  - Linux

  目前支持的资源类型:

  - 动漫
  - 剧集
  - 电影

  目前支持的站点(排名仅代表支持的时间先后):

  - pter
  - lemonhd
  - hdsky
  - audience
  - piggo
  - ssd
  - hdpt(明教)
  - carpt
  - ptnap
  - wintersakura
  - hdfans
  - hhclub(憨憨)

  正在适配的站点(排名不分先后):

  - mt
  - pthome
  - hare

  Todolist:

  - 使用request发种,开发ing
  - GUI（有考虑，需要学）
  - 自定义站点（需要考虑做不做和怎么做）

  如果有新的站点/资源类型等需求,可以加入QQ群交流(735803201)



  `Auto_Upload自动发种机`可以在任何具有 `Python`环境的系统上使用，下面讲解下在各个系统上的安装步骤



  1.需要本地安装Chrome且升级到最新正式版本

  2.安装python3:
  [安装Python](https://www.python.org/downloads/)，一般选择最新版本的Python3及对应的Windows installer即可。安装时注意将为所有用户安装和将Python添加到PATH勾上
  ![安装python1](https://img.picgo.net/2022/08/07/1.png)
  打开PowerShell，确认Python安装成功
  ![安装python2](https://img.picgo.net/2022/08/07/2.png)

  以下几个插件的安装包可以去通过下面官方途径下载，也可以前往[Install文件夹](https://github.com/dongshuyan/Auto_Upload/blob/master/install)获取 或者 前往交流群的群文件获取。3.安装 `ffmpeg`，并确认安装正确:

  - 下载安装 `ffmpeg` & `ffprobe`：https://github.com/BtbN/FFmpeg-Builds/releases
  - 将解压后的 `ffmpeg`文件夹移动到一个相对稳定的文件夹,比如 `D:\Program Files\`
  - 将上一步 `ffmpeg\bin`文件夹路径添加到系统PATH我的电脑【右击】 -> 选择 属性 -> 高级系统设置 -> 高级 -> 环境变量  -> 系统变量里面找到'Path',点击编辑 -> 新建 -> 将上一步 `ffmpeg\bin`文件夹路径路径粘贴进去 -> 确定 --> 确定 … 保存即可。一般也是 不需要重启
  - 在PowerShell确认ffmpeg和ffprobe安装成功

  4.安装 `mktorrent`，并确认安装正确:

  - 根据自己电脑下载[64位安装包](https://github.com/q3aql/mktorrent-win/releases/download/v1.1-2/mktorrent-1.1-win-64bit-build2.7z)或者[32位安装包](https://github.com/q3aql/mktorrent-win/releases/download/v1.1-2/mktorrent-1.1-win-32bit-build2.7z)
  - 使用[7-zip](http://www.7-zip.org/) or [Winrar](http://www.rarlab.com/)解压文件.
  - 将 `mktorrent`文件夹移动到一个相对稳定的文件夹,比如 `D:\Program Files\`
  - 将上一步 `mktorrent\bin`文件夹路径添加到系统PATH
    我的电脑【右击】 -> 选择 属性 -> 高级系统设置 -> 高级 -> 环境变量  -> 系统变量里面找到'Path',点击编辑 -> 新建 -> 将上一步 `mktorrent\bin`文件夹路径路径粘贴进去 -> 确定 --> 确定 … 保存即可。一般也是 不需要重启

  5.安装 `mediainfo`，并确认安装正确

  - 下载[mediainfo-cli](https://mediaarea.net/download/binary/mediainfo/22.06/MediaInfo_CLI_22.06_Windows_x64.zip)：https://mediaarea.net/en/MediaInfo/Download/Windows
  - 解压zip文件并解压后的 `Mediainfo_CLIxxx`文件夹移动到一个相对稳定的位置
  - 将上一步 `Mediainfo_CLIxxx`文件夹路径添加到系统PATH我的电脑【右击】 -> 选择 属性 -> 高级系统设置 -> 高级 -> 环境变量  -> 系统变量里面找到'Path',点击编辑 -> 新建 -> 将上一步 `Mediainfo_CLIxxx`文件夹路径粘贴进去 -> 确定 --> 确定 … 保存即可。一般也是 不需要重启。
  - 在PowerShell确认 `mediainfo`安装成功

  ```bash
  mediainfo -h
  ```

  6.安装 `Auto_Upload`，在以管理员身份打开 `Windows PowerShell`中输入:

  ```bash
  python3 -m pip install auto_upload  -i https://pypi.tuna.tsinghua.edu.cn/simple/
  auto_upload -h
  ```

  如果上述命令没反应或者报错可以尝试下面这个：

  ```bash
  pip install auto_upload  -i https://pypi.tuna.tsinghua.edu.cn/simple/
  auto_upload -h
  ```

  7.更新 `Auto_Upload`，在 `Windows PowerShell`中输入:

  ```bash
  python3 -m pip install --upgrade auto_upload  -i https://pypi.tuna.tsinghua.edu.cn/simple/
  ```



  0.升级 `python`至 `3.7.0`版本以上，建议 `3.9.0`
  如果有 `_ssl`或者 `_ctypes`找不到，也可以试试按照下面步骤重新安装python3

  ```bash

  wget https://www.python.org/ftp/python/3.9.0/Python-3.9.0.tgz

  tar -zxf Python-3.9.0.tgz

  cd Python-3.9.0


  ./configure --prefix=/usr/local/python3


  ./configure --enable-optimizations


  sudo apt-get update
  sudo apt-get install openssl
  sudo apt-get install libssl-dev
  sudo apt-get install build-essential python-dev python-setuptools python-pip python-smbus
  sudo apt-get install build-essential libncursesw5-dev libgdbm-dev libc6-dev
  sudo apt-get install zlib1g-dev libsqlite3-dev tk-dev
  sudo apt-get install libssl-dev openssl
  sudo apt-get install libffi-dev
  sudo apt-get install libxpm-dev libxext-dev
  sudo apt-get install zlib1g-dev libbz2-dev libssl-dev libncurses5-dev libsqlite3-dev


  ./configure --with-ssl


  sudo su


  make && make install


  exit


  ```

  1.需要本地安装Chrome且升级到最新正式版本
  手动下载安装并更新即可，如果不方便手动，可以尝试使用如果命令（没有测试过）



  ```bash
  wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
  sudo sh -c 'echo "deb http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google-chrome.list'
  sudo apt-get update
  sudo apt-get install google-chrome-stable
  ```



  ```bash
  wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
  sudo dpkg -i google-chrome-stable_current_amd64.deb
  ```

  2.安装 `mktorrent`,`ffmpeg`和 `mediainfo`，并确认安装正确

  ```bash
  sudo apt update
  sudo python3 -m pip install --upgrade pip
  sudo apt-get install python3-pip ffmpeg mediainfo mktorrent
  ```

  3.安装 `Auto_Upload`

  ```bash
  python3 -m pip install auto_upload -i https://pypi.tuna.tsinghua.edu.cn/simple/
  auto_upload -h
  ```

  4.更新 `Auto_Upload`，，在 `Terminal.app`中输入:

  ```bash
  python3 -m pip install --upgrade auto_upload -i https://pypi.tuna.tsinghua.edu.cn/simple/
  ```



  1.需要本地安装Chrome且升级到最新正式版本
  以Mac为例，2020.08.06最新正式版为104.0.5112.79

  2.安装 `Homebrew`，在Termial.app中输入:

  ```bash
  bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  ```

  3.安装 `mktorrent`,`ffmpeg`和 `mediainfo`，并确认安装正确:

  ```bash
  brew install ffmpeg mediainfo mktorrent
  ffmpeg -version
  mediainfo --version
  ```

  4.安装 `Auto_Upload`，在 `Terminal.app`中输入:

  ```bash
  python3 -m pip install auto_upload -i https://pypi.tuna.tsinghua.edu.cn/simple/
  auto_upload -h
  ```

  5.更新 `Auto_Upload`，，在 `Terminal.app`中输入:

  ```bash
  python3 -m pip install --upgrade auto_upload -i https://pypi.tuna.tsinghua.edu.cn/simple/
  ```





  例如路径为:/Users/Desktop/auto_upload



  "cookies_path","screenshot_path","record_path"

  - cookies_path将用来存放站点cookie文件，文件名需要命名为cookie_站点.json。(例如:cookie_lemonhd.json,cookie_pter.json等)
  - screenshot_path将用来存放视频截图，种子等临时文件
  - record_path将用来存放发种记录



  on格式的cookie推荐使用插件"EditThisCookie"获取



  http://www.editthiscookie.com/



  https://chrome.google.com/webstore/detail/fngmhnnpilhplaeedifhccceomclgfbg



  https://microsoftedge.microsoft.com/addons/detail/editthiscookie/jhampopgcdhehhkbeljdbfdbkfkmolbh?hl=zh-CN

  - 安装好 `EditThisCookie`之后
  - 使用浏览器 `成功登录`PT站点
  - 点击右上角 `饼干🍪`图案的图标
  - 点击向右的按钮就把json格式的cookie复制的剪贴板了
  - 粘贴进本文并保存到 `工作目录/cookies_path/cookie_站点.json`文件即可



  详细参数说明参考[au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml)

  注意：如果是在windows系统下，要发布的 `资源文件/文件夹名称`如果有 `空格`会导致制作种子失败，建议将空格替换为 `.`或者下划线 `_`。其他系统没有这个问题。

  建立完成后在工作目录下应该有三个文件夹以及一个au.yaml位置文件，如下图
  ![Img_Demo](https://img.picgo.net/2022/08/06/dir.jpg)





  ```bash
  auto_upload -yp '工作目录/au.yaml' -u
  ```

  注意：在Windows系统发种时需要确保在制作种子期间，被发布的 `文件`或者 `文件夹`没有被其他应用占用。



  ```bash
  auto_upload -yp '工作目录/au.yaml' -iu -ih 图床名称  -iform 图片格式 -if  '图片路径1' '图片路径2'
  ```

  图床名称目前仅支持（排名无先后）：

  - ptpimg
  - picgo
  - chd
  - imgbox
  - pter
  - smms



  ```bash
  auto_upload -yp '工作目录/au.yaml' -di -du 豆瓣链接
  ```

  示例:

  ```bash
  auto_upload -yp '工作目录/au.yaml' -di -du https://movie.douban.com/subject/26353671/
  ```



  ```bash
  auto_upload -yp '工作目录/au.yaml' -mi -mf '视频路径' -ih 图床名称 -iform 图片格式 -in 截图数量
  ```

  图床名称目前仅支持（排名无先后）：

  - ptpimg
  - picgo
  - chd
  - imgbox
  - pter
  - smms

  图片格式(可以不填，默认'img'):

  - img 图片原始链接
  - bbcode BBcode格式链接

  截图数量(可以不填，默认3张)

  示例:

  ```bash
  auto_upload 'au.yaml' -mi -mf '1.mp4' -ih picgo -iform bbcode -in 6
  ```



  参考 [au_example.yaml](https://github.com/dongshuyan/Auto_Upload/blob/master/au_example.yaml)







  Windows下的mktorrent支持的不太好，后面我再修复吧



  最后一级文件夹名称必须是：任意内容[想要在副标题添加的内容]-资源中文名-资源英文名-发布组
  例如 `6[有B站水印]-不死者之王-OVERLOAD-sauterne`



  群号:735803201



  [Differential 差速器](https://github.com/LeiShi1313/Differential)  (复制了上传图床部分代码)
  [Differential差速器使用教程](https://leishi.io/blog/posts/2021-12/Differential/)  (Auto_Upload安装教程主要参考本文)
  [mktorrent-win-builds](https://github.com/q3aql/mktorrent-win-builds)
  [MKTORRENT WIN下命令行制作种子](https://blog.acesheep.com/index.php/archives/551/)
  [linux 安装 Chrome](https://www.cnblogs.com/ivantang/p/6290729.html)
  [windows10 环境变量设置](https://blog.csdn.net/palmer_kai/article/details/80588594)
  [Linux Ubuntu系统升级Python3版本至Python3.9版本步骤](https://blog.csdn.net/u012080686/article/details/112600252)
  [PYTorrent](https://github.com/ndroi/pytorrent)


pkgId: a397f93b36790ecd8ca3b2719f1d65b81ca545fe8c34d17e2951a01ae52a40ad
name: python-auto-walrus
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Automatically apply the awesome walrus operator
url: https://github.com/MarcoGorelli/auto-walrus
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto-walrus-0.3.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/MarcoGorelli/auto-walrus/workflows/tox/badge.svg)](https://github.com/MarcoGorelli/auto-walrus/actions?workflow=tox)
  [![Coverage](https://codecov.io/gh/MarcoGorelli/auto-walrus/branch/main/graph/badge.svg)](https://codecov.io/gh/MarcoGorelli/auto-walrus)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/MarcoGorelli/auto-walrus/main.svg)](https://results.pre-commit.ci/latest/github/MarcoGorelli/auto-walrus/main)
  A tool and pre-commit hook to automatically apply the awesome walrus operator.

  ```console
  pip install auto-walrus
  ```

  See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
  Sample `.pre-commit-config.yaml`:
  ```yaml
  -   repo: https://github.com/MarcoGorelli/auto-walrus
      rev: 0.3.4
      hooks:
      -   id: auto-walrus
  ```

  ```console
  auto-walrus myfile.py
  ```
  ```diff
  -    n = 10
  -    if n > 3:
  +    if (n := 10) > 3:
           print(n)
  ```

  Using the walrus operator can result in longer lines. Lines longer than what you
  pass to ``--line-length`` won't be rewritten to use walrus operators.
  E.g.
  ```
  auto-walrus myfile_1.py myfile_2.py --line-length 89
  ```
  Lines with comments won't be rewritten.

  To my great surprise, this is being used by:
  - https://github.com/python-graphblas/python-graphblas
  - https://github.com/Remi-Gau/bids2cite
  - https://github.com/TheAlgorithms/Python
  - https://github.com/apache/superset
  Anyone else? Please let me know, or you can open a pull request to add yourself.

  **Christopher Redwine**, [Senior Software Engineer at TechnologyAdvice](https://github.com/chrisRedwine)
  > hmm, i dunno about this one chief
  **Michael Kennedy & Brian Okken**, [hosts of the Python Bytes podcast](https://pythonbytes.fm/):
  > I kind of like this being separate from other tools
  **Someone on Discord**
  > you're a monster
  **Will McGugan**, [CEO / Founder of http://Textualize.io](https://www.willmcgugan.com/):
  > Embrace the Walrus!

  Logo by [lion_space](https://www.fiverr.com/lion_space)


pkgId: 6c3a3632a93dba7adafab133e77a308b03ceb8a73af0eb2ca923fa205a995e62
name: python-auto1111sdk
arch: src
version: 0.0.95
epoch: 0
release: 1
summary: SDK for Automatic 1111.
url: https://pypi.org/project/auto1111sdk/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto1111sdk-0.0.95-1.src.rpm
checksum_type: sha256
description:
  <p>
      <a href="https://pepy.tech/project/auto1111sdk">
          <img alt="GitHub release" src="https://static.pepy.tech/badge/auto1111sdk/month">
      </a>

  </p>
  Auto 1111 SDK is a lightweight Python library for using Stable Diffusion generating images, upscaling images, and editing images with diffusion models. It is designed to be a modular, light-weight Python client that encapsulates all the main features of the [Automatic 1111 Stable Diffusion Web Ui](https://github.com/AUTOMATIC1111/stable-diffusion-webui). Auto 1111 SDK offers 3 main core features currently:

  - Text-to-Image, Image-to-Image, Inpainting, and Outpainting pipelines. Our pipelines support the exact same parameters as the [Stable Diffusion Web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui), so you can easily replicate creations from the Web UI on the SDK.
  - Upscaling Pipelines that can run inference for any Esrgan or Real Esrgan upscaler in a few lines of code.
  - An integration with Civit AI to directly download models from the website.

  Join our [Discord!!](https://discord.gg/S7wRQqt6QV)



  We have a colab demo where you can run many of the operations of Auto 1111 SDK. Check it out [here!!](https://colab.research.google.com/drive/1SekiJ-mdB2V8ogWbyRyF_yDnoMuDGWTl?usp=sharing)



  We recommend installing Auto 1111 SDK in a virtual environment from PyPI. Right now, we do not have support for conda environments yet.

  ```bash
  pip3 install auto1111sdk
  ```

  To install the latest version of Auto 1111 SDK, run:

  ```bash
  pip3 install git+https://github.com/saketh12/Auto1111SDK.git
  ```



  Generating images with Auto 1111 SDK is super easy. To run inference for Text-to-Image, Image-to-Image, Inpainting, Outpainting, or Stable Diffusion Upscale, we have 1 pipeline that can support all these operations. This saves a lot of RAM from having to create multiple pipeline objects with other solutions.

  ```python
  from auto1111sdk import StableDiffusionPipeline

  pipe = StableDiffusionPipeline("<Path to your local safetensors or checkpoint file>")

  prompt = "a picture of a brown dog"
  output = pipe.generate_txt2img(prompt = prompt, height = 1024, width = 768, steps = 10)

  output[0].save("image.png")
  ```



  Find the instructions [here.](https://github.com/saketh12/Auto1111SDK/blob/main/automatic1111sdk_on_windows_w_gpu.md) Contributed by by Marco Guardigli, mgua@tomware.it



  We have more detailed examples/documentation of how you can use Auto 1111 SDK [here](https://flush-ai.gitbook.io/automatic-1111-sdk/).
  For a detailed comparison between us and Huggingface diffusers, you can read [this](https://flush-ai.gitbook.io/automatic-1111-sdk/auto-1111-sdk-vs-huggingface-diffusers).

  For a detailed guide on how to use SDXL, we recommend reading [this](https://flush-ai.gitbook.io/automatic-1111-sdk/pipelines/stable-diffusion-xl)



  - Original txt2img and img2img modes
  - Real ESRGAN upscale and Esrgan Upscale (compatible with any pth file)
  - Outpainting
  - Inpainting
  - Stable Diffusion Upscale
  - Attention, specify parts of text that the model should pay more attention to
      - a man in a `((tuxedo))` - will pay more attention to tuxedo
      - a man in a `(tuxedo:1.21)` - alternative syntax
      - select text and press `Ctrl+Up` or `Ctrl+Down` (or `Command+Up` or `Command+Down` if you're on a MacOS) to automatically adjust attention to selected text (code contributed by anonymous user)
  - Composable Diffusion: a way to use multiple prompts at once
      - separate prompts using uppercase AND
      - also supports weights for prompts: a cat :1.2 AND a dog AND a penguin :2.2
  - Works with a variety of samplers
  - Download models directly from Civit AI and RealEsrgan checkpoints
  - Set custom VAE: works for any model including SDXL
  - Support for SDXL with Stable Diffusion XL Pipelines
  - Pass in custom arguments to the models
  - No 77 prompt token limit (unlike Huggingface Diffusers, which has this limit)



  - Adding support Hires Fix and Refiner parameters for inference.
  - Adding support for Lora's
  - Adding support for Face restoration
  - Adding support for Dreambooth training script.
  - Adding support for custom extensions like Controlnet.

  We will be adding support for these features very soon. We also accept any contributions to work on these issues!



  Auto1111 SDK is continuously evolving, and we appreciate community involvement. We welcome all forms of contributions - bug reports, feature requests, and code contributions.

  Report bugs and request features by opening an issue on Github.
  Contribute to the project by forking/cloning the repository and submitting a pull request with your changes.



  Licenses for borrowed code can be found in `Settings -> Licenses` screen, and also in `html/licenses.html` file.

  - Automatic 1111 Stable Diffusion Web UI - https://github.com/AUTOMATIC1111/stable-diffusion-webui
  - Stable Diffusion - https://github.com/Stability-AI/stablediffusion, https://github.com/CompVis/taming-transformers
  - k-diffusion - https://github.com/crowsonkb/k-diffusion.git
  - ESRGAN - https://github.com/xinntao/ESRGAN
  - MiDaS - https://github.com/isl-org/MiDaS
  - Ideas for optimizations - https://github.com/basujindal/stable-diffusion
  - Cross Attention layer optimization - Doggettx - https://github.com/Doggettx/stable-diffusion, original idea for prompt editing.
  - Cross Attention layer optimization - InvokeAI, lstein - https://github.com/invoke-ai/InvokeAI (originally http://github.com/lstein/stable-diffusion)
  - Sub-quadratic Cross Attention layer optimization - Alex Birch (https://github.com/Birch-san/diffusers/pull/1), Amin Rezaei (https://github.com/AminRezaei0x443/memory-efficient-attention)
  - Textual Inversion - Rinon Gal - https://github.com/rinongal/textual_inversion (we're not using his code, but we are using his ideas).
  - Idea for SD upscale - https://github.com/jquesnelle/txt2imghd
  - Noise generation for outpainting mk2 - https://github.com/parlance-zz/g-diffuser-bot
  - CLIP interrogator idea and borrowing some code - https://github.com/pharmapsychotic/clip-interrogator
  - Idea for Composable Diffusion - https://github.com/energy-based-model/Compositional-Visual-Generation-with-Composable-Diffusion-Models-PyTorch
  - xformers - https://github.com/facebookresearch/xformers
  - Sampling in float32 precision from a float16 UNet - marunine for the idea, Birch-san for the example Diffusers implementation (https://github.com/Birch-san/diffusers-play/tree/92feee6)


pkgId: 71a095dcd0034df50d9e821f61f78426d45d2901e0a8f857e6276d9401fcf06e
name: python-autoBOTLib
arch: src
version: 1.19
epoch: 0
release: 1
summary: AutoBOT: Explainable AutoML for texts
url: https://github.com/skblaz/autobot
rpm_license: bsd-3-clause-clear
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoBOTLib-1.19-1.src.rpm
checksum_type: sha256
description:
  autoBOT is an AutoML system for text classification with an emphasis on explainability.
  It implements the idea of *representation evolution*, learning to combine representations
  for a given task, automatically.


pkgId: 661d0a02bbc1a16ee2e2ab75cf58641987a493c7d04c4359b77c02ac28b4cb68
name: python-autoReRun
arch: src
version: 1.3.0
epoch: 0
release: 1
url: https://github.com/BhaskarPanja93/autoReRun
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoReRun-1.3.0-1.src.rpm
checksum_type: sha256
summary:
  A simple program to automatically kill running process(es) and re-spawn new process(es) for the runnable files everytime some specified file(s) get modified (or deleted or created). For example, Automatically re-starting any server when the server file(s) is modified.

description:
  ```pip install autoReRun --upgrade```




  <br>To install:
  ```
  pip install autoReRun --upgrade
  pip3 install autoReRun --upgrade
  python -m pip install autoReRun --upgrade
  python3 -m pip install autoReRun --upgrade
  ```



  ```
  from autoReRun import AutoReRun
  toRun = {
      "server1.py":["-p 5000", "-h 0.0.0.0"], # file A to run
      "server2.py":["-p 6000"], # file B to run
           }

  toCheck = ["server1.toml", "server2.toml"] # files to check for updates


  AutoReRun(toRun=toRun, toCheck=toCheck)
  ```


  * Only limited to python files, make it work with any other file type.
  * Way to turn off debugger.


pkgId: d96fa9806e322013fbe1900978d84c6efb375dc35f9853e4d2a8bd54164fa124
name: python-auto_ml
arch: src
version: 2.9.10
epoch: 0
release: 1
summary: Automated machine learning for production and analytics
url: https://github.com/ClimbsRocks/auto_ml
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auto_ml-2.9.10-1.src.rpm
checksum_type: sha256
description:
      Automated machine learning for production and analytics
  |Build Status| |Documentation Status| |PyPI version| |Coverage Status|
  |license|


pkgId: 401ee566dcb3e4d0e9273529b7e5c504d2eb9b741926cbade30827b05d3acc61
name: python-autoafids
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: End-to-end SnakeBIDS workflow for landmark regression and derivative apps
url: https://pypi.org/project/autoafids/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoafids-0.1.0-1.src.rpm
checksum_type: sha256
description:
  AIMS Lab Research Team at the Robarts Research Institute - 2023-2024

  *This package is under active development. It should be stable and reproducible, but please let any of the active contributing members know if there are any bugs or unusual behaviour.*

  This Python package is a standard 3D [U-Net](https://arxiv.org/abs/1505.04597) (Ronneberger et al. 2015) machine learning model based on Snakemake and SnakeBIDS workflow management tools that leverages the recent release of the anatomical fiducial framework to solve the landmark regression problem on 3D MRI images. It is currently in development phase and contains tunable parameters that are not normally exposed in most other machine learning models; the user is highly advised to get familiar with the above mentioned workflow managaments tools and read docstrings and relevant documentation before using this software. Please see the [changelog](CHANGELOG.md) for more details.


  1. [Installation](#installation)
  2. [Workflow](#workflow)
  2. [Train](#train)
  3. [Apply](#apply)
  4. [Known issues](#known-issues)
  5. [Roadmap](#roadmap)
  6. [Questions, Issues, Suggestions, and Other Feedback](#questions--issues)




  We use poetry tool for dependency management and to package the python project. You can find step by step instructions on how to install it by visiting it's official [website](https://python-poetry.org/docs/).



  After installing poetry, clone this repository via:

  ```bash
  git clone https://github.com/afids/autoafids.git
  ```

  You can then install the python package using one of the following commands, which should be executed within the repository folder (i.e., autoafids/).

  ```bash
  poetry install
  ```
  If you want to install in _develop mode_, use:

  ```bash
  poetry install -e
  ```


  Brief summary of the workflow along with its Directed Acyclic Graph (DAG) can be found below.

  *Insert DAG image - inspired by khanlab/scattr*


  1. Extract fiducial points from the landmark files (.fcsv is supported)
  2. Generate a landmark Euclidean distance/probability map with each voxel communicating distance to an AFID of interest


  Currently, we support generating your own models (i.e., training) in a sperate workflow (i.e., afids-cnn: <LINK>). For more details, see [Known Issues](#known-issues).



  <TODO>


  - Factorize apply workflow to run per landmark of interest



  - Model optimization
  - Extension to incorporate new modalities (i.e., CT scans)


  Please reach out if you have any questions, suggestions, or other feedback related to this software—either through email (dbansal7@uwo.ca) or the discussions page. Larger issues or feature requests can be posted and tracked via the issues page. Finally, you can also reach out to Alaa Taha, the Science Lead.


pkgId: 4763fb9fa1b904db23d4ba7782d4a91d058cf50ac07d5efd0cbbd6e4ada489e0
name: python-autoalbument
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: AutoML for image augmentation
url: https://github.com/albumentations-team/autoalbument
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoalbument-0.4.0-1.src.rpm
checksum_type: sha256
description:
  AutoAlbument is an AutoML tool that learns image augmentation policies from data using the [Faster AutoAugment algorithm](https://arxiv.org/abs/1911.06987). It relieves the user from the burden of manually selecting augmentations and tuning their parameters. AutoAlbument provides a complete ready-to-use configuration for an augmentation pipeline.

  The library supports image classification and semantic segmentation tasks. You can use [Albumentations](https://github.com/albumentations-team/albumentations) to utilize policies discovered by AutoAlbument in your computer vision pipelines.

  The documentation is available at [https://albumentations.ai/docs/autoalbument/](https://albumentations.ai/docs/autoalbument/)



  Here is a comparison between a baseline augmentation strategy and an augmentation policy discovered by AutoAlbument
  for different classification and semantic segmentation tasks. You can read more about these benchmarks in the [autoalbument-benchmarks](https://github.com/albumentations-team/autoalbument-benchmarks) repository.


  | Dataset  | Baseline Top-1 Accuracy | AutoAlbument Top-1 Accuracy  |
  |----------|:-----------------------:|:----------------------------:|
  | [CIFAR10](https://github.com/albumentations-team/autoalbument-benchmarks#cifar-10-classification)  |          91.79          |           **96.02**          |
  | [SVHN](https://github.com/albumentations-team/autoalbument-benchmarks#svhn-classification)     |          98.31          |           **98.48**          |
  | [ImageNet](https://github.com/albumentations-team/autoalbument-benchmarks#imagenet-classification) |          73.27          |           **75.17**          |



  | Dataset    | Baseline mIOU | AutoAlbument mIOU |
  |------------|:-------------:|:-----------------:|
  | [Pascal VOC](https://github.com/albumentations-team/autoalbument-benchmarks#pascal-voc-semantic-segmentation) |     73.34     |     **75.55**     |
  | [Cityscapes](https://github.com/albumentations-team/autoalbument-benchmarks#cityscapes) |     79.47     |     **79.92**     |



  AutoAlbument requires Python 3.6 or higher. To install the latest stable version from PyPI:

  `pip install -U autoalbument`



  ![How to use AutoAlbument](https://albumentations.ai/docs/images/autoalbument/how_to_use/autoalbument_usage.png)

  1. You need to create a configuration file with AutoAlbument parameters and a Python file that implements a custom PyTorch Dataset for your data. Next, you need to pass those files to AutoAlbument.
  2. AutoAlbument will use Generative Adversarial Network to discover augmentation policies and then create a file containing those policies.
  3. Finally, you can use [Albumentations](https://github.com/albumentations-team/albumentations) to load augmentation policies from the file and utilize them in your computer vision pipelines.

  You can read the detailed description of all steps at [https://albumentations.ai/docs/autoalbument/how_to_use/](https://albumentations.ai/docs/autoalbument/how_to_use/)


  The [`examples`](https://github.com/albumentations-team/autoalbument/tree/master/examples) directory contains example configs for different tasks and datasets:


  - [CIFAR10](https://github.com/albumentations-team/autoalbument/tree/master/examples/cifar10)
  - [SVHN](https://github.com/albumentations-team/autoalbument/tree/master/examples/svhn)
  - [ImageNet](https://github.com/albumentations-team/autoalbument/tree/master/examples/imagenet)


  - [Pascal VOC](https://github.com/albumentations-team/autoalbument/tree/master/examples/pascal_voc)
  - [Cityscapes](https://github.com/albumentations-team/autoalbument/tree/master/examples/cityscapes)

  To run the search with an example config:

  ```
  autoalbument-search --config-dir </path/to/directory_with_dataset.py_and_search.yaml>
  ```


pkgId: 87d23058f40bdf17ff0b7061633d03e77730f07be9b26a3e49b4025804181ab2
name: python-autoapi-django
arch: src
version: 0.11.4
epoch: 0
release: 1
summary: Library for generating transport logic for web application
url: https://pypi.org/project/autoapi-django/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoapi-django-0.11.4-1.src.rpm
checksum_type: sha256
description:
  AutoAPI собирает абстрагирует ваше приложение от слоя с передачей данных,
  генерируя API из чистых классов, содержащих логику.



  - [Russian](./docs/autoapi/index.md)
  - English (in future)



  Устанавливаем virtual env:

  ```shell
  python3 -m venv venv
  . venv/bin/activate
  ```

  Устанавливаем библиотеку с зависимостями
  ```shell
  pip install .
  ```

  Переходим в example-проект, мигрируем БД (SQLite) и запускаем:
  ```shell
  cd example/online_shop
  python manage.py migrate
  python manage.py runserver
  ```

  По урле http://127.0.0.1:8000/docs/ будет доступен Swagger для сгенерированного API.
  Оттуда можно дергать хэндлеры.

  Рекомендуется создать суперюзера (`python manage.py createsuperuser`) и авторизоваться в админке.
  Чтобы проверить корректную работу API, можно дернуть хэндлер `user.get_user` в сваггере.


  Для билда и отправки в PyPI надо сделать:
  ```shell
  pip install build
  python -m build
  pip install twine
  twine upload dist/*
  ```

rpm_license:
  The MIT License (MIT)  Copyright (c) 2018 Sebastián Ramírez  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: dff5623056157d2439bce424fc5e8188a39a7edc8d9fc8ca1530517dda39b1c5
name: python-autoappanalysis
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Automation GUI for Android App Analysis
url: https://github.com/5f0ne/autoappanalysis
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoappanalysis-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Automation GUI for Android App Analysis



  `pip install autoappanalysis`



  Create a config file with the following schema:

  ```json
  // config.json
  {
    "log": "autoappanalysis.log",                                // Path to log file
    "pkgName": "com.app",                                        // Package Name
    "vm": "app-vm",                                              // Name of the VM
    "user": "admin",                                             // User Name
    "pw": "admin",                                               // Password
    "input": "/media/sf_avd",                                    // Path to AVD shared folder on VM
    "output": "/media/sf_results",                               // Path to result shared folder on VM
    "outputHost": "C:\\Users\\admin\\results",                   // Path to result shared folder on host
    "snapshot": "C:\\Users\\admin\\.android\\avd\\analysis.avd", // Path to AVD shared folder on host
    "comparison": [                                              // Array of objects to provide different
          {                                                      // comparison setup.
              "name": "01_action_install",                       // Each object holds a comparison name,
              "first": "init",                                   // a starting snapshot (first) to which the other
              "second": ["install"],                             // snapshots (second) will be compared against
              "noise": "noise"                                   // name of the noise snapshot
          },
          {
              "name": "02_action_first_start",
              "first": "install",
              "second": ["first_start"],
              "noise": "noise_install"
          },
          {
              "name": "03_action_guest_login",
              "first": "first_start",
              "second": ["continue_as_guest"],
              "noise": "noise_first_start"
          }
    ],
    "files": [                                                  // Full Paths to files which are going to be
          "/data/data/path/to/app/user.db",                     // extracted for each snapshot
          "/data/data/path/to/app/host.db",
          "/data/data/path/to/app/config.json"
    ],
    "search": {
          "files": [                                           // Path to files which shall be searched
                  "C:\\Users\\admin\\results\\**\\*.1.test",   // Accepts globe patterns
          ],
          "actions": [                                        // Each action specified here will be
              {                                               // applied to each files listed before
                  "name": "All Occurences",
                  "method": "or",
                  "words": "appname",
                  "format": "wln"
              },
              {
                  "name": "Interesting FileTypes",
                  "method": "or",
                  "words": ".db,.json,.xml,.yml",
                  "format": "wln"
              }
          ]
    }
  }
  ```




  `python -m autoappanalysis -c config.json`


  ![](img/01.png)


  | Button | Description |
  | --- | ---|
  | Root | Starts adbd as root |
  | Create Snapshot | Create a AVD Snapshot with `Snapshot Name` and `Snapshot Number` and extract all files given by `AVD Files to be extracted` |
  | Decrypt Snapshots | Decrypts all snapshots in `VM Input Directory` and save the `.raw` in `VM Output Directory + /decrypted` |
  | Create .idiff | Creates `.idiff` files from the given comparison in config.json and save them in `VM Output Directory + /actions` |
  | Analyse .idiff | Analyses all `.idiff` in `VM Output Directory + /actions` and save the results there |
  | Analyse .db | Analyse all `AVD Files to be extracted` sqlite databases based on given comparison rules in config.json |
  | Uninstall | Uninstalls the App given by `App Package Name` |
  | Extract Files | Extract all files given by `AVD Files to be extracted`. In order to work, `Root` button need to be pushed first. |
  | Search Files | Search given files by provided config and save results within the given paths |




  MIT


pkgId: 64cfc80885be460f0c9ced0aecd65ff27007f02583d455315e69b0129e3acc13
name: python-autobackup
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Automatically create backups of a directory
url: https://github.com/johnowhitaker/autobackup
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autobackup-0.0.1-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

  This file will become your README and also the index of your
  documentation.



  If you are new to using `nbdev` here are some useful pointers to get you
  started.



  ``` sh

  $ pip install -e .





  $ nbdev_prepare
  ```





  Install latest from the GitHub
  [repository](https://github.com/johnowhitaker/autobackup):

  ``` sh
  $ pip install git+https://github.com/johnowhitaker/autobackup.git
  ```

  or from [conda](https://anaconda.org/johnowhitaker/autobackup)

  ``` sh
  $ conda install -c johnowhitaker autobackup
  ```

  or from [pypi](https://pypi.org/project/autobackup/)

  ``` sh
  $ pip install autobackup
  ```



  Documentation can be found hosted on this GitHub
  [repository](https://github.com/johnowhitaker/autobackup)’s
  [pages](https://johnowhitaker.github.io/autobackup/). Additionally you
  can find package manager specific guidelines on
  [conda](https://anaconda.org/johnowhitaker/autobackup) and
  [pypi](https://pypi.org/project/autobackup/) respectively.



  Fill me in please! Don’t forget code examples:

  ``` python
  1+1
  ```

      2


pkgId: 46beb3c9d26b8002559dd5942815fe8e701d4883aed7c3ea06c6e56c0da3b521
name: python-autobackup
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Automatically create backups of a directory
url: https://github.com/johnowhitaker/autobackup
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autobackup-0.0.4-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->





  Install latest from the GitHub
  [repository](https://github.com/johnowhitaker/autobackup):

  ``` sh
  $ pip install git+https://github.com/johnowhitaker/autobackup.git
  ```

  or from [pypi](https://pypi.org/project/autobackup/)

  ``` sh
  $ pip install autobackup
  ```



  `autobackup src dest` will make a copy of `src` (which can be a file or
  a directory) inside `dir` in a folder with the current date+time, and
  clean up any old backups based on the following rules:

  - The most recent 5 backups are kept
  - For each number of days in `--max_ages` (default is “2,14,60”) the
    oldest one below that age is kept.

  This ensures that you have a few recent backups, one up to 2 days old,
  one up to 2 weeks old and one up to 2 months old.

  To run this script hourly,

  1.  Create a service file (e.g. `/etc/systemd/system/backup.service`):

  <!-- -->

      [Unit]
      Description=Hourly Backup Service

      [Service]
      ExecStart=autobackup /path/to/src /path/to/dest

      [Install]
      WantedBy=multi-user.target

  2.  Create a timer file (e.g. `/etc/systemd/system/backup.timer`):

  <!-- -->

      [Unit]
      Description=Run Backup Service Hourly

      [Timer]
      OnCalendar=hourly

      [Install]
      WantedBy=timers.target

  3.  Enable and start the timer:

  <!-- -->

      sudo systemctl enable backup.timer
      sudo systemctl start backup.timer


pkgId: 9e04029af37f18ec00860dd30b21fd4f5cdc581d49695800dcea917a33680d03
name: python-autobib
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Automatically download missing entries to your bibliography file.
url: https://github.com/hdembinski/autobib
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autobib-0.8.1-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/autobib)
  ![PyPI - License](https://img.shields.io/pypi/l/autobib)
  ![PyPI - Status](https://img.shields.io/pypi/status/autobib)

  `autobib` automatically fetches BibTeX entries from online databases (currently Inspire and ADS) based on references that were added to the LaTeX document but not yet to the `.bib` file. The automatically fetched entries are appended to the first `.bib` file defined in your LaTeX source (first entry of `\bibliography{...}`). For this to work, the cite key has to be a key used by the online database.

  In other words, you still need to look up a citation online and copy the cite key to your LaTeX file, but you don't have to also copy the whole BibTeX entry to your local `.bib` file (essentially adding it twice), since `autobib` does the latter for you.

  `autobib` only appends new entries to your `.bib` file and otherwise leaves it as is. Using it is therefore safe.



  `pip install autobib`

  This installs a new script called `bibtex-autobib`, which is a drop-in replacement of the original `bibtex` command. The easiest way to make it work automatically with tooling like `latexmk` is to create a symlink

  `ln -s /path/to/bibtex-autobib /some/path/bibtex`

  where `/some/path/bibtex` comes before the path in which the original `bibtex` command is located in the PATH environment variable. Be careful that you do not override the original `bibtex` command.

  After doing that, you can check whether the command `bibtex` is calling `autobib` by calling `bibtex --version` on the command-line. You should see something like this
  ```
  autobib 0.6.0
  BibTeX 0.99d (TeX Live 2020)
  [...]
  ```
  If this is not the case, then you may have to change the order of search paths in the `PATH` environment variable.



  No extra steps are needed to download from Inspire, but to download from ADS you need to [follow these instructions](https://github.com/adsabs/adsabs-dev-api#access) to get an API token. Export this token in your shell as ADS_TOKEN, e.g. `export ADS_TOKEN=<insert token here>`.


pkgId: b478d339ea1a996d04a22bfa4c76ada9bd030eeeec78ce9350d0dc9806b699d8
name: python-autobisect
arch: src
version: 7.8.0
epoch: 0
release: 1
summary: Automatic bisection utility for Mozilla Firefox and SpiderMonkey
url: https://github.com/MozillaSecurity/autobisect
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autobisect-7.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Task Status](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/autobisect/master/badge.svg)](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/autobisect/master/latest)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![codecov](https://codecov.io/gh/MozillaSecurity/autobisect/branch/master/graph/badge.svg)](https://codecov.io/gh/MozillaSecurity/autobisect)
  Autobisect is a python module that automates bisection of Mozilla Firefox and SpiderMonkey bugs.


pkgId: 6ae7219e48e712e82ddd44d31c00a4809ce72766ca1a61919e9e243421264345
name: python-autoblocksai
arch: src
version: 0.0.102
epoch: 0
release: 1
summary: Python client for Autoblocks
url: https://github.com/autoblocksai/python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoblocksai-0.0.102-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://app.autoblocks.ai/images/logo-white.png">
      <source media="(prefers-color-scheme: light)" srcset="https://app.autoblocks.ai/images/logo-black.png">
      <img alt="Autoblocks Logo" width="300px" src="https://app.autoblocks.ai/images/logo-black.png">
    </picture>
  </p>
  <p align="center">
    📚
    <a href="https://docs.autoblocks.ai/">Documentation</a>
    &nbsp;
    •
    &nbsp;
    🖥️
    <a href="https://app.autoblocks.ai/">Application</a>
    &nbsp;
    •
    &nbsp;
    🏠
    <a href="https://www.autoblocks.ai/">Home</a>
  </p>
  <p align="center">
    <img src="assets/python-logo-only.png" width="64px">
  </p>
  <p align="center">
    <a href="https://github.com/autoblocksai/python-sdk/actions/workflows/ci.yml">
      <img src="https://github.com/autoblocksai/python-sdk/actions/workflows/ci.yml/badge.svg?branch=main">
    </a>
  </p>



  ```bash
  poetry add autoblocksai
  ```

  ```bash
  pip install autoblocksai
  ```



  See our [Python](https://github.com/autoblocksai/autoblocks-examples#python) examples.



  See [the full documentation](https://docs.autoblocks.ai).



  Please [open an issue](https://github.com/autoblocksai/python-sdk/issues/new) if you encounter any bugs, have any questions, or have any feature requests.



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


pkgId: 8c9ee726e216756cb2a0c67e1e18fcf1041703f6db43b80f12709be9ecf8938c
name: python-autobmt
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: a modeling tool that automatically builds scorecards and tree models.
url: https://github.com/ZhengRyan/autobmt
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autobmt-0.2.0-1.src.rpm
checksum_type: sha256
description:
  |  微信 |  微信公众号 |
  | :---: | :----: |
  | <img src="https://github.com/ZhengRyan/autotreemodel/blob/master/images/%E5%B9%B2%E9%A5%AD%E4%BA%BA.png" alt="RyanZheng.png" width="50%" border=0/> | <img src="https://github.com/ZhengRyan/autotreemodel/blob/master/images/%E9%AD%94%E9%83%BD%E6%95%B0%E6%8D%AE%E5%B9%B2%E9%A5%AD%E4%BA%BA.png" alt="魔都数据干饭人.png" width="50%" border=0/> |
  |  干饭人  | 魔都数据干饭人 |


  > 仓库地址：https://github.com/ZhengRyan/autobmt
  >
  > 微信公众号文章：https://mp.weixin.qq.com/s/30-V0p30p1rKSBtcBgLTRA
  >
  > pipy包：https://pypi.org/project/autobmt/
  >
  > 实验数据：链接: https://pan.baidu.com/s/1BRIHH9Wcwy2EZaO5xSgH9w?pwd=tdq5 提取码: tdq5


  可以不用单独创建虚拟环境，都是日常常用的python依赖包。需要创建虚拟环境，请参考"五、依赖包安装"


  pip install（pip安装）

  ```bash
  pip install autobmt # to install
  pip install -U autobmt # to upgrade
  ```

  Source code install（源码安装）

  ```bash
  python setup.py install
  ```


  1、1行代码自动构建评分卡：请查看autobmt/examples/autobmt_lr_tutorial_code.py。里面有例子

  2、1步1步拆解自动构建评分卡的步骤：请查看autobmt/examples/tutorial_code.ipynb。里面有详细步骤拆解例子


  1、Step 1: EDA，整体数据探索性数据分析

  2、Step 2: 特征粗筛选

  3、Step 3: 对粗筛选后的变量调用最优分箱

  4、Step 4: 对最优分箱后的变量进行woe转换

  5、Step 5: 对woe转换后的变量进行stepwise

  6、Step 6: 用逻辑回归构建模型

  7、Step 7: 构建评分卡

  8、Step 8: 持久化模型，分箱点，woe值，评分卡结构

  9、Step 9: 持久化建模中间结果到excel，方便复盘


  1、all_data_eda.xlsx：整体数据的EDA情况

  2、build_model_log_var_jpg文件夹，最终入模变量的分箱画图，在"build_model_log.xlsx"最后1个sheet也有记录

  3、build_model_log.xlsx：构建整个模型的过程日志，记录有利复盘

  4、fb.pkl、woetf.pkl、lrmodel.pkl、in_model_var.pkl：fb.pkl分箱文件，woetf.pkl转woe文件，lrmodel.pkl模型文件，入模变量文件

  5、scorecard.pkl、scorecard.csv、scorecard.json：评分卡的pkl、csv、json格式。在"build_model_log.xlsx"的"scorecard_structure"sheet也有记录

  6、var_bin_woe_format.csv、var_bin_woe_format.json、var_bin_woe.csv、var_bin_woe.json、var_split_point_format.csv、var_split_point_format.json、var_split_point.csv、var_split_point.json：分箱文件和转woe文件的csv、json格式

  7、lr_auc_ks_psi.csv：模型的auc、ks、psi

  8、lr_pred_to_report_data.csv：构建建模报告的数据

  9、lr_test_input.csv：用于模型上线后，将次数据喂入模型，对比和lr_pred_to_report_data.csv结果是否一致。验证模型上线的正确性



  conda create -y --force -n autobmt python=3.7.2

  conda activate autobmt


  pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/


pkgId: a10332e9ca787dcb8867a0dc298bc70fd40efd758ee7c32f2e06debfbcf64bf2
name: python-autoboot
arch: src
version: 0.12.2
epoch: 0
release: 1
summary: IoC with auto config framework
url: https://github.com/yizzuide/autoboot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoboot-0.12.2-1.src.rpm
checksum_type: sha256
description:
  一个Python语言的仿SpringBoot开发方式，支持IoC组件容器、注解式注册、配置驱动开发、事件通知、插件扩展的快速开发框架。
  <p>
    <a href="https://pypi.org/project/autoboot">
        <img src="https://img.shields.io/pypi/v/autoboot?color=%2334D058&label=pypi%20package" alt="Version">
    </a>
    <a href="https://pypi.org/project/autoboot">
          <img src="https://img.shields.io/pypi/pyversions/autoboot.svg?color=%2334D058" alt="Python">
    </a>
    <a href="https://pepy.tech/project/autoboot">
        <img src="https://static.pepy.tech/personalized-badge/autoboot?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=Downloads" alt="Downloads">
    </a>
    <a href="https://github.com/yizzuide/autoboot/blob/main/LICENSE">
        <img src="https://img.shields.io/github/license/yizzuide/autoboot" alt="License">
    </a>
  </p>


  在使用Python开发AI应用服务时遇到以下问题：

  - 在`.env`里添加配置的方式，在获取配置参数时很容易写错，且调用没有代码提示。
  - 配置参数较多时会让查找起来比较混乱，无法分类进行管理。
  - 各种对象创建在各个函数和方法里，但多时候只需要创建一个单例。
  - 很多代码和函数写在全局执行文件，创建的上下文数据在调用其它函数时需要层层传递。



  由于Python有自身的语法特性，开发时也得到了天然的优化支持，以下是对比的测试环境：

  | 开发语言 | 框架 | server |
  | :----: | :----: | :----: |
  | Python 3.11 | autoboot 0.10 | uvicorn
  | Java 1.8 | SpringBoot 2.7 | Tomcat

  - 基于单容器设计，使用简单，学习成本低。
  - 不需要扫描组件所在的包，所有组件只需要声明即可（除Listener特殊组件需要配置扫描外）。
  - 所有声明的组件只有在调用时才会创建并缓存，实现了SpringBoot推荐的懒加载创建方式。
  - 配置采用`.env + yaml`组合，`.env`用于支持多环境配置项，主配置使用`autoboot.yaml`，框架扩展了yaml自定义指令`!env`用于从`.env`中获取配置参数。
  - 没有历史遗留包袱，启动创建的对象少，占用内存低。
  - 微服务项目的启动速度快到可以在1-2秒内启动完成，相比SpringBoot的10几秒，快了至少10倍。




  ```bash
  pip install autoboot
  ```




  * 启动配置文件`./config/.env`

  ```ini

  ENV_NAME=dev


  APPLICATION_NAME=demo
  ```

  * 环境配置文件`./config/.env.dev`

  ```ini
  APPLICATION_NAME=demo-dev
  ```

  * 主配置文件`./config/autoboot.yaml`

  ```yml
  autoboot:
    application:
      
      name: !env $APPLICATION_NAME
      
      module: api
      
      log:
        dir: logs
        
        max_size: !!str 100 MB
        retention: !!str 30 days
  ```


  ```python
  from autoboot import AutoBoot, AutoBootConfig

  context = Autoboot(AutoBootConfig(config_dir="./config"))
  context.run()


  Autoboot.logger.info("Context run succeed!")
  ```






  ```yml
  api:
    
    secret: !env $API_SECRET_KEY
  ```


  ```python
  from autoboot.annotation import static_property

  class ApiProperties:

    @static_property("api.secret")
    def secret() -> str:
      
      return ""
  ```


  ```python
  from autoboot import AutoBoot, AutoBootConfig
  from .api_properties import ApiProperties

  context = Autoboot(AutoBootConfig(config_dir="./config"))
  context.run()


  Autoboot.logger.info("api.secret: {}", ApiProperties.secret())
  ```




  创建组件`hello_service.py`文件：

  ```python
  from autoboot.annotation import component

  @component()
  class HelloService(object):
    def __init__(self):
      pass

    def hello(self):
      return "Hello World!"
  ```



  如果注册的类来自第三方库，无法采用继承Component的方式，那么可以通过下面方式来注册：

  ```python
  from autoboot.annotation import component
  from .hello_service import HelloService


  @component(name='HelloService')
  def hello_service():
    return HelloService()
  ```


  ```python
  from autoboot import AutoBoot, AutoBootConfig
  from .hello_service import HelloService

  context = Autoboot(AutoBootConfig(config_dir="./config"))
  context.run()



  assert id(HelloService()) == id(HelloService())
  Autoboot.logger.info("HelloService.hello: {}", HelloService().hello())
  ```





  ```yml
  autoboot:
    application:
      
      scan_listener_packages:
        - listener
  ```



  * 在该目录创建`__init__.py`

  ```python
  from .app_listener import AppListener

  __all__ = ["AppListener"]
  ```

  * 在该目录创建`app_listener.py`

  ```python
  from autoboot import AutoBoot
  from autoboot.event import ApplicationListener
  from autoboot.meta import Listener

  @Listener
  class AppListener(ApplicationListener):

    def on_env_prepared(self, config: dict[str, Any]):
      AutoBoot.logger.info("listen: env prepared!")

    def on_started(self):
      AutoBoot.logger.info("listen: app started!")

  ```




  ```python
  from dataclasses import dataclass
  from autoboot.event import emitter, Event
  from loguru import logger

  @dataclass(slots=True)
  class PayOrder:
    no: str

  @emitter.on("pay_action")
  def received_payment(event: Event[str]):
    logger.info("received_payment")
    assert(event.data == "pay order: 1001")


  emitter.emit(action="pay_action", event=Event("pay order: 1001"))
  ```


  ```python
  from dataclasses import dataclass
  from autoboot.event import emitter, Event
  from loguru import logger

  @dataclass(slots=True)
  class PayOrder:
    no: str

  @emitter.on_event
  def received_pay(event: Event[PayOrder]):
    logger.info("received_pay")
    assert(event.data == PayOrder("1001"))

  emitter.emit(event=Event(PayOrder("1001")))
  ```



  ```python
  from autoboot.plugin import AppPlugin

  class MyPlugin(AppPlugin):
    def install(self):
      AutoBoot.logger.info("plugin: installed!")

    def on_env_prepared(self, config: dict[str, Any]):
      AutoBoot.logger.info("plugin: env prepared!")

    def on_started(self):
      AutoBoot.logger.info("plugin: started!")
  ```


  ```python
  from autoboot import AutoBoot, AutoBootConfig
  from .my_plugin import MyPlugin

  context = Autoboot(AutoBootConfig(config_dir="./config"))
  context.apply(MyPlugin())
  context.run()
  ```


  * [autoboot-web](https://github.com/yizzuide/autoboot-web)
  * [autoboot-data](https://github.com/yizzuide/autoboot-data)


  有问题可以在issues开话题讨论，如果你有新的想法，创建新的`feat`或`pref`分支并提交PR。


  [MIT License](https://github.com/yizzuide/autoboot/blob/main/LICENSE.txt)


pkgId: 3efa62c3c73eff845fb2b21cfb23d412f51d8daf62c3b74826135fe6369f86aa
name: python-autobuild
arch: src
version: 3.9.6
epoch: 0
release: 1
summary: Linden Lab Automated Package Management and Build System
url: http://wiki.secondlife.com/wiki/Autobuild
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autobuild-3.9.6-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/secondlife/autobuild/branch/main/graph/badge.svg?token=8GBLMAFDIN)](https://codecov.io/gh/secondlife/autobuild)

  **Autobuild** is a framework for building packages and for managing the
  dependencies of a package on other packages. It provides a common
  interface to configuring and building any package, but it is not a
  build system like make or cmake. You will still need platform-specific
  make, cmake, or project files to configure and build your
  library. Autobuild will, however, allow you invoke these commands and
  package the product with a common interface.

  *Important: Linden Lab Autobuild is not the same as or derived from GNU
  Autobuild, but they are similar enough to cause confusion.*

  For more information, see [Autobuild's wiki page][wiki].

  [wiki]: https://wiki.secondlife.com/wiki/Autobuild



  | Name | Default | Description |
  |-|-|-|
  | AUTOBUILD_ADDRSIZE | 32 | Target address size |
  | AUTOBUILD_BUILD_ID | - | Build identifier |
  | AUTOBUILD_CONFIGURATION | - | Target build configuration |
  | AUTOBUILD_CONFIG_FILE | autobuild.xml | Autobuild configuration filename |
  | AUTOBUILD_CPU_COUNT | - | Build system cpu core count |
  | AUTOBUILD_GITHUB_TOKEN | - | GitHub HTTP authorization token to use during package download |
  | AUTOBUILD_GITLAB_TOKEN | - | GitLab HTTP authorization token to use during package download |
  | AUTOBUILD_INSTALLABLE_CACHE | - | Location of local download cache |
  | AUTOBUILD_LOGLEVEL | WARNING | Log level |
  | AUTOBUILD_PLATFORM | - | Target platform |
  | AUTOBUILD_SCM_SEARCH | true | Whether to search for .git in parent directories if using SCM version discovery |
  | AUTOBUILD_VARIABLES_FILE | - | .env file to load |
  | AUTOBUILD_VCS_BRANCH | git branch | autobuild-package.xml VCS info: branch name.  |
  | AUTOBUILD_VCS_INFO | false | Whether to include version control information in autobuild-package.xml |
  | AUTOBUILD_VCS_REVISION | git commit | autobuild-package.xml VCS commit reference to include in autobuild-package.xml. Defaults to current git commit sha. |
  | AUTOBUILD_VCS_URL | git remote url | autobuild-package.xml VCS info: repository URL |
  | AUTOBUILD_VSVER | - | Target Visual Studio version to use on windows |


pkgId: 8d4bf4fbde290ce26f2b0387c5f5ce80f7838299cc625e64a90edce24651cd31
name: python-autocfg
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Deep learning configuration
url: https://github.com/zhreshold/autocfg
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocfg-0.0.8-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/autocfg.svg)](https://pypi.python.org/pypi/autocfg)

  All you need is a minimal config system for automl.





  See [basic usage](examples/basics.ipynb)



  See [version control](examples/versioning.ipynb)


pkgId: df5f785eecacbeee78ae04355ec06ba6fa5dc85709c83849cfea297be450947e
name: python-autochat
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Small OpenAI/Anthropic library to support chat templates, and function calls
url: https://github.com/benderv/autochat
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autochat-0.3.7-1.src.rpm
checksum_type: sha256
description:
  AutoChat is an assistant library, that supports OpenAI/Anthropic, to simplify the process of creating interactive agents.

  - **Autochat Class**: Conversation wrapper to store instruction, context and messages histories.
  - **Message Class**: Message wrapper to handle format/parsing automatically.
  - **Function Calls**: Capability to handle function calls within the conversation, allowing complex interactions and responses.
  - **Template System**: A straightforward text-based template system for defining the behavior of the chatbot, making it easy to customize its responses and actions.



  To install the package, you can use pip:

  ```bash
  pip install autochat
  ```

  Please note that this package requires Python 3.6 or later.



  ```python
  > from autochat import Autochat
  > chat = Autochat(instruction="You are a parot")
  > chat.ask('Hi my name is Bob')

  > chat.ask('Can you tell me my name?')

  ```



  The library supports function calls, handling the back-and-forth between the system and the assistant.

  ```python
  from autochat import Autochat, Message
  import json

  def label_item(category: str, from_response: Message):
      
      raise NotImplementedError()

  with open("./examples/function_label.json") as f:
      FUNCTION_LABEL_ITEM = json.load(f)

  classifierGPT = Autochat.from_template("./examples/classify_template.txt")
  classifierGPT.add_function(label_item, FUNCTION_LABEL_ITEM)

  text = "The new iPhone is out"
  for message in classifierGPT.run_conversation(text):
      print(message.to_markdown())








  ```



  We provide a simple template system for defining the behavior of the chatbot, using markdown-like syntax.

  ```

  You are a parrot


  Hi my name is Bob


  Hi my name is Bob, hi my name is Bob!


  Can you tell me my name?


  Your name is Bob, your name is Bob!
  ```

  You can then load the template file using the `from_template` method:

  ```python
  parrotGPT = Autochat.from_template("./parrot_template.txt")
  ```

  The template system also supports function calls. Check out the [examples/demo_label.py](examples/demo_label.py) for a complete example.



  Default provider is openai.

  Anthropic:

  ```python
  chat = Autochat(provider="anthropic")
  ```



  The `AUTOCHAT_MODEL` environment variable specifies the model to use. If not set, it defaults to "gpt-4-turbo".

  ```bash
  export AUTOCHAT_MODEL="gpt-4-turbo"
  export OPENAI_API_KEY=<your-key>
  ```

  or with anthropic

  ```bash
  export AUTOCHAT_MODEL="claude-3-opus"
  export ANTHROPIC_API_KEY=<your-key>
  ```

  Use `AUTOCHAT_HOST` to use alternative provider (openai, anthropic, openpipe, llama_cpp, ...)



  If you encounter any issues or have questions, please file an issue on the GitHub project page.



  This project is licensed under the terms of the MIT license.


pkgId: b82b7200f4dcd343d427dc6871a702681e64ef6d9a1bfe298464b945e815f405
name: python-autoclasstoc
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Add a succinct TOC to auto-documented classes.
url: https://pypi.org/project/autoclasstoc/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoclasstoc-1.6.0-1.src.rpm
checksum_type: sha256
description:
  ************
  autoclasstoc
  ************

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

  .. image:: https://img.shields.io/pypi/pyversions/autoclasstoc.svg
     :target: https://pypi.python.org/pypi/autoclasstoc

  .. image:: https://img.shields.io/readthedocs/autoclasstoc.svg
     :target: https://autoclasstoc.readthedocs.io/en/latest/?badge=latest

  It's surprisingly difficult to document large Python classes in a way that's
  easy for users to navigate.  Most projects use the ``autodoc`` Sphinx plugin,
  which simply puts the complete documentation for each class member one after
  another.  While this does fully document the class, it doesn't give the user a
  quick way to see everything the class can do.  This makes classes of even
  moderate complexity difficult to navigate.  It also encourages projects to be
  stingy about which class members to include in the documentation (e.g.
  excluding special methods, inherited methods, private methods, and/or
  undocumented methods), to the further detriment of the user.

  What's needed is for each class to have a succinct table of contents (TOC)
  that:

  - Is organized into sections that will be meaningful to the user.  Different
    projects and classes may call for different sections, e.g. public/private
    methods, methods that share a decorator, methods with a common prefix, etc.

  - Includes every method of the class (so that the documentation is complete),
    while still making it easy for the user to get a sense for what the class
    does and find what they're looking for.

  - Collapses inherited methods.  Complex classes in particular can inherit a lot
    of methods from their parent classes, and while these methods should be
    present in the TOC (since they're part of the class), collapsing them makes
    it easier for the user to grok the functionality provided by the class
    itself.

  ``autoclasstoc`` provides a new Restructured Text directive that is all of
  these things.  It also works well with ``autodoc`` and ``autogen``, and should
  be easy to incorporate into any existing project.

  See the `complete documentation`__ for more information (including examples).

  __ https://autoclasstoc.readthedocs.io/en/latest


pkgId: b9a67b094585b5b8b2356e20c964fc27e397cd5403112f041b1f4f223de95769
name: python-autoclasstoc
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Add a succinct TOC to auto-documented classes.
url: https://pypi.org/project/autoclasstoc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoclasstoc-1.7.0-1.src.rpm
checksum_type: sha256
description:
  ************
  autoclasstoc
  ************

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

  .. image:: https://img.shields.io/pypi/pyversions/autoclasstoc.svg
     :target: https://pypi.python.org/pypi/autoclasstoc

  .. image:: https://img.shields.io/readthedocs/autoclasstoc.svg
     :target: https://autoclasstoc.readthedocs.io/en/latest/?badge=latest

  .. image:: https://img.shields.io/github/actions/workflow/status/kalekundert/autoclasstoc/test.yml?branch=master
     :target: https://github.com/kalekundert/autoclasstoc/actions

  .. image:: https://img.shields.io/codecov/c/gh/kalekundert/autoclasstoc
     :target: https://app.codecov.io/gh/kalekundert/autoclasstoc

  It's surprisingly difficult to document large Python classes in a way that's
  easy for users to navigate.  Most projects use the ``autodoc`` Sphinx plugin,
  which simply puts the complete documentation for each class member one after
  another.  While this does fully document the class, it doesn't give the user a
  quick way to see everything the class can do.  This makes classes of even
  moderate complexity difficult to navigate.  It also encourages projects to be
  stingy about which class members to include in the documentation (e.g.
  excluding special methods, inherited methods, private methods, and/or
  undocumented methods), to the further detriment of the user.

  What's needed is for each class to have a succinct table of contents (TOC)
  that:

  - Is organized into sections that will be meaningful to the user.  Different
    projects and classes may call for different sections, e.g. public/private
    methods, methods that share a decorator, methods with a common prefix, etc.

  - Includes every method of the class (so that the documentation is complete),
    while still making it easy for the user to get a sense for what the class
    does and find what they're looking for.

  - Collapses inherited methods.  Complex classes in particular can inherit a lot
    of methods from their parent classes, and while these methods should be
    present in the TOC (since they're part of the class), collapsing them makes
    it easier for the user to grok the functionality provided by the class
    itself.

  ``autoclasstoc`` provides a new Restructured Text directive that is all of
  these things.  It also works well with ``autodoc`` and ``autogen``, and should
  be easy to incorporate into any existing project.

  See the `complete documentation`__ for more information (including examples).

  __ https://autoclasstoc.readthedocs.io/en/latest


pkgId: 6b3c0090712c8ea699c1011a2af5ebab6ca5b348fc7a98f1cfff8b090736fbef
name: python-autoclasswrapper
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: AutoClassWrapper: a Python wrapper for AutoClass C classification.
url: https://github.com/pierrepo/autoclasswrapper
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoclasswrapper-1.5.1-1.src.rpm
checksum_type: sha256
description:
  [![License: BSD](https://img.shields.io/badge/License-BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)   [![autoclasswrapper version on PyPI](https://badge.fury.io/py/autoclasswrapper.svg)](https://pypi.python.org/pypi/autoclasswrapper)   [![Build Status](https://travis-ci.org/pierrepo/autoclasswrapper.svg?branch=master)](https://travis-ci.org/pierrepo/autoclasswrapper)
  [![Documentation Status](https://readthedocs.org/projects/autoclasswrapper/badge/?version=latest)](https://autoclasswrapper.readthedocs.io/en/latest/?badge=latest)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/pierrepo/autoclasswrapper/master?filepath=notebooks)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2527059.svg)](https://doi.org/10.5281/zenodo.2527059)


  AutoClass is an unsupervised Bayesian classification system.

  [AutoClass C](https://ti.arc.nasa.gov/tech/rse/synthesis-projects-applications/autoclass/autoclass-c/) is an implementation of the AutoClass algorithm made by the NASA.

  AutoClassWrapper is a Python wrapper to ease the use of Autoclass C.







  AutoClass C can be found [here](https://ti.arc.nasa.gov/tech/rse/synthesis-projects-applications/autoclass/autoclass-c/). The installation process can be achieved with the following commands:
  ```
  $ wget https://ti.arc.nasa.gov/m/project/autoclass/autoclass-c-3-3-6.tar.gz
  $ tar zxvf autoclass-c-3-3-6.tar.gz
  $ rm -f autoclass-c-3-3-6.tar.gz
  $ export PATH=$PATH:$(pwd)/autoclass-c
  ```

  Please note that is you are running a 64-bit operating system, you will also need to install the standard 32-bit libraries. For instance, on a Debian/Ubuntu-like system:
  ```
  $ sudo apt-get install -y libc6-i386
  ```




  Dependencies:

  - **Python 3.6** or above
  - Python libraries: NumPy, Pandas, Scipy, matplotlib, chardet

  AutoClassWrapper is available through the Python Package Index ([PyPI](https://pypi.org/)):

  ```
  $ python3 -m pip install autoclasswrapper
  ```




  Documentation is available on [ReadTheDocs](https://autoclasswrapper.readthedocs.io/en/latest/)




  AutoClassWrapper is free software made available under the BSD 3-clause license. For more details see the [LICENSE](LICENSE.txt) file.




  If you want to report a bug, request a feature, or propose an improvement use the [GitHub issue system](https://github.com/pierrepo/autoclasswrapper/issues/).

  Please, see also the [CONTRIBUTING](CONTRIBUTING.md) file.

  Note that this project is released with a [Contributor Code of
  Conduct](http://contributor-covenant.org/). By participating in this project you
  agree to abide by its terms. See the [CODE_OF_CONDUCT](CODE_OF_CONDUCT.md) file.

  **Dev**

  **1.5.1**
  - Create new release for paper in the Journal of Open Source Software

  **1.5.0**
  - Print AutoClass C Version on run
  - Update jinja and urllib3 for security issues
  - Rename input.merge_dataframes() to input.prepare_input_data()
  - Increase documentation


  **1.4.1**
  - Rename marker files to autoclass-run-success and autoclass-run-failure

  **1.4.0**
  - Print columns with missing values one column per line
  - Embed column stats in logging output

  **1.3.0**
  - Redirect run ouput to log files
  - Use f-strings

  **1.2.0**
  - Handle error while checking for autoclass version
  - Fix missing margin in dendrogram picture

  **1.1.0**
  - Rewrite write_dendrogram() method
  - Rename marker files (autoclass_run_*) in snake_case

  **1.0.0**
  - Jump to major release

  **0.2.2**
  - Remove wrap method for results
  - Update list of authorized characters in column names

  **0.2.1**
  - Move function utilities to tools.py
  - Change defaut filename to 'autoclass'

  **0.2.0**
  - Fix error decorator for Sphinx doc generation
  - Use 'class' (instead of 'cluster') for consistency
  - Move get_autoclass_version() out of Run() class
  - Create file marker upon autoclass run success/failure

  **0.1.14**
  - update missing dependencies in setup.cfg
  - improve PEP 8 and PEP 257 compliance
  - add documentation (Sphinx)

  **0.1.13**
  - print Exception content for check_data_type()
  - output class probability for every gene/protein
  - simplify the calculation of cluster stats
  - class/cluster numbering starts at 1 (0-based in autoclass output)
  - add dendrogram of classes
  - add reproducible run option (test only)
  - add tests for Input() class
  - add tests for Output() class
  - add tests for Run() class

  **0.1.12**
  - update write_cluster_stats() methods with mean/std column
  - output data+clusters in clust_data.tsv

  **0.1.11**
  - add nohup while running autoclass script

  **0.1.10**
  - search_autoclass_in_path() returns the PATH

  **0.1.9**
  - check autoclass-c executable is in PATH
  - building and running script are in Run() class

  **0.1.8**
  - add env in Popen()

  **0.1.7**
  - add missing dependencies

  **0.1.6**
  - move distribution package to bdist_wheel

  **0.1.5**
  - move config options to setup.cfg

  **0.1.4**
  - add MANIFEST.in

  **0.1.3**
  - remove tests from Python package

  **0.1.2**
  - add Markdown support for README description

  BSD 3-Clause License

  Copyright (c) 2018, Pierre Poulain
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.

  * Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.

  * Neither the name of the copyright holder nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 3fbaae92d980565832fd1869ee71348c8036b46a68f002b7a75e512d6a97b450
name: python-autoclip
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Smart gradient clippers
url: https://github.com/HesitantlyHuman/autoclip
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoclip-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Pytorch and tensorflow implementations (and variations) of the AutoClip gradient smoothing procedure from [Seetharaman et al](https://arxiv.org/abs/2007.14469).

  > Prem Seetharaman, Gordon Wichern, Bryan Pardo, Jonathan Le Roux. "AutoClip: Adaptive Gradient Clipping for Source Separation Networks." 2020 IEEE 30th International Workshop on Machine Learning for Signal Processing (MLSP). IEEE, 2020.



  While training your model, AutoClip keeps a running history of all of your model's gradient magnitudes. Using these, the gradient clipper can adaptively clamp outlier gradient values before they reach the optimizer of your choice.

  While AutoClip is great as a preventative measure against exploding gradients, it also speeds up training time, and encourages the optimizer to find more optimal models. At an intuitive level, AutoClip compensates for the stochastic nature of training over batches, regularizing training effects.



  AutoClip is listed on pypi. To install AutoClip simply run the following command
  ```
  pip install autoclip
  ```
  and the `autoclip` package will be installed in your currently active environment.



  Below are some examples how to use `autoclip`'s torch API.


  Using the optimizer wrapping pattern is the recommended way to use AutoClip, and `autoclip`'s torch API supports wrapping arbitrary pytorch optimizers. The wrapping pattern allows you to avoid changing your training code when you want to use an AutoClip clipper. This is especially useful if you do not own the training code for whatever reason. (Say for example you are using someone else's Trainer class, as is often the case with frameworks like `huggingface`.)

  The following is an example of how to integrate AutoClip into your model training using this pattern:
  ```python
  import torch
  from autoclip.torch import QuantileClip

  model = torch.nn.Sequential(
      torch.nn.Linear(100, 50),
      torch.nn.ReLU(),
      torch.nn.Linear(50, 2)
  )

  optimizer = torch.optim.AdamW(model.parameters())
  optimizer = QuantileClip.as_optimizer(optimizer=optimizer, quantile=0.9, history_length=1000)
  ```
  Now you can use the optimizer just like you would have before adding the clipper, and the clipping will be applied automatically.


  You can still use the clipper manually if you would like. If this is the case, then you would create your clipper like this:
  ```python
  import torch
  from autoclip.torch import QuantileClip

  model = torch.nn.Sequential(
      torch.nn.Linear(100, 50),
      torch.nn.ReLU(),
      torch.nn.Linear(50, 2)
  )

  clipper = QuantileClip(model.parameters(), quantile=0.9, history_length=1000)
  ```
  Then, to clip the model's gradients, simply run the clipper's `.step()` function during your training loop. Note that you should call the clipper's `step` before you call your optimizer's `step`. Calling it after would mean that your clipping will have no effect, since the model will have already been updated using the unclipped gradients. For example:
  ```python
  for batch_num, batch in enumerate(training_dataset):
      model_prediction = model(batch['data'])
      loss = loss_function(model_prediction, batch['targets'])
      loss.backward()
      clipper.step() # clipper comes before optimizer
      optimizer.step()
  ```


  `autoclip`'s torch clippers support two clipping modes. The first is `global_clipping`, which is the original AutoClip as described in Seetherman et al. The second is local or parameter-wise clipping. In this mode a history is kept for every parameter, and each is clipped according to its own history. By default, the `autoclip` clippers will use the parameter-wise clipping.
  To use the global mode, simply pass the appropriate flag:
  ```python
  clipper = QuantileClip(
      model.parameters(),
      quantile=0.9,
      history_length=1000,
      global_clipping=True
  )
  ```


  The torch clippers also support checkpointing through `state_dict()` and `load_state_dict()`, just like torch models and optimizers. For example, if you want to checkpoint a clipper to `clipper.pth`:
  ```python
  clipper = QuantileClip(model.parameters())
  torch.save(clipper.state_dict(), 'clipper.pth')


  clipper = QuantileClip(model.parameters())
  clipper.load_state_dict(torch.load('clipper.pth'))
  ```
  Keep in mind that just like a torch optimizer this will error if you give the clipper differently sized model parameters.

  While it is generally recommended to use `state_dict`s instead (see the [pytorch documentation](https://pytorch.org/tutorials/beginner/saving_loading_models.html#save-load-entire-model) on this subject for more info), you may also use `torch.save` and `torch.load` directly to pickle the entire clipper object.


  `autoclip`'s tensorflow API does not currently have feature parity with the torch API (If you want to change this, feel free to [contribute](https://github.com/HesitantlyHuman/autoclip/issues/2)).
  As it is, the tensorflow API currently only supports the original AutoClip algorithm, and does not support checkpointing. Below is a short example:
  ```python
  import tensorflow as tf
  from autoclip.tf import QuantileClip

  model = tf.keras.models.Sequential(
      [
          tf.keras.layers.Dense(50),
          tf.keras.layers.ReLU(),
          tf.keras.layers.Dense(10),
          tf.keras.layers.ReLU(),
          tf.keras.layers.Dense(
              2,
              activation=tf.keras.activations.tanh
          ),
      ]
  )
  model.compile(
      optimizer=tf.keras.optimizers.Adam(
          learning_rate=0.001,
          gradient_transformers=[
              QuantileClip(
                  quantile=0.9,
                  history_length=1000
              )
          ]
      ),
      loss="mean_absolute_error",
      metrics=["accuracy"],
  )
  model.fit(train_data, train_targets)
  ```


pkgId: fc2289f57e363d8e1918de897abe81cd8d6ed24561621b0eac0bb590263993f3
name: python-autococonut
arch: src
version: 0.9.16
epoch: 0
release: 1
summary: A workflow recording tool.
url: https://pypi.org/project/autococonut/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autococonut-0.9.16-1.src.rpm
checksum_type: sha256
description:
  **AutoCoconut** is a tool that enables tracking mouse and keyboard events to make a workflow report with screenshot illustrations.
  Such workflow report can be helpful when creating bug reports, tutorials, or test cases for GUI testing frameworks, such as OpenQA
  and others.

  **AutoCoconut** works on **X11** sessions only. The current version is **not Wayland ready**.



  Currently, the development has reached **Phase 4**.

  Which means that the script is able:

  * record various events,  mouse buttons and actions (click, double click, drag, vertical scroll), keyboard events (press and release)
  * identify various types of keys (modifiers, special keys, character keys, etc.)
  * find pre-defined patterns in single events and interpret them
  * take screenshots to illustrate the workflow (or create needles for OpenQA)
  * produce various output - *raw* file, *json* file, or a workflow description in adoc and html.
  * it has a GUI version which brings more functionality, such as edit, delete, or create events for the recorded workflow
  * is packaged on PyPi for easy installation.




  The script is being developed and tested on Fedora, so the following procedure is related to Fedora. For other distributions, you need to
  make sure, that the following requirements are met:

  * Python development packages.
  * Tkinter libraries

  On Fedora, you can follow this procedure:

  1. Install the `python3-devel`.
  2. Install `python3-tkinter`.

  Then you can install the application:

  1. `pip install --user autococonut`



  See the documentation in the `docs` directory of the `autococonut` package.


pkgId: 22f253ad2b228c2e4300ebf790e8b23589f61c1b73c34f19433647f9ede0f3be
name: python-autocode-py
arch: src
version: 0.0.1.post9
epoch: 0
release: 1
summary: autocode: Auto Code Improvement by Metrics Optimization.
url: https://github.com/muazhari/autocode
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocode-py-0.0.1.post9-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13225517.svg)](https://doi.org/10.5281/zenodo.13225517)



  Auto Code Improvement by Metrics Optimization.



  Autocode selects the best values for optimized metrics. The value types could be bool, int, float, and choice (including
  but not limited to code). This project utilizes a Large Language Model and Mixed-Variable Many-Objective Optimization.
  Based on our research/literature review, this project hypothetically can contribute to the economic performance of
  companies.



  - Many-software Value-level Mixed-variable Many-objective Optimization.
  - Value types include bool, int, float, and choice (code).
  - Code scoring and variation generators using LLM.
  - Software cross-language support.
  - Easy software deployment using docker-compose.
  - Scalable to infinite cores to speed up processing in parallel.



  1. Install the requirements

  ```bash
  pip install -U autocode-py
  ```

  2. Prepare software to be processed as in the [`./example/client`](https://github.com/muazhari/autocode/tree/main/example/client) folder.
  3. Prepare deployment as in the [`./example/client/docker-compose.yml`](https://github.com/muazhari/autocode/blob/main/example/client/docker-compose.yml) file.
  4. Prepare controller as in the [`./example/controller.ipynb`](https://github.com/muazhari/autocode/blob/main/example/controller.ipynb) file.
  5. Instantiate `optimization` then execute `optimization.deploy()` in controller.
  6. Open dashboard in `http://localhost:{dashboard_port}/` to see the process in real-time.
  7. Wait until all client are ready (need to wait for long time because the libraries need to be re-downloaded for each client).
  8. Execute `optimization.run()` in controller.
  9. Wait until the run is finished.
  10. Analyze and decide the best values.
  11. Execute `optimization.reset(keys=["clients"])` then `optimization.deploy()` to apply different client states.
  12. Try to execute `optimization.reset()` to totally reset the tool if needed (i.e. data inconsistency).



  - [Controller](https://github.com/muazhari/autocode/blob/main/example/controller.ipynb)
  - [Client](https://github.com/muazhari/autocode/tree/main/example/client)
  - Dashboard
    ![demo-1.png](https://github.com/muazhari/autocode/blob/main/demo-1.png?raw=true)



  - Python 3.10, 3.11
  - Linux
  - Docker
  - [autocode-go](https://github.com/muazhari/autocode-go)


pkgId: 906bc0e8bc279d578a9d67ca7b6ce293e42647199d381789433d5f5ec2d5da3b
name: python-autocog
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/andreasjansson/AutoCog
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocog-0.0.11-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/autocog.svg)](https://badge.fury.io/py/autocog)

  _Generate [predict.py and cog.yaml](https://github.com/replicate/cog) automatically using GPT4_




  ```
  pip install autocog
  ```



  First, specify your AI provider with `--ai-provider` and set your OpenAI/Anthropic API key in an environment variable

  ```
  OPENAI_API_KEY=sk-...
  ANTHROPIC_API_KEY=sk-...
  ```

  In the repo you want to cog-ify, run

  ```
  autocog
  ```

  This will generate a cog.yaml and predict.py based on the files in the current directory. It will then run the model and if it fails to run, it will attempt to fix the error and run it again. By default it has 5 attempts to fix it, which can be changed with the `--attempts` flag.

  If your model needs a GPU to run, you need to run AutoCog on a GPU machine.



  Sometimes AutoCog fails to create a working Cog configuration. In those cases you, the human, have to step in and edit the cog.yaml and predict.py files.

  Once you have edited them, let AutoCog continue by running `autocog` again. If you'd like to recreate `predict.py` and `cog.yaml` from scratch, run `autocog --initialize`.

  By default, AutoCog will guess a `cog predict` command to run the model. If you want to specify your own predict command, use the `--predict-command` flag.

  If you want AutoCog to take the generation of `cog.yaml` and `predict.py` in a specific direction, you can use the `--tell` flag to prompt GPT4:

  ```
  autocog --tell="Add inputs to allow for inpainting"
  ```


pkgId: 393057411c7329d66641e6d38d588533da746c2a7ec2302652172e7cbd7d565c
name: python-autocombobox
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Insert a Combobox into your GUI that allows suggestions based on what the user writes in
url: https://github.com/Church-17/autocombobox
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocombobox-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/autocombobox?style=flat)](https://pypi.python.org/pypi/autocombobox/)

  AutoCombobox is a Ttk widget based on the existing Combobox. It allows the user to write on the entry field, viewing at the same time some suggested option based on what the user writes. The suggestions are customizable through a function that can be defined by the developer.

  ![](./images/description.png)



  AutoCombobox can be installed from PyPI using the command `pip install autocombobox`.
  It doesn't have any dependences other than Tkinter.



  AutoCombobox was created specifically to be used like the normal Ttk Combobox, so all its options are available.
  Beside that, it can accept the `filter` option, that allows the developer to pass the function that determines the suggestions. The function must take 2 parameters: the first represent the list of all possible options of the Combobox, and the second represent the text written on the entry field; the function must returns a list of integers rappresenting the indices of the position of each option (a negative value indicates that the option will not be shown). There is a default filter function, that shows all the options that starts with the user input.

  AutoCombobox makes available also various useful methods:
  - `show_listbox` and `hide_listbox` are the functions that manage the list of the Combobox options;
  - `update_values` takes an optional string and filters the list of all possible values based on it, to show only suggestions. If no strings is given, it is taken from the entry field;
  - `select` takes a string, and set the entry field with that. If the string is also in the possible value, it generate a `<<ComboboxSelected>>` event;
  - `change_highlight` takes the index of the option we want to highglights.

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


pkgId: ebca22b33fc283d17f13bb24568a5f0286e3d5ce911ca991aee44acafe43930b
name: python-autocommand
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: A library to create a command-line program from a function
url: https://github.com/Lucretiel/autocommand
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocommand-2.2.2-1.src.rpm
checksum_type: sha256
description:
      Some extra documentation in the epilog
      '''
      with smart_open(infile) as istr:
          with smart_open(outfile, 'w') as ostr:
              for line in istr:
                  ostr.write(line)
  ```
  ```
  $ python copy.py -h
  usage: copy.py [-h] [-i INFILE] [-o OUTFILE]
  Copy an the contents of a file (or stdin) to another file (or stdout)
  optional arguments:
    -h, --help            show this help message and exit
    -i INFILE, --infile INFILE
    -o OUTFILE, --outfile OUTFILE
  Some extra documentation in the epilog
  $ echo "Hello World" | python copy.py --outfile hello.txt
  $ python copy.py --infile hello.txt --outfile hello2.txt
  $ python copy.py --infile hello2.txt
  Hello World
  ```

  You can also attach description text to individual parameters in the annotation. To attach both a type and a description, supply them both in any order in a tuple
  ```python
  @autocommand(__name__)
  def copy_net(
      infile: 'The name of the file to send',
      host: 'The host to send the file to',
      port: (int, 'The port to connect to')):
      '''
      Copy a file over raw TCP to a remote destination.
      '''
      
  ```

  Autocommand automatically follows wrapper chains created by `@functools.wraps`. This means that you can apply other wrapping decorators to your main function, and autocommand will still correctly detect the signature.
  ```python
  from functools import wraps
  from autocommand import autocommand
  def print_yielded(func):
      '''
      Convert a generator into a function that prints all yielded elements
      '''
      @wraps(func)
      def wrapper(*args, **kwargs):
          for thing in func(*args, **kwargs):
              print(thing)
      return wrapper
  @autocommand(__name__,
      description= 'Print all the values from START to STOP, inclusive, in steps of STEP',
      epilog=      'STOP and STEP default to 1')
  @print_yielded
  def seq(stop, start=1, step=1):
      for i in range(start, stop + 1, step):
          yield i
  ```
  ```
  $ seq.py -h
  usage: seq.py [-h] [-s START] [-S STEP] stop
  Print all the values from START to STOP, inclusive, in steps of STEP
  positional arguments:
    stop
  optional arguments:
    -h, --help            show this help message and exit
    -s START, --start START
    -S STEP, --step STEP
  STOP and STEP default to 1
  ```
  Even though autocommand is being applied to the `wrapper` returned by `print_yielded`, it still retreives the signature of the underlying `seq` function to create the argument parsing.

  While autocommand's automatic parser generator is a powerful convenience, it doesn't cover all of the different features that argparse provides. If you need these features, you can provide your own parser as a kwarg to `autocommand`:
  ```python
  from argparse import ArgumentParser
  from autocommand import autocommand
  parser = ArgumentParser()

  parser.add_argument('arg', nargs='?')

  group = parser.add_mutually_exclusive_group()
  group.add_argument('-v', '--verbose', action='store_true')
  group.add_argument('-q', '--quiet', action='store_true')
  @autocommand(__name__, parser=parser)
  def main(arg, verbose, quiet):
      print(arg, verbose, quiet)
  ```
  ```
  $ python parser.py -h
  usage: write_file.py [-h] [-v | -q] [arg]
  positional arguments:
    arg
  optional arguments:
    -h, --help     show this help message and exit
    -v, --verbose
    -q, --quiet
  $ python parser.py
  None False False
  $ python parser.py hello
  hello False False
  $ python parser.py -v
  None True False
  $ python parser.py -q
  None False True
  $ python parser.py -vq
  usage: parser.py [-h] [-v | -q] [arg]
  parser.py: error: argument -q/--quiet: not allowed with argument -v/--verbose
  ```
  Any parser should work fine, so long as each of the parser's arguments has a corresponding parameter in the decorated main function. The order of parameters doesn't matter, as long as they are all present. Note that when using a custom parser, autocommand doesn't modify the parser or the retrieved arguments. This means that no description/epilog will be added, and the function's type annotations and defaults (if present) will be ignored.

  The decorated function is only called and exited from if the first argument to `autocommand` is `'__main__'` or `True`. If it is neither of these values, or no argument is given, then a new main function is created by the decorator. This function has the signature `main(argv=None)`, and is intended to be called with arguments as if via `main(sys.argv[1:])`. The function has the attributes `parser` and `main`, which are the generated `ArgumentParser` and the original main function that was decorated. This is to facilitate testing and library use of your main. Calling the function triggers a `parse_args()` with the supplied arguments, and returns the result of the main function. Note that, while it returns instead of calling `sys.exit`, the `parse_args()` function will raise a `SystemExit` in the event of a parsing error or `-h/--help` argument.
  ```python
      @autocommand()
      def test_prog(arg1, arg2: int, quiet=False, verbose=False):
          if not quiet:
              print(arg1, arg2)
              if verbose:
                  print("LOUD NOISES")
          return 0
      print(test_prog(['-v', 'hello', '80']))
  ```
  ```
  $ python test_prog.py
  hello 80
  LOUD NOISES
  0
  ```
  If the function is called with no arguments, `sys.argv[1:]` is used. This is to allow the autocommand function to be used as a setuptools entry point.

  - There are a few possible exceptions that `autocommand` can raise. All of them derive from `autocommand.AutocommandError`.
    - If an invalid annotation is given (that is, it isn't a `type`, `str`, `(type, str)`, or `(str, type)`, an `AnnotationError` is raised. The `type` may be any callable, as described in the `Types`_ section.
    - If the function has a `**kwargs` parameter, a `KWargError` is raised.
    - If, somehow, the function has a positional-only parameter, a `PositionalArgError` is raised. This means that the argument doesn't have a name, which is currently not possible with a plain `def` or `lambda`, though many built-in functions have this kind of parameter.
  - There are a few argparse features that are not supported by autocommand.
    - It isn't possible to have an optional positional argument (as opposed to a `--option`). POSIX thinks this is bad form anyway.
    - It isn't possible to have mutually exclusive arguments or options
    - It isn't possible to have subcommands or subparsers, though I'm working on a few solutions involving classes or nested function definitions to allow this.

  Autocommand cannot be important from the project root; this is to enforce separation of concerns and prevent accidental importing of `setup.py` or tests. To develop, install the project in editable mode:
  ```
  $ python setup.py develop
  ```
  This will create a link to the source files in the deployment directory, so that any source changes are reflected when it is imported.


pkgId: 7a91f64d549eecde91db9b13edb71a0ee2e416a1a0189859d27e42fd2904d4ca
name: python-autocron
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Asynchronous background tasks for Python web-frameworks with no dependencies
url: https://github.com/kbr/autocron
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocron-1.2.2-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/pypi/pyversions/autocron.svg)
  ![](https://img.shields.io/pypi/l/autocron.svg)


  **autocron** is a Python background task library with no dependencies beside the standard library. It works out of the box with webframeworks like django, pyramid, flask, bottle, tornado or starlette.

  **autocron** makes it easy to delegate long running and recurring tasks to external processes. No hassle with configuration-files.

  **autocron** is designed for the vast majority of webapplications that don't need massive scaling. And don't want to add unnecessary dependencies.




  For installation use pip:

  ```
      $ pip install autocron
  ```

  or conda:

  ```
      $ conda install autocron
  ```



  autocron provides two decorators: ``cron`` that takes a string in [cron](https://en.wikipedia.org/wiki/Cron#CRON_expression)-format as argument, but accepts also keyword-arguments like *minutes* and *hours*. And ``delay`` to delegate a long running task to a background process.

  Here is a simple example how to use autocron with the flask web-framework that can be run with ``$ flask --app application run``:

  ```
      

      import autocron
      from flask import Flask

      app = Flask(__name__)
      autocron.start("the_flask_app.db")

      @autocron.cron("* * * * *")
      def cronjob():
          

      @autocron.delay
      def do_this_later():
          

      @app.route("/later")
      def later():
          do_this_later()
          return "delayed action triggered"
  ```

  After creating the flask ``app`` instance calling ``autocron.start(<databasename>)`` starts the background workers. The ``cron`` decorated ``cronjob()`` function will get executed every minute and the ``delay`` decorated ``do_this_later()`` function gets delegated to the background worker every time the application processes the ``/later`` url. Terminating the application will shut down the worker processes.

  More information and examples how to use autocron with other frameworks are at the documentation.




  The full documentation and release notes are at [https://autocron.readthedocs.org](https://autocron.readthedocs.org)


pkgId: 417fa2a08a270faae089b21264bb3ce36619116515e043e712fd77f10db6260f
name: python-autocrop
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Automatically crops faces from batches of pictures
url: https://github.com/leblancfg/autocrop
rpm_license: BSD 2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocrop-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/leblancfg/autocrop/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/leblancfg/autocrop/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/leblancfg/autocrop/branch/master/graph/badge.svg)](https://codecov.io/gh/leblancfg/autocrop) [![Documentation](https://img.shields.io/badge/docs-passing-success.svg)](https://leblancfg.com/autocrop) [![PyPI version](https://badge.fury.io/py/autocrop.svg)](https://badge.fury.io/py/autocrop) [![Downloads](https://pepy.tech/badge/autocrop)](https://pepy.tech/project/autocrop)

  <p align="center"><img title="obama_crop" src="https://cloud.githubusercontent.com/assets/15659410/10975709/3e38de48-83b6-11e5-8885-d95da758ca17.png"></p>

  Perfect for profile picture processing for your website or batch work for ID cards, autocrop will output images centered around the biggest face detected.


  Simple!

  ~~~sh
  pip install autocrop
  ~~~


  Autocrop can be used [from the command line](#from-the-command-line) or directly [from Python API](#from-python).


  Import the `Cropper` class, set some parameters (optional), and start cropping.

  The `crop` method accepts filepaths or `np.ndarray`, and returns Numpy arrays. These are easily handled with [PIL](https://pillow.readthedocs.io/) or [Matplotlib](https://matplotlib.org/).

  ~~~python
  from PIL import Image
  from autocrop import Cropper

  cropper = Cropper()


  cropped_array = cropper.crop('portrait.png')


  if cropped_array:
      cropped_image = Image.fromarray(cropped_array)
      cropped_image.save('cropped.png')
  ~~~

  Further examples and use cases are found in the [accompanying Jupyter Notebook](https://github.com/leblancfg/autocrop/blob/master/examples/visual_tests.ipynb).



  	usage: [-h] [-o OUTPUT] [-i INPUT] [-w WIDTH] [-H HEIGHT] [-e EXTENSION] [-v]

  	Automatically crops faces from batches of pictures

  	optional arguments:
  	  -h, --help
  	  		Show this help message and exit
  	  -o, --output, -p, --path
  			Folder where cropped images will be placed.
  			Default: current working directory
  	  -r, --reject
  			Folder where images without detected faces will be placed.
  			Default: same as output directory
  	  -i, --input
  			Folder where images to crop are located.
  			Default: current working directory
  	  -w, --width
  			Width of cropped files in px. Default=500
  	  -H, --height
  			Height of cropped files in px. Default=500
  	  --facePercent
  	  		Zoom factor. Percentage of face height to image height.
  	  -e, --extension
  	  		Enter the image extension which to save at output.
  	  		Default: Your current image extension
  	  -v, --version
  	  		Show program's version number and exit



  * Crop every image in the `pics` folder, resize them to 400 px squares, and output them in the `crop` directory:
  	- `autocrop -i pics -o crop -w 400 -H 400`.
  	- Images where a face can't be detected will be left in `crop`.
  * Same as above, but output the images with undetected faces to the `reject` directory:
  	- `autocrop -i pics -o crop -r reject -w 400 -H 400`.
  * Same as above but the image extension will be `png`:
  	- `autocrop -i pics -o crop -w 400 -H 400 -e png`

  If no output folder is added, asks for confirmation and destructively crops images in-place.


  You can use autocrop to detect faces in frames extracted from a video. A great way to [perform the frame extraction step is with `ffmpeg`](https://ffmpeg.org/download.html):

  ```sh
  mkdir frames faces


  ffmpeg -i input.mp4 -filter:v fps=fps=1/60 frames/ffmpeg_%0d.bmp


  autocrop -i frames -o faces -e jpg
  ```




  The following file types are supported:

  - EPS files (`.eps`)
  - GIF files (`.gif`) (only the first frame of an animated GIF is used)
  - JPEG 2000 files (`.j2k`, `.j2p`, `.jp2`, `.jpx`)
  - JPEG files (`.jpeg`, `.jpg`, `.jpe`)
  - LabEye IM files (`.im`)
  - macOS ICNS files (`.icns`)
  - Microsoft Paint bitmap files (`.msp`)
  - PCX files (`.pcx`)
  - Portable Network Graphics (`.png`)
  - Portable Pixmap files (`.pbm`, `.pgm`, `.ppm`)
  - SGI files (`.sgi`)
  - SPIDER files (`.spi`)
  - TGA files (`.tga`)
  - TIFF files (`.tif`, `.tiff`)
  - WebP (`.webp`)
  - Windows bitmap files (`.bmp`, `.dib`)
  - Windows ICO files (`.ico`)
  - X bitmap files (`.xbm`)



  In some cases, you may wish the package directly, instead of through [PyPI](https://pypi.python.org/pypi):

  ~~~
  cd ~
  git clone https://github.com/leblancfg/autocrop
  cd autocrop
  pip install .
  ~~~


  Development of a `conda-forge` package for the [Anaconda Python distribution](https://www.anaconda.com/download/) is currently stalled due to the complexity of setting up the workflow with OpenCV. Please leave feedback on [issue #7](https://github.com/leblancfg/autocrop/issues/7) to see past attempts if you are insterested in helping out!


  Best practice for your projects is of course to [use virtual environments](http://docs.python-guide.org/en/latest/dev/virtualenvs/). At the very least, you will need to [have pip installed](https://pip.pypa.io/en/stable/installing/).

  Autocrop is [currently being tested on](https://github.com/leblancfg/autocrop/actions/workflows/ci.yml):

  * Python 3.7 to 3.10
  * OS:
      - Linux
      - macOS
      - Windows


  Check out:

  * http://docs.opencv.org/master/d7/d8b/tutorial_py_face_detection.html#gsc.tab=0
  * http://docs.opencv.org/master/d5/daf/tutorial_py_histogram_equalization.html#gsc.tab=0

  Adapted from:

  * http://photo.stackexchange.com/questions/60411/how-can-i-batch-crop-based-on-face-location



  Although autocrop is essentially a CLI wrapper around a single OpenCV function, it is actively developed. It has active users throughout the world.

  If you would like to contribute, please consult the [contribution docs](CONTRIBUTING.md).


pkgId: 64caf0719e651d953e72c07833f94ec936cdfc29b28b59337f712d90141028cd
name: python-autocrosswalk
arch: src
version: 0.0.24
epoch: 0
release: 1
summary: Automatic Crosswalk
url: https://github.com/muhlbach/autocrosswalk
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocrosswalk-0.0.24-1.src.rpm
checksum_type: sha256
description:
  This library automates crosswalks from one dataframe to another.

  Please contact the authors below if you find any bugs or have any suggestions for improvement. Thank you!

  Author: Nicolaj Søndergaard Mühlbach (n.muhlbach at gmail dot com, muhlbach at mit dot edu)


  This code has the following dependencies:
  - Python >=3.6
  - pandas >=1.3


  There are no heavy dependencies for this library to work. We have included an example that requires a parquet reader, e.g., `pyarrow`, `brotli`, or `fastparquet`. One needs to have one of them installed in order to use the example data provided.
  Otherwise, go ahead and install by `pip install autocrosswalk`.


  ```python

  from autocrosswalk.main import AutoCrosswalk
  from autocrosswalk.tools import load_example_data


  data = load_example_data()


  data_from = data.loc[data["DB"]=="db_20_0"]
  data_to = data.loc[data["DB"]=="db_26_1"]


  autocrosswalk = AutoCrosswalk(n_best_match=3,
                                prioritize_exact_match=True,
                                enforce_completeness=True,
                                verbose=2)


  df_crosswalk = autocrosswalk.generate_crosswalk(df_from=data_from,
                                                  df_to=data_to,
                                                  numeric_key=['O*NET-SOC Code'],
                                                  text_key=['Job title'])


  df_updated = autocrosswalk.perform_crosswalk(crosswalk=df_crosswalk,
                                               df=data_from,
                                               values=["Data Value"],
                                               by=['Date', 'DB',
                                                   'Category', 'Element ID',
                                                   'Element Name','Element description'])


  print(len(df_updated["O*NET-SOC Code"].unique()) == len(data_to["O*NET-SOC Code"].unique()))
  print(len(df_updated["Job title"].unique()) == len(data_to["Job title"].unique()))


  ```
  <!-- ## Example
  We provide an example script in `demo.py`. -->


pkgId: cb07d4ad2be0080572675e747ccd7ec9c820ebfdd8ea841ffaa816f35f4f0fe0
name: python-autocti
arch: src
version: 2024.11.13.2
epoch: 0
release: 1
summary: PyAutoCTI: Charge Transfer Inefficiency Modeling
url: https://github.com/jammy2211/PyAutoCTI
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocti-2024.11.13.2-1.src.rpm
checksum_type: sha256
description:
  |RTD| |Tests| |Build| |code-style| |arXiv|
  `Installation Guide <https://pyautocti.readthedocs.io/en/latest/installation/overview.html>`_ |
  `readthedocs <https://pyautocti.readthedocs.io/en/latest/index.html>`_ |
  `What is CTI? <https://pyautocti.readthedocs.io/en/latest/overview/overview_1_what_is_cti.html>`_
  Charge Transfer Inefficiency, or CTI for short, is an effect that occurs when acquiring imaging data from
  Charge Coupled Devices (CCDs). Due to radiation damage to the CCD's silicon lattice electrons are read-out inefficiently,
  creating a characteristic trailing or smearing effect.
  Here is an example of CTI in the Hubble space telescope, after decades of radiation damage:
  **PyAutoCTI** makes it simple to calibrate a time-varying CTI model using in-orbit observations and correct CTI in
  science imaging using this model.
  **PyAutoCTI** development is centred around mitigating CTI for the Euclid space mission, which relies on the precise
  measurement of galaxy shapes in order to map out the distribution of dark matter throughout the Universe via a
  phenomena called weak gravitational lensing.


pkgId: 59e15fbfbaae6142b3090e29b626773fa55aff102e97247c922de8e645458140
name: python-autocuda
arch: src
version: 0.16
epoch: 0
release: 1
url: https://github.com/yangheng95/autocuda
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autocuda-0.16-1.src.rpm
checksum_type: sha256
summary:
  This package provides the function to auto-choose the cuda device hase largest free memory in Pytorch


pkgId: 8c77b4df7c4dfb53439ad922bf6174e3ffbca7856a9234db441327d092d28035
name: python-autodatapre
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: The package of Auto-DP ( Automated System for Data Preparation).
url: https://gitee.com/zyyyyyyyyyyyyyyyyyyyyy/auto-dp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodatapre-0.1.12-1.src.rpm
checksum_type: sha256
description:
  Automated System for Efficient Generation of Data Preparation Pipeline




  1.  Before running the code, please make sure your Python version is 3.7.16.
  2.  pip install autodatapre



  1. AutoDP.testFunction() provide two fast examples, Showcased examples from our paper.

  2. We support classification and regression tasks, with specified runtime and default runtime until convergence.

  3. Taking classification as an example：

     import autodatapre as AutoDP

     datasetName = your_dataset_path # e.g. "E:/1.csv"

     datasetTarget = the_target_column_name # e.g. 'delay'

     runTime = 10

     df = pd.read_csv(datasetName, sep=',', encoding='ISO-8859-1')

     detailResult, preparedDataset = AutoDP.Classifier(df, datasetName, datasetTarget, runTime)

     AutoDP.EnhancedFunction(df, preparedDataset, detailResult, taskType="CLA")

  4. If runTime is not specified in the Classifier function, run until convergence.

  5. Regressor has the same settings.


pkgId: 792aff28c6c7fd9e1acbf2c8b1b11054641ba927127e8e80185f32863293f189
name: python-autodecrypt
arch: src
version: 2.3.2
epoch: 0
release: 1
summary: Tool to decrypt iOS firmware images
url: https://github.com/matteyeux/autodecrypt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodecrypt-2.3.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/autodecrypt.svg)](https://badge.fury.io/py/autodecrypt)

  Simple tool to decrypt iOS firmware images.

  Going to the iPhone wiki and copying and pasting firmware keys to your terminal is boring.

  autodecrypt will grab keys for you and decrypt the firmware image you want.


  ```
  Usage: autodecrypt [OPTIONS]

  Options:
    -f, --filename TEXT             File  [required]
    -d, --device TEXT               Device  [required]
    -i, --ios_version TEXT          iOS version
    -b, --build TEXT                Build ID of iOS version
    -k, --ivkey TEXT                IV and key to decrypt file
    -l, --local                     Use path to local file
    -D, --download                  Download file
    -B, --beta                      Specify that it is a beta firmware
    -P, --pongo                     Use PongoOS over USB for decryption
    --install-completion [bash|zsh|fish|powershell|pwsh]
                                    Install completion for the specified shell.
    --show-completion [bash|zsh|fish|powershell|pwsh]
                                    Show completion for the specified shell, to
                                    copy it or customize the installation.
    --help                          Show this message and exit.
  ```


  - [img4](https://github.com/xerub/img4lib)

  To run autodecrypt, use poetry with a virtualenv:
  - `virtualenv -p python3 env`
  - `pip3 install poetry`
  - `poetry install`



  `pip3 install autodecrypt`





  ```
  » autodecrypt -f iBSS.iphone6.RELEASE.im4p -i 10.3.3 -d iPhone6,2
  [i] downloading iBSS.iphone6.RELEASE.im4p
  [i] image : ibss
  [i] grabbing keys for iPhone6,2/14G60
  [x] iv  : f2aa35f6e27c409fd57e9b711f416cfe
  [x] key : 599d9b18bc51d93f2385fa4e83539a2eec955fce5f4ae960b252583fcbebfe75
  [i] decrypting iBSS.iphone6.RELEASE.im4p to iBSS.iphone6.RELEASE.bin...
  [x] done
  ```


  ```
  » autodecrypt -f sep-firmware.n841.RELEASE.im4p -b 17C5053a -d iPhone11,8 -k 9f974f1788e615700fec73006cc2e6b533b0c6c2b8cf653bdbd347bc1897bdd66b11815f036e94c951250c4dda916c00
  [i] downloading sep-firmware.n841.RELEASE.im4p
  [x] iv  : 9f974f1788e615700fec73006cc2e6b5
  [x] key : 33b0c6c2b8cf653bdbd347bc1897bdd66b11815f036e94c951250c4dda916c00
  [i] decrypting sep-firmware.n841.RELEASE.im4p to sep-firmware.n841.RELEASE.bin...
  [x] done
  ```


  ```
  » export FOREMAN_HOST="https://foreman-public.sudosecuritygroup.com"
  » autodecrypt -f LLB.n112.RELEASE.im4p -i 13.2.3 -d iPod9,1
  [i] downloading LLB.n112.RELEASE.im4p
  [i] image : llb
  [i] grabbing keys for iPod9,1/17B111
  [i] grabbing keys from https://foreman-public.sudosecuritygroup.com
  [x] iv  : 85784a219eb29bcb1cc862de00a590e7
  [x] key : f539c51a7f3403d90c9bdc62490f6b5dab4318f4633269ce3fbbe855b33a4bc7
  [i] decrypting LLB.n112.RELEASE.im4p to LLB.n112.RELEASE.bin...
  [x] done
  ```


  > I you wanna use this on Linux, you may have some USB permissions. I recommend copying the file `66-pongos.rules` available on this repository to `/etc/udev/rules.d/`.

  ```
  » autodecrypt -f iBoot.n71.RELEASE.im4p -d iPhone8,1 -i 14.1 -p
  [i] downloading iBoot.n71.RELEASE.im4p
  [i] grabbing keys from PongoOS device
  [i] kbag : 03C9E01CA99FE6475566C791777169C0625B04B7BD4E593DE0F61ABF4E8DB1A987D9D6155C5A1F41D9113694658AC61C
  [x] iv  : 245a9b52e53a704fe73d7b58734b00ae
  [x] key : d3aa3c8cc20fa9d61e466f46aee374a92a125abb5b3f57264025c8c72127e321
  [i] decrypting iBoot.n71.RELEASE.im4p to iBoot.n71.RELEASE.bin...
  [x] done
  ```



  For debugging purposes you can check `autodecrypt.log` :
  ```
  11/02/2019 21:39:41 Launching "['autodecrypt/autodecrypt.py', '-d', 'iPhone9,3', '-f', 'iBoot.d10.RELEASE.im4p', '-i', '12.3.1']"
  11/02/2019 21:39:41 requesting IPSW's API for iPhone9,3
  11/02/2019 21:39:41 done, now looking for version or build
  11/02/2019 21:39:41 grabbing firmware codename for 16F203
  11/02/2019 21:39:42 codename : PeaceF
  11/02/2019 21:39:42 grabbing IPSW file URL for iPhone9,3/12.3.1
  11/02/2019 21:39:42 downloading iBoot...
  11/02/2019 21:39:43 img4 -i iBoot.d10.RELEASE.im4p iBoot.d10.RELEASE.bin 978fd4680cd4b624b0dfea22a417f51f0ee2b871defed42277fe18885053b1eb5c7ffe82f38ab8cf7772c69a0db5d386
  ```



  - checkra1n team for AES patches, kbag.m and [PongoOS](https://github.com/checkra1n/pongoos)
  - tihmstar for wiki parsing ([my method](https://github.com/matteyeux/ios-tools/blob/master/scrapkeys.py) was pretty bad)
  - m1stadev for [PyIMG4](https://github.com/m1stadev/PyIMG4)


pkgId: 839f0b83eeda01c30e90794ac6febf38f1599c96189a8a91697fa3e4f46c354f
name: python-autodiff-AsiaUnionCS107
arch: src
version: 0.0.15
epoch: 0
release: 1
summary: An Automatic Differentiation Package
url: https://github.com/AsiaUnionCS107/cs107-FinalProject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodiff-AsiaUnionCS107-0.0.15-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/AsiaUnionCS107/cs107-FinalProject/branch/master/graph/badge.svg?token=1WWKZG2QDY)](https://codecov.io/gh/AsiaUnionCS107/cs107-FinalProject)

  [![Build Status](https://api.travis-ci.com/AsiaUnionCS107/cs107-FinalProject.svg?token=mrHgEBMWayvk9YMprwym&branch=master)](https://travis-ci.com/AsiaUnionCS107/cs107-FinalProject)







  * Sehaj Chawla
  * Xin Zeng
  * Yang Xiang
  * Sivananda Rajananda



  Differentiation, the process of finding a derivative, is one of the most fundamental operations in mathematics. Computational techniques of calculating differentiations have broad applications in science and engineering, including numerical solution of ordinary differential equations, optimization and solution of linear systems. Besides, they also have many real-life applications, like edge detection in image processing and safety tests of cars. Symbolic Differentiation and Finite Difference are two ways to numerically compute derivatives. Symbolic Differentiation is precise, but it can lead to inefficient code and can be costly to evaluate. Finite Difference is quick and easy to implement, but it can introduce round-off errors. Automatic Differentiation (AD) handles both of these two problems. It achieves machine precision without costly evaluation, and therefore is widely used.



  Our package, **autodiff**, provides an easy way to calculate derivatives of functions for both scalar and vector inputs. It implements both of forward and reverse mode of automatic differentiation, and also extends to root-finding with Newton's method.



  We invite you to use **autodiff** package and help us improve it!



  The link for full documentation is [here](https://github.com/AsiaUnionCS107/cs107-FinalProject/blob/Milestone_3/docs/documentation.md).



  Our package **autodiff** supports installation via ```pip```. Users can install the package with the following command.

  ```
  pip install autodiff_AsiaUnionCS107
  ```

  Below are some simple demos of **autodiff** package.

  * Forward mode AD

  *Example 1*

  ```python
  >>> from autodiff.ad import AutoDiff
  >>> val = 0 # Value to evaluate at
  >>> x = AutoDiff(val, name="x") # Create an AD forward mode object with val
  >>> f = AutoDiff.sin(2 * x) # function to be evaluate, i.e. f(x) = sin(2x)
  >>> print(f.val) # Output the function value
  >>> print(f.der) # Output the function derivative
  [0.]
  {'x': array([2.])}
  ```

  *Example 2*

  ```python

  >>> x = AutoDiff([-1.0, -3.0, -5.0, -7.0, 0.1], name="x")

  >>> f = AutoDiff.logistic(AutoDiff.tan(x) + (3 * x ** (-2)) + (2 * x) + 7)
  >>> print(f.val) # Output the function value
  >>> print(f.der) # Output the function derivative
  [9.98410258e-01 8.13949454e-01 6.22580352e-01 4.05402978e-04 1.00000000e+00]
  {'x': array([1.81347563e-002,  4.91036710e-001,  3.40145666e+000,
               1.53055156e-003, -2.08494059e-130])}
  ```

  * Reverse mode AD

  *Example 1*

  ```python
  >>> from autodiff.reverse import Reverse

  >>> x = Reverse(5)

  >>> y = Reverse.sqrt(Reverse.sinh(x)) + 2**x + 7*Reverse.exp(x) + Reverse.sin(Reverse.cos(x))

  >>> x.reset_gradient()

  >>> y.gradient_value = 1

  >>> dy_dx = x.get_gradient()

  >>> print(dy_dx)
  [1066.30088158]
  ```

  *Example 2*

  ```python

  >>> x = Reverse([1, 2, 3])

  >>> y = 2*x + x**2

  >>> x.reset_gradient()

  >>> y.gradient_value = 1

  >>> dy_dx = x.get_gradient()

  >>> print(dy_dx)
  [4. 6. 8.]
  ```

  * Root finding with Newton's method

  *Example 1*

  ```python
  >>> from autodiff.rootfinding import newton_method
  >>> def func_one_variable(x: list):
  ...     # function with one variable
  ...     f = (x[0]-2)**2
  ...     return [f]

  >>> root, trace = newton_method(func=func_one_variable, num_of_variables=1, initial_val=[0],
  ...                             max_iter=10000, tol=1e-3)
  >>> print(f'Root of function: {root}')
  >>> print(f'Trace of function: {trace}')
  Root of function: [1.96875]
  Trace of function: [array([0]), array([1.]), array([1.5]), array([1.75]), array([1.875]), array([1.9375]), array([1.96875])]
  ```

  *Example 2*

  ```python
  >>> def func_multi_variables(x: list):
  ...     # function with multi variables
  ...     f1 = x[0] + 2
  ...     f2 = x[0] + x[1]**2 - 2
  ...     return [f1, f2]

  >>> root, trace = newton_method(func=func_multi_variables, num_of_variables=2,
  ...                             initial_val=[0, 1], max_iter=10000, tol=1e-3)
  >>> print(f'Root of function: {root}')
  >>> print(f'Trace of function: {trace}')
  Root of function: [-2.          2.00000009]
  Trace of function: [array([0, 1]), array([-2. ,  2.5]), array([-2.  ,  2.05]), array([-2.        ,  2.00060976]), array([-2.        ,  2.00000009])]
  ```



  We hope you enjoy using our package, and feel free to offer us your advice!


pkgId: 2a755c985e58d7cb2c198b2a0d734cd7242354bf1a4a7f94a7cf966c6decc8e3
name: python-autodiffy
arch: src
version: 0.0.2.12
epoch: 0
release: 1
summary: Automatic Differentiation package
url: https://github.com/CS207-Feiyu-Group8/cs207-FinalProject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodiffy-0.0.2.12-1.src.rpm
checksum_type: sha256
description:
  autodiffy: Automatic Differentiation Package

  + Andrew Chia
  + Will Fried
  + Ankith Harathi
  + Wei-Hung Hsu

  For documentation and development, visit [our github](https://github.com/CS207-Feiyu-Group8/cs207-FinalProject)


pkgId: 9c935dcc17f93b825b3deb536683d23ebf7333c7868d041a457e9716c6f5caf7
name: python-autodistill
arch: src
version: 0.1.28
epoch: 0
release: 1
summary: Distill large foundational models into smaller, domain-specific models for deployment
url: https://github.com/autodistill/autodistill
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodistill-0.1.28-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <p>
      <a align="center" href="" target="_blank">
        <img
          width="850"
          src="https://media.roboflow.com/open-source/autodistill/autodistill-banner.jpg?2"
        >
      </a>
    </p>

  [notebooks](https://github.com/roboflow/notebooks) | [inference](https://github.com/roboflow/inference) | [autodistill](https://github.com/autodistill/autodistill) | [collect](https://github.com/roboflow/roboflow-collect)

  [![version](https://badge.fury.io/py/autodistill.svg?)](https://badge.fury.io/py/autodistill)
  [![downloads](https://img.shields.io/pypi/dm/autodistill)](https://pypistats.org/packages/autodistill)
  [![license](https://img.shields.io/pypi/l/autodistill?)](https://github.com/autodistill/autodistill/blob/main/LICENSE)
  [![python-version](https://img.shields.io/pypi/pyversions/autodistill)](https://badge.fury.io/py/autodistill)
  [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-auto-train-yolov8-model-with-autodistill.ipynb)
  </div>

  Autodistill uses big, slower foundation models to train small, faster supervised models. Using `autodistill`, you can go from unlabeled images to inference on a custom model running at the edge with no human intervention in between.

  > [!TIP]
  > You can use Autodistill on your own hardware, or use the [Roboflow hosted version of Autodistill](https://blog.roboflow.com/launch-auto-label/) to label images in the cloud.

  <div align="center">
    <p>
      <a align="center" href="" target="_blank">
        <img
          width="850"
          src="https://media.roboflow.com/open-source/autodistill/steps.jpg"
        >
      </a>
    </p>
  </div>

  Currently, `autodistill` supports vision tasks like object detection and instance segmentation, but in the future it can be expanded to support language (and other) models.



  | [Tutorial](https://blog.roboflow.com/autodistill)| [Docs](https://docs.autodistill.com)| [Supported Models](#-available-models)  | [Contribute](CONTRIBUTING.md)
  |:---:|:---:|:---:|:---:|



  Here are example predictions of a Target Model detecting milk bottles and bottlecaps after being trained on an auto-labeled dataset using Autodistill (see [the Autodistill YouTube video](https://www.youtube.com/watch?v=gKTYMfwPo4M) for a full walkthrough):

  <div align="center">
    <p>
      <a align="center" href="https://www.youtube.com/watch?v=gKTYMfwPo4M" target="_blank">
        <img
          width="850"
          src="https://media.roboflow.com/open-source/autodistill/milk-480.gif"
        >
      </a>
    </p>
  </div>



  * 🔌 Pluggable interface to connect models together
  * 🤖 Automatically label datasets
  * 🐰 Train fast supervised models
  * 🔒 Own your model
  * 🚀 Deploy distilled models to the cloud or the edge



  To use `autodistill`, you input unlabeled data into a Base Model which uses an Ontology to label a Dataset that is used to train a Target Model which outputs a Distilled Model fine-tuned to perform a specific Task.

  <div align="center">
    <p>
      <a align="center" href="" target="_blank">
        <img
          width="850"
          src="https://media.roboflow.com/open-source/autodistill/overview.jpg"
        >
      </a>
    </p>
  </div>

  Autodistill defines several basic primitives:

  * **Task** - A Task defines what a Target Model will predict. The Task for each component (Base Model, Ontology, and Target Model) of an `autodistill` pipeline must match for them to be compatible with each other. Object Detection and Instance Segmentation are currently supported through the `detection` task. `classification` support will be added soon.
  * **Base Model** - A Base Model is a large foundation model that knows a lot about a lot. Base models are often multimodal and can perform many tasks. They're large, slow, and expensive. Examples of Base Models are GroundedSAM and GPT-4's upcoming multimodal variant. We use a Base Model (along with unlabeled input data and an Ontology) to create a Dataset.
  * **Ontology** - an Ontology defines how your Base Model is prompted, what your Dataset will describe, and what your Target Model will predict. A simple Ontology is the `CaptionOntology` which prompts a Base Model with text captions and maps them to class names. Other Ontologies may, for instance, use a CLIP vector or example images instead of a text caption.
  * **Dataset** - a Dataset is a set of auto-labeled data that can be used to train a Target Model. It is the output generated by a Base Model.
  * **Target Model** - a Target Model is a supervised model that consumes a Dataset and outputs a distilled model that is ready for deployment. Target Models are usually small, fast, and fine-tuned to perform a specific task very well (but they don't generalize well beyond the information described in their Dataset). Examples of Target Models are YOLOv8 and DETR.
  * **Distilled Model** - a Distilled Model is the final output of the `autodistill` process; it's a set of weights fine-tuned for your task that can be deployed to get predictions.



  Human labeling is one of the biggest barriers to broad adoption of computer vision. It can take thousands of hours to craft a dataset suitable for training a production model. The process of distillation for training supervised models is not new, in fact, traditional human labeling is just another form of distillation from an extremely capable Base Model (the human brain 🧠).


  Foundation models know a lot about a lot, but for production we need models that know a lot about a little.

  As foundation models get better and better they will increasingly be able to augment or replace humans in the labeling process. We need tools for steering, utilizing, and comparing these models. Additionally, these foundation models are big, expensive, and often gated behind private APIs. For many production use-cases, we need models that can run cheaply and in realtime at the edge.

  <div align="center">
    <p>
      <a align="center" href="" target="_blank">
        <img
          width="850"
          src="https://media.roboflow.com/open-source/autodistill/connections.jpg"
        >
      </a>
    </p>
  </div>

  Autodistill's Base Models can already create datasets for many common use-cases (and through creative prompting and few-shotting we can expand their utility to many more), but they're not perfect yet. There's still a lot of work to do; this is just the beginning and we'd love your help testing and expanding the capabilities of the system!



  Autodistill is modular. You'll need to install the `autodistill` package (which defines the interfaces for the above concepts) along with [Base Model and Target Model plugins](#-available-models) (which implement specific models).

  By packaging these separately as plugins, dependency and licensing incompatibilities are minimized and new models can be implemented and maintained by anyone.

  Example:
  ```bash
  pip install autodistill autodistill-grounded-sam autodistill-yolov8
  ```

  <details close>
  <summary>Install from source</summary>

  You can also clone the project from GitHub for local development:

  ```bash
  git clone https://github.com/roboflow/autodistill
  cd autodistill
  pip install -e .
  ```
  </details>

  Additional Base and Target models are [enumerated below](#-available-models).



  See the [demo Notebook](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-auto-train-yolov8-model-with-autodistill.ipynb) for a quick introduction to `autodistill`. This notebook walks through building a milk container detection model with no labeling.

  Below, we have condensed key parts of the notebook for a quick introduction to `autodistill`.

  You can also run Autodistill in one command. First, install `autodistill`:

  ```bash
  pip install autodistill
  ```

  Then, run:

  ```bash
  autodistill images --base="grounding_dino" --target="yolov8" --ontology '{"prompt": "label"}' --output="./dataset"
  ```

  This command will label all images in a directory called `images` with Grounding DINO and use the labeled images to train a YOLOv8 model. Grounding DINO will label all images with the "prompt" and save the label as the "label". You can specify as many prompts and labels as you want. The resulting dataset will be saved in a folder called `dataset`.



  For this example, we'll show how to distill [GroundedSAM](https://github.com/IDEA-Research/Grounded-Segment-Anything) into a small [YOLOv8](https://github.com/ultralytics/ultralytics) model using [autodistill-grounded-sam](https://github.com/autodistill/autodistill-grounded-sam) and [autodistill-yolov8](https://github.com/autodistill/autodistill-yolov8).

  ```
  pip install autodistill autodistill-grounded-sam autodistill-yolov8
  ```



  ```python
  from autodistill_grounded_sam import GroundedSAM
  from autodistill.detection import CaptionOntology
  from autodistill_yolov8 import YOLOv8





  base_model = GroundedSAM(ontology=CaptionOntology({"shipping container": "container"}))


  base_model.label(
    input_folder="./images",
    output_folder="./dataset"
  )

  target_model = YOLOv8("yolov8n.pt")
  target_model.train("./dataset/data.yaml", epochs=200)


  pred = target_model.predict("./dataset/valid/your-image.jpg", confidence=0.5)
  print(pred)


  from roboflow import Roboflow

  rf = Roboflow(api_key="API_KEY")
  project = rf.workspace().project("PROJECT_ID")
  project.version(DATASET_VERSION).deploy(model_type="yolov8", model_path=f"./runs/detect/train/")
  ```

  <details close>
  <summary>Visualize Predictions</summary>

  To plot the annotations for a single image using `autodistill`, you can use the code below. This code is helpful to visualize the annotations generated by your base model (i.e. GroundedSAM) and the results from your target model (i.e. YOLOv8).

  ```python
  import supervision as sv
  import cv2

  img_path = "./images/your-image.jpeg"

  image = cv2.imread(img_path)

  detections = base_model.predict(img_path)

  box_annotator = sv.BoxAnnotator()

  labels = [
      f"{base_model.ontology.classes()[class_id]} {confidence:0.2f}"
      for _, _, confidence, class_id, _, _ in detections
  ]

  annotated_frame = box_annotator.annotate(
      scene=image.copy(), detections=detections, labels=labels
  )

  sv.plot_image(annotated_frame, (16, 16))
  ```
  </details>



  Our goal is for `autodistill` to support using all foundation models as Base Models and most SOTA supervised models as Target Models. We focused on object detection and segmentation
  tasks first but plan to launch classification support soon! In the future, we hope `autodistill` will also be used for models beyond computer vision.

  * ✅ - complete (click row/column header to go to repo)
  * 🚧 - work in progress



  | base / target | [YOLOv8](https://github.com/autodistill/autodistill-yolov8) | [YOLO-NAS](https://github.com/autodistill/autodistill-yolonas) | [YOLOv5](https://github.com/autodistill/autodistill-yolov5) | [DETR](https://github.com/autodistill/autodistill-detr) | YOLOv6 | YOLOv7 | MT-YOLOv6 |
  |:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
  | [DETIC](https://github.com/autodistill/autodistill-detic) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [GroundedSAM](https://github.com/autodistill/autodistill-grounded-sam) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [GroundingDINO](https://github.com/autodistill/autodistill-grounding-dino) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [OWL-ViT](https://github.com/autodistill/autodistill-owl-vit) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [SAM-CLIP](https://github.com/autodistill/autodistill-sam-clip) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [LLaVA-1.5](https://github.com/autodistill/autodistill-llava) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [Kosmos-2](https://github.com/autodistill/autodistill-kosmos-2) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [OWLv2](https://github.com/autodistill/autodistill-owlv2) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [Roboflow Universe Models (50k+ pre-trained models)](https://github.com/autodistill/autodistill-roboflow-universe) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [CoDet](https://github.com/autodistill/autodistill-codet) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [Azure Custom Vision](https://github.com/autodistill/autodistill-azure-vision) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [AWS Rekognition](https://github.com/autodistill/autodistill-rekognition) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |
  | [Google Vision](https://github.com/autodistill/autodistill-gcp-vision) | ✅ | ✅ | ✅ | ✅ | 🚧 |  |  |




  | base / target | [YOLOv8](https://github.com/autodistill/autodistill-yolov8) | [YOLO-NAS](https://github.com/autodistill/autodistill-yolonas) | [YOLOv5](https://github.com/autodistill/autodistill-yolov5) | YOLOv7 | Segformer |
  |:---:|:---:|:---:|:---:|:---:|:---:|
  | [GroundedSAM](https://github.com/autodistill/autodistill-grounded-sam) | ✅ | 🚧 | 🚧 |  |  |
  | SAM-CLIP | ✅ | 🚧 | 🚧 |  |  |
  | SegGPT | ✅ | 🚧 | 🚧 |  |  |
  | FastSAM | 🚧 | 🚧 | 🚧 |  |  |




  | base / target | [ViT](https://github.com/autodistill/autodistill-vit) | [YOLOv8](https://github.com/autodistill/autodistill-yolov8) | [YOLOv5](https://github.com/autodistill/autodistill-yolov5) |
  |:---:|:---:|:---:|:---:|
  | [CLIP](https://github.com/autodistill/autodistill-clip) | ✅ | ✅ | 🚧 |
  | [MetaCLIP](https://github.com/autodistill/autodistill-metaclip) | ✅ | ✅ | 🚧 |
  | [DINOv2](https://github.com/autodistill/autodistill-dinov2) | ✅ | ✅ | 🚧 |
  | [BLIP](https://github.com/autodistill/autodistill-blip) | ✅ | ✅ | 🚧 |
  | [ALBEF](https://github.com/autodistill/autodistill-albef) | ✅ | ✅ | 🚧 |
  | [FastViT](https://github.com/autodistill/autodistill-fastvit) | ✅ | ✅ | 🚧 |
  | [AltCLIP](https://github.com/autodistill/autodistill-altcip) | ✅ | ✅ | 🚧 |
  | [EvaCLIP](https://github.com/lab176344/autodistill-evaclip) (contributed by a community member) | ✅ | ✅ | 🚧 |
  | Fuyu | 🚧 | 🚧 | 🚧 |
  | Open Flamingo | 🚧 | 🚧 | 🚧 |
  | GPT-4 |  |  |  |
  | PaLM-2 |  |  |  |




  You can optionally deploy some Target Models trained using Autodistill on Roboflow. Deploying on Roboflow allows you to use a range of concise SDKs for using your model on the edge, from [roboflow.js](https://docs.roboflow.com/inference/web-browser) for web deployment to [NVIDIA Jetson](https://docs.roboflow.com/inference/nvidia-jetson) devices.

  The following Autodistill Target Models are supported by Roboflow for deployment:

  | model name | Supported? |
  |:---:|:---:|
  | YOLOv8 Object Detection | ✅ |
  | YOLOv8 Instance Segmentation | ✅ |
  | YOLOv5 Object Detection | ✅ |
  | YOLOv5 Instance Segmentation | ✅ |
  | YOLOv8 Classification |  |



  <p align="left">
  <a href="https://www.youtube.com/watch?v=gKTYMfwPo4M" title="Autodistill: Train YOLOv8 with ZERO Annotations"><img src="https://i.ytimg.com/vi/gKTYMfwPo4M/maxresdefault.jpg" alt="Autodistill: Train YOLOv8 with ZERO Annotations" width="300px" align="left" /></a>
  <a href="https://youtu.be/oEQYStnF2l8"><strong>Autodistill: Train YOLOv8 with ZERO Annotations</strong></a>
  <div><strong>Published: 8 June 2023</strong></div>
  <br/>In this video, we will show you how to use a new library to train a YOLOv8 model to detect bottles moving on a conveyor line. Yes, that's right - zero annotation hours are required! We dive deep into Autodistill's functionality, covering topics from setting up your Python environment and preparing your images, to the thrilling automatic annotation of images. </p>



  - [Distill Large Vision Models into Smaller, Efficient Models with Autodistill](https://blog.roboflow.com/autodistill/): Announcement post with written guide on how to use Autodistill
  - [Comparing AI-Labeled Data to Human-Labeled Data](https://blog.roboflow.com/ai-vs-human-labeled-data/): A qualitative evaluation of Grounding DINO used with Autodistill across various tasks and domains.
  - [How to Evaluate Autodistill Prompts with CVevals](https://blog.roboflow.com/autodistill-prompt-evaluation/): Evaluate Autodistill prompts.
  - [Autodistill: Label and Train a Computer Vision Model in Under 20 Minutes](https://www.youtube.com/watch?v=M_QZ_Q0zT0k): Building a model to detect planes in under 20 minutes.
  - [Comparing AI-Labeled Data to Human-Labeled Data](https://blog.roboflow.com/ai-vs-human-labeled-data/): Explore the strengths and limitations of a base model used with Autoditsill.
  - [Train an Image Classification Model with No Labeling](https://blog.roboflow.com/train-classification-model-no-labeling/): Use Grounded SAM to automatically label images for training an Ultralytics YOLOv8 classification model.
  - [Train a Segmentation Model with No Labeling](https://blog.roboflow.com/train-a-segmentation-model-no-labeling/): Use CLIP to automatically label images for training an Ultralytics YOLOv8 segmentation model.
  - File a PR to add your own resources here!



  Apart from adding new models, there are several areas we plan to explore with `autodistill` including:

  * 💡 Ontology creation & prompt engineering
  * 👩‍💻 Human in the loop support
  * 🤔 Model evaluation
  * 🔄 Active learning
  * 💬 Language tasks



  We love your input! Please see our [contributing guide](CONTRIBUTING.md) to get started. Thank you 🙏 to all our contributors!



  The `autodistill` package is licensed under an [Apache 2.0](LICENSE). Each Base or Target model plugin may use its own license corresponding with the license of its underlying model. Please refer to the license in each plugin repo for more information.





  This error is caused when PyTorch cannot load the model weights for a model. Go into the `~/.cache/autodistill` directory and delete the folder associated with the model you are trying to load. Then, run your code again. The model weights will be downloaded from scratch. Leave the installation process uninterrupted.



  |Project | Description|
  |:---|:---|
  |[supervision](https://roboflow.com/supervision) | General-purpose utilities for use in computer vision projects, from predictions filtering and display to object tracking to model evaluation.
  |[Autodistill](https://github.com/autodistill/autodistill) (this project) | Automatically label images for use in training computer vision models. |
  |[Inference](https://github.com/roboflow/inference) | An easy-to-use, production-ready inference server for computer vision supporting deployment of many popular model architectures and fine-tuned models.
  |[Notebooks](https://roboflow.com/notebooks) | Tutorials for computer vision tasks, from training state-of-the-art models to tracking objects to counting objects in a zone.
  |[Collect](https://github.com/roboflow/roboflow-collect) | Automated, intelligent data collection powered by CLIP.

  <br>

  <div align="center">

    <div align="center">
        <a href="https://youtube.com/roboflow">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/youtube.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949634652"
              width="3%"
            />
        </a>
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://roboflow.com">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/roboflow-app.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949746649"
              width="3%"
            />
        </a>
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://www.linkedin.com/company/roboflow-ai/">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/linkedin.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949633691"
              width="3%"
            />
        </a>
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://docs.roboflow.com">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/knowledge.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949634511"
              width="3%"
            />
        </a>
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://disuss.roboflow.com">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/forum.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949633584"
              width="3%"
            />
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://blog.roboflow.com">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/blog.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949633605"
              width="3%"
            />
        </a>
        </a>
    </div>

  </div>


pkgId: db9c49f942f0e8177ec2c8f1646f260fa90f92625f82f6aecab95cdb62aad6c7
name: python-autodistill-grounded-sam-2
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/autodistill/autodistill-grounded-sam-2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodistill-grounded-sam-2-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  Use Segment Anything 2, grounded with Florence-2, to auto-label data for use in training vision models.

description:
   Use Segment Anything 2, grounded with Florence-2, to auto-label data for use in training vision models.


pkgId: 279295d9a2ccaa9787843505a60505aa100c9077b0736f7ed7d3eafb14d692a7
name: python-autodistill-grounding-dino
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: GroundingDINO module for use with Autodistill
url: https://github.com/autodistill/autodistill-grounding-dino
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodistill-grounding-dino-0.1.4-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <p>
      <a align="center" href="" target="_blank">
        <img
          width="850"
          src="https://media.roboflow.com/open-source/autodistill/autodistill-banner.png?3"
        >
      </a>
    </p>
  </div>



  This repository contains the code supporting the Grounding DINO base model for use with [Autodistill](https://github.com/autodistill/autodistill).

  [Grounding DINO](https://github.com/IDEA-Research/GroundingDINO) is a zero-shot object detection model developed by IDEA Research. You can distill knowledge from Grounding DINO into a smaller model using Autodistill.

  Read the [Grounding DINO Autodistill documentation](https://autodistill.github.io/autodistill/base_models/grounding-dino/).

  > [!TIP]
  > You can use Autodistill Grounding DINO on your own hardware, or use the [Roboflow hosted version of Autodistill](https://blog.roboflow.com/launch-auto-label/) to label images in the cloud.



  To use the Grounding DINO base model, you will need to install the following dependency:

  ```bash
  pip3 install autodistill-grounding-dino
  ```



  ```python
  from autodistill_grounding_dino import GroundingDINO
  from autodistill_yolov8 import YOLOv8







  base_model = GroundingDINO(ontology=CaptionOntology({"shipping container": "container"}))


  base_model.label("./context_images", extension=".jpeg")
  ```



  The code in this repository is licensed under an [Apache 2.0 license](LICENSE).



  We love your input! Please see the core Autodistill [contributing guide](https://github.com/autodistill/autodistill/blob/main/CONTRIBUTING.md) to get started. Thank you 🙏 to all our contributors!


pkgId: 8d56455dd1018d5ef3830aa6d21d0132a964899054f3a6c7d0d847537c268690
name: python-autodoc
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Autodoc Python implementation.
url: http://github.com/heavenshell/py-autodoc
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodoc-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Generate documentation from your unit-test.
  This library is Python implementation of Autodoc.
  - `Autodoc <https://github.com/r7kamura/autodoc>`_
  - `Test::JsonAPI::Autodoc <https://metacpan.org/pod/Test::JsonAPI::Autodoc>`_


pkgId: 6cf5242af6e451d4e646d2caad2ab2f29f8fd07f2e3815b142bfdcc94640edcc
name: python-autodoc-traits
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Sphinx extension to autodoc traitlets
url: https://pypi.org/project/autodoc-traits/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodoc-traits-1.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Latest PyPI version](https://img.shields.io/pypi/v/autodoc-traits?logo=pypi)](https://pypi.python.org/pypi/autodoc-traits)
  [![GitHub](https://img.shields.io/badge/issue_tracking-github-blue?logo=github)](https://github.com/jupyterhub/autodoc-traits/issues)
  [![Discourse](https://img.shields.io/badge/help_forum-discourse-blue?logo=discourse)](https://discourse.jupyter.org/c/jupyterhub)
  [![Gitter](https://img.shields.io/badge/social_chat-gitter-blue?logo=gitter)](https://gitter.im/jupyterhub/jupyterhub)

  `autodoc-traits` is a Sphinx extension that builds on [`sphinx.ext.autodoc`][]
  to better document classes with [Traitlets][] based configuration.
  `autodoc-traits` provides the [Sphinx directives][] `autoconfigurable` (use with
  classes) and `autotrait` (use with the traitlets based configuration options).

  The `sphinx.ext.autodoc` provided directive [`automodule`][], which can overview
  classes, will with `autodoc-traits` enabled use `autoconfigurable` over
  [`autoclass`][] for classes has trait based configuration. Similarly, the
  `sphinx.ext.autodoc` provided `autoclass` directive will use `autotrait` over
  [`autoattribute`][] if configured to present the traitlets attributes normally
  not presented.

  The `autoattribute` directive will provide a header looking like `trait
  c.SampleConfigurable.trait = Bool(False)`, and as docstring it will use the
  trait's configured help text.



  1. Install `autodoc-traits`:

     ```shell
     pip install autodoc-traits
     ```

  2. Configure Sphinx to use the `autodoc_traits` extensions in a Sphinx project's
     `conf.py` file:

     ```python
     
     
     
     extensions = [
         "autodoc_traits",
         
         
         
     ]
     ```

  3. Make use of the `sphinx.ext.autodoc` Sphinx directive like `automodule` that
     document classes, the `autodoc_traits` provided `autoconfigurable` that
     documents traitlets configurable classes, or the `autodoc_traits` provided
     `autotrait` that documents individual traitlets configuration options:

     From a .rst document:

     ```rst
     .. automodule:: sample_module
        :members:

     .. autoconfigurable:: sample_module.SampleConfigurable

     .. autotrait:: sample_module.SampleConfigurable.trait
     ```



  While you can use [`myst-parser`][], `sphinx.ext.autodoc`'s directives emits
  unparsed rST, forcing us to parse the autodoc directives in a rST context.

  From a .md document, with `myst-parser`:

  ````markdown
  ```{eval-rst}
  .. autoconfigurable:: sample_module.SampleConfigurable
  ```
  ````

  Due to this, also the Python docstrings are required to be in rST as well.
  Addressing this can be tracked from [executablebooks/team-compass issue


  [`sphinx.ext.autodoc`]: https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html
  [sphinx directives]: https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html#directives
  [`autoclass`]: https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html#directive-autoclass
  [`autoattribute`]: https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html#directive-autoattribute
  [traitlets]: https://github.com/ipython/traitlets
  [`traitlets.traittype`]: https://traitlets.readthedocs.io/en/stable/trait_types.html#traitlets.TraitType
  [`myst-parser`]: https://myst-parser.readthedocs.io/en/latest/

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


pkgId: 979127d48828b79da4f42e23b1c73d180fedeb0ce40c38e4e883c46531361c1a
name: python-autodox
arch: src
version: 0.1.16
epoch: 0
release: 1
summary: Tool for generating documentation automatically from code annotations, types, and docstrings.
url: https://github.com/k98kurz/autodox
rpm_license: ISC License (ISCL)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodox-0.1.16-1.src.rpm
checksum_type: sha256
description:
  Tool for generating documentation automatically from code annotations, types,
  and docstrings.



  - [x] Code
  - [x] Docs
  - [x] Package published
  - [x] Denote async functions as such





  ```bash
  pip install autodox
  ```

  Note that Protocols do not support `__init__` methods before Python 3.11. To use
  `__init__` method signatures for Protocols in Python 3.10, use the
  `typing.Protocol` backport from the 3rd-party `typing_extensions` package.
  Otherwise, the `__init__` method signature will be overridden with an empty one
  named `_no_init_or_replace_init` and will be ignored by this tool.



  Use the following to document a module with default configuration:

  ```bash
  autodox module_name [options] > target_file.md
  ```

  The output can be configured with the following options:
  - `-exclude_name=name` to exclude a specific part of the module by name
  - `-exclude_type=type` to exclude any module parts of the given type
  - `-package=module_name` to scope a relative import
  - `-header_level=number` to increase the hashtag count in headers by `number`
  - `-function_format=format` - can be one of 'header', 'paragraph', or 'list'
  - `-method_format=format` - can be one of 'header', 'paragraph', or 'list'
  - `-value_format=format` - can be one of 'header', 'paragraph', or 'list'
  - `-line_length=number` - number of chars per line in paragraphs
  - `-include_private` to include things prefaced with '_'
  - `-include_dunder` to include things prefaced with '__'
  - `-include_submodules` to include submodules
  - `-document_submodules` to run the module documentation for submodules
  - `-debug` to increase the level of debug statements printed (starts at 0)

  For experimentation and to learn how the options work, try running the following:

  ```bash
  autodox autodox [options]
  ```



  The autodox package can also be used by importing and running the desired
  documentation function(s). The following are included.

  - `dox_a_module(module: ModuleType, options: dict = None) -> str` produces docs for a module
  - `dox_a_value(value: Any, options: dict = None) -> str` produces docs for a value
  - `dox_a_function(function: Callable, options: dict = None) -> str` produces docs for a function
  - `dox_a_class(cls: type, options: dict = None) -> str` produces docs for a class

  The valid options for each will be described below. Additionally, there is a
  system for setting up hooks that interact with the doc generation process to
  change the inputs or outputs, and that will be described below the options for
  the four `dox_a_{thing}` functions.



  Produces docs for a module. Valid options are the following:

  - `exclude_names: list[str]` - names to exclude from docs
  - `exclude_types: list[str]` - types to exclude from docs
  - `header_level: int` - number of additional hashtags to add to headers
  - `include_private: bool` - if True, includes things with names prefaced by '_'
  - `include_dunder: bool` - if True, includes things with names prefaced by '__'
  - `include_submodules: bool` - if True, notes will be made about any additional
  modules encountered when analyzing the specified module
  - `document_submodules: bool` - if True, `dox_a_module` will be called
  recursively on any additional modules encountered when analyzing the specified
  module



  Produces docs for a value. Valid options are the following:

  - `header_level: int` - number of additional hashtags to add to headers
  - `format: str` - format can be one of 'header', 'paragraph', or 'list'



  Produces docs for a function. Valid options are the following:

  - `header_level: int` - number of additional hashtags to add to headers



  Produces docs for a class. Valid options are the following:

  - `exclude_names: list[str]` - names to exclude from docs
  - `header_level: int` - number of additional hashtags to add to headers
  - `include_private: bool` - if True, includes things with names prefaced by '_'
  - `include_dunder: bool` - if True, includes things with names prefaced by '__'
  - `method_format: str` - can be one of 'header', 'paragraph', or 'list'



  There are eight events where custom functionality can be run, specified in the
  `Event` enum:
  - `AFTER_HEADER`
  - `AFTER_PARAGRAPH`
  - `AFTER_LIST`
  - `BEFORE_VALUE`
  - `AFTER_VALUE`
  - `BEFORE_FUNCTION`
  - `AFTER_FUNCTION`
  - `BEFORE_CLASS`
  - `AFTER_CLASS`
  - `BEFORE_MODULE`
  - `AFTER_MODULE`

  Handlers for the `BEFORE_` events can be set using the `set_before_handler`
  function. These handlers will receive the item to be documented and a dict
  containing any options passed into the `dox_a_{thing}` function, and they should
  return a tuple containing those two arguments after any modifications are made
  to them. Example:

  ```python
  from autodox import Event, set_before_handler
  from typing import Callable


  def handle_before_function(function: Callable, options: dict):
      
      options['header_level'] = 2
      return (function, options)

  set_before_handler(Event.BEFORE_FUNCTION, handle_before_function)
  ```

  Handlers for the `AFTER_` events can be set using the `set_after_handler`
  function. These handlers will receive the str doc after the `dox_a_{thing}`
  function has completed executing, and they should return that document after any
  modifications are made. Example:

  ```python
  from autodox import Event, set_after_handler


  def handle_after_function(doc: str):
      
      return doc + 'But really, why would you call this function anyway?\n\n'

  set_after_handler(Event.AFTER_FUNCTION, handle_after_function)
  ```

  Muliple handlers can be set for each event, and they will be executed in order,
  passing the output from the first as input to the second, etc. Example:

  ```python
  from autodox import Event, set_after_handler



  def hello(doc: str):
      return doc + ' hello'

  def world(doc: str):
      return doc + ' world'

  set_after_handler(Event.AFTER_LIST, hello)
  set_after_handler(Event.AFTER_LIST, world)
  ```




  The test suite for this library is currently limited to hooks (14 tests) and a
  few edge cases I encountered using the package (12 tests).

  To test, clone the repository and run the following:

  ```
  python test_hooks.py
  python test_doxing.py
  ```



  Copyleft (c) 2023 k98kurz

  Permission to use, copy, modify, and/or distribute this software
  for any purpose with or without fee is hereby granted, provided
  that the above copyleft notice and this permission notice appear in
  all copies.

  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 8454239f9b02259f112cce99ff67d19291db6e011d2798bef453a660172304bf
name: python-autodynatrace
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Auto instrumentation for the OneAgent SDK
url: https://github.com/dlopes7/autodynatrace
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autodynatrace-2.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/dynatrace-oss/OneAgent-SDK-Python-AutoInstrumentation/workflows/Tests/badge.svg)](https://github.com/dynatrace-oss/OneAgent-SDK-Python-AutoInstrumentation/actions)
   [![Downloads](https://pepy.tech/badge/autodynatrace)](https://pepy.tech/project/autodynatrace)

  Dynatrace provides a [powerful SDK](https://github.com/Dynatrace/OneAgent-SDK-for-Python) that can be used to achieve code level visibility and transaction tracing for applications written in multiple languages, including python. This project provides a library called *autodynatrace*, which is a wrapper around the OneAgent SDK for Python and allows you to instrument python applications with minimal code changes.


  > **Warning**
  > Autodynatrace is opensource and supported via github issues, this is not supported by Dynatrace via support tickets.



  `pip install autodynatrace`



  Add the environment variable `AUTOWRAPT_BOOTSTRAP=autodynatrace` to your python processes



  For most technologies, just import it in your code.

  `import autodynatrace`



  - **aiohttp** (client)
  - **bottle**
  - **celery**
  - **concurrent.futures**
  - **confluent_kafka**
  - **cx_Oracle**
  - **django**
  - **fastapi**
  - **flask**
  - **grpc** (client)
  - **paramiko**
  - **pika** (RabbitMQ)
  - **psycopg2**
  - **pymongo**
  - **pysnmp**
  - **redis**
  - **ruxit** (Dynatrace plugin framework)
  - **sqlalchemy**
  - **subprocess**
  - **suds**
  - **starlette**
  - **tornado**
  - **urllib**
  - **urllib3**
  - **custom annotations**



  For Django, add `"autodynatrace.wrappers.django"` to `INSTALLED_APPS`



  * `AUTODYNATRACE_CAPTURE_HEADERS`: Default: `False`, set to `True` to capture request headers
  * `AUTODYNATRACE_LOG_LEVEL`: Default `WARNING`
  * `AUTODYNATRACE_FORKABLE`: Default `False`, set to `True` to [instrument forked processes](https://github.com/Dynatrace/OneAgent-SDK-for-Python#using-the-oneagent-sdk-for-python-with-forked-child-processes-only-available-on-linux). Use this for gunicorn/uwsgi
  * `AUTODYNATRACE_VIRTUAL_HOST`: Overwrite the default Virtual Host for web frameworks
  * `AUTODYNATRACE_APPLICATION_ID`: Overwrite the default Application Name for web frameworks
  * `AUTODYNATRACE_CONTEXT_ROOT`: Overwrite the default Context Root for web frameworks
  * `AUTODYNATRACE_CUSTOM_SERVICE_NAME`: Overwrite the custom service name (used by `@autodynatrace.trace`)
  * `AUTODYNATRACE_CUSTOM_SERVICE_USE_FQN`: Default `False`, set to `True` to use fully qualified names for service and method names in custom traced services
  * `AUTODYNATRACE_INSTRUMENT_<LIB_NAME>`: If set to `False`, Disables the instrumentation for a specific lib, example: `AUTODYNATRACE_INSTRUMENT_CONCURRENT=False`, default is `True`



  For support using this open source project, please open a github issue explaining your issue and providing code examples, environment details


pkgId: 435c24f759e0de524ed3108765c3babb508756c5e8325afb251779885413c345
name: python-autoeis
arch: src
version: 0.0.35
epoch: 0
release: 1
summary: A tool for automated EIS analysis by proposing statistically plausible ECMs.
url: https://github.com/AUTODIAL/AutoEIS
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoeis-0.0.35-1.src.rpm
checksum_type: sha256
description:
  ![example workflow](https://github.com/AUTODIAL/AutoEIS/actions/workflows/nightly.yml/badge.svg)

  > [!TIP]
  > _Want to get notified about major announcements/new features?_ Please click on "Watch" -> "Custom" -> Check "Releases". Starring the repository alone won't notify you when we make a new release. This is particularly useful since we're actively working on adding new features/improvements to AutoEIS. Currently, we might issue a new release every month, so rest assured that you won't be spammed.





  AutoEIS (Auto ee-eye-ess) is a Python package that automatically proposes statistically plausible equivalent circuit models (ECMs) for electrochemical impedance spectroscopy (EIS) analysis. The package is designed for researchers and practitioners in the fields of electrochemical analysis, including but not limited to explorations of electrocatalysis, battery design, and investigations of material degradation.

  AutoEIS is still under development and the API might change. If you find any bugs or have any suggestions, please file an [issue](https://github.com/AUTODIAL/AutoEIS/issues) or directly submit a [pull request](https://github.com/AUTODIAL/AutoEIS/pulls). We would greatly appreciate any contributions from the community.





  Open a terminal (or command prompt on Windows) and run the following command:

  ```bash
  pip install -U autoeis
  ```

  Julia dependencies will be automatically installed at first import. It's recommended that you have your own Julia installation, but if you don't, Julia itself will also be installed automatically.

  > **How to install Julia?** If you decided to have your own Julia installation (recommended), the official way to install Julia is via [juliaup](https://github.com/JuliaLang/juliaup). [Juliaup](https://github.com/JuliaLang/juliaup) provides a command line interface to automatically install Julia (optionally multiple versions side by side). Working with [juliaup](https://github.com/JuliaLang/juliaup) is straightforward; Please follow the instructions on its GitHub [page](https://github.com/JuliaLang/juliaup).



  Visit our [examples'](https://autodial.github.io/AutoEIS/examples.html) page to learn how to use AutoEIS.



  The schematic workflow of AutoEIS is shown below:

  ![AutoEIS workflow](https://raw.githubusercontent.com/AUTODIAL/AutoEIS/develop/assets/workflow.png)

  It includes: data pre-processing, ECM generation, circuit post-filtering, Bayesian inference, and the model evaluation process. Through this workflow, AutoEis can prioritize the statistically optimal ECM and also retain suboptimal models with lower priority for subsequent expert inspection. A detailed workflow can be found in the [paper](https://iopscience.iop.org/article/10.1149/1945-7111/aceab2/meta).



  Thanks to Prof. Jason Hattrick-Simpers, Dr. Robert Black, Dr. Debashish Sur, Dr. Parisa Karimi, Dr. Brian DeCost, Dr. Kangming Li, and Prof. John R. Scully for their guidance and support. Also, thanks to Dr. Shijing Sun, Prof. Keryn Lian, Dr. Alvin Virya, Dr. Austin McDannald, Dr. Fuzhan Rahmanian, and Prof. Helge Stein for their feedback and discussions. Special shoutout to Prof. John R. Scully and Dr. Debashish Sur for letting us use their corrosion data to showcase the functionality of AutoEIS—your help has been invaluable!


pkgId: 5fe0090dc535631b3c12b9cc77bc48337741daf5eb5c9a5ff113945b0c57e8c1
name: python-autoeis
arch: src
version: 0.0.36
epoch: 0
release: 1
summary: A tool for automated EIS analysis by proposing statistically plausible ECMs.
url: https://github.com/AUTODIAL/AutoEIS
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoeis-0.0.36-1.src.rpm
checksum_type: sha256
description:
  ![example workflow](https://github.com/AUTODIAL/AutoEIS/actions/workflows/nightly.yml/badge.svg)

  > [!TIP]
  > _Want to get notified about major announcements/new features?_ Please click on "Watch" -> "Custom" -> Check "Releases". Starring the repository alone won't notify you when we make a new release. This is particularly useful since we're actively working on adding new features/improvements to AutoEIS. Currently, we might issue a new release every month, so rest assured that you won't be spammed.





  AutoEIS (Auto ee-eye-ess) is a Python package that automatically proposes statistically plausible equivalent circuit models (ECMs) for electrochemical impedance spectroscopy (EIS) analysis. The package is designed for researchers and practitioners in the fields of electrochemical analysis, including but not limited to explorations of electrocatalysis, battery design, and investigations of material degradation.

  AutoEIS is still under development and the API might change. If you find any bugs or have any suggestions, please file an [issue](https://github.com/AUTODIAL/AutoEIS/issues) or directly submit a [pull request](https://github.com/AUTODIAL/AutoEIS/pulls). We would greatly appreciate any contributions from the community.





  Open a terminal (or command prompt on Windows) and run the following command:

  ```bash
  pip install -U autoeis
  ```

  Julia dependencies will be automatically installed at first import. It's recommended that you have your own Julia installation, but if you don't, Julia itself will also be installed automatically.

  > **How to install Julia?** If you decided to have your own Julia installation (recommended), the official way to install Julia is via [juliaup](https://github.com/JuliaLang/juliaup). [Juliaup](https://github.com/JuliaLang/juliaup) provides a command line interface to automatically install Julia (optionally multiple versions side by side). Working with [juliaup](https://github.com/JuliaLang/juliaup) is straightforward; Please follow the instructions on its GitHub [page](https://github.com/JuliaLang/juliaup).



  Visit our [example notebooks](https://autodial.github.io/AutoEIS/examples.html) page to learn how to use AutoEIS.



  The schematic workflow of AutoEIS is shown below:

  ![AutoEIS workflow](https://raw.githubusercontent.com/AUTODIAL/AutoEIS/develop/assets/workflow.png)

  It includes: data pre-processing, ECM generation, circuit post-filtering, Bayesian inference, and the model evaluation process. Through this workflow, AutoEis can prioritize the statistically optimal ECM and also retain suboptimal models with lower priority for subsequent expert inspection. A detailed workflow can be found in the [paper](https://iopscience.iop.org/article/10.1149/1945-7111/aceab2/meta).



  Thanks to Prof. Jason Hattrick-Simpers, Dr. Robert Black, Dr. Debashish Sur, Dr. Parisa Karimi, Dr. Brian DeCost, Dr. Kangming Li, and Prof. John R. Scully for their guidance and support. Also, thanks to Dr. Shijing Sun, Prof. Keryn Lian, Dr. Alvin Virya, Dr. Austin McDannald, Dr. Fuzhan Rahmanian, and Prof. Helge Stein for their feedback and discussions. Special shoutout to Prof. John R. Scully and Dr. Debashish Sur for letting us use their corrosion data to showcase the functionality of AutoEIS—your help has been invaluable!


pkgId: 790fdde9fccdb95345f45c45bcbb4f60703ae3eb4f50069516dbd09fba6fdb63
name: python-autoevals
arch: src
version: 0.0.103
epoch: 0
release: 1
summary: Universal library for evaluating AI models
url: https://www.braintrustdata.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoevals-0.0.103-1.src.rpm
checksum_type: sha256
description:
  Autoevals is a tool to quickly and easily evaluate AI model outputs.

  It bundles together a variety of automatic evaluation methods including:

  - LLM-as-a-Judge
  - Heuristic (e.g. Levenshtein distance)
  - Statistical (e.g. BLEU)

  Autoevals is developed by the team at [Braintrust](https://braintrust.dev/).

  Autoevals uses model-graded evaluation for a variety of subjective tasks including fact checking,
  safety, and more. Many of these evaluations are adapted from OpenAI's excellent [evals](https://github.com/openai/evals)
  project but are implemented so you can flexibly run them on individual examples, tweak the prompts, and debug
  their outputs.

  You can also create your own model-graded evaluations with Autoevals. It's easy to add custom prompts, parse outputs,
  and manage exceptions.



  Autoevals is distributed as a [Python library on PyPI](https://pypi.org/project/autoevals/) and
  [Node.js library on NPM](https://www.npmjs.com/package/autoevals).



  ```bash
  pip install autoevals
  ```



  ```bash
  npm install autoevals
  ```



  Use Autoevals to model-grade an example LLM completion using the [factuality prompt](templates/factuality.yaml).
  By default, Autoevals uses your `OPENAI_API_KEY` environment variable to authenticate with OpenAI's API.



  ```python
  from autoevals.llm import *


  evaluator = Factuality()


  input = "Which country has the highest population?"
  output = "People's Republic of China"
  expected = "China"

  result = evaluator(output, expected, input=input)


  print(f"Factuality score: {result.score}")
  print(f"Factuality metadata: {result.metadata['rationale']}")
  ```



  ```javascript
  import { Factuality } from "autoevals";

  (async () => {
    const input = "Which country has the highest population?";
    const output = "People's Republic of China";
    const expected = "China";

    const result = await Factuality({ output, expected, input });
    console.log(`Factuality score: ${result.score}`);
    console.log(`Factuality metadata: ${result.metadata.rationale}`);
  })();
  ```



  Once you grade an output using Autoevals, it's convenient to use [Braintrust](https://www.braintrust.dev/docs/libs/python) to log and compare your evaluation results.



  ```python
  from autoevals.llm import *
  import braintrust


  evaluator = Factuality()


  input = "Which country has the highest population?"
  output = "People's Republic of China"
  expected = "China"


  experiment = braintrust.init(
      project="Autoevals", api_key="YOUR_BRAINTRUST_API_KEY"
  )


  with experiment.start_span() as span:
      result = evaluator(output, expected, input=input)

      
      print(f"Factuality score: {result.score}")
      print(f"Factuality metadata: {result.metadata['rationale']}")

      span.log(
          inputs={"query": input},
          output=output,
          expected=expected,
          scores={
              "factuality": result.score,
          },
          metadata={
              "factuality": result.metadata,
          },
      )

  print(experiment.summarize())
  ```



  Create a file named `example.eval.js` (it must end with `.eval.js` or `.eval.js`):

  ```javascript
  import { Eval } from "braintrust";
  import { Factuality } from "autoevals";

  Eval("Autoevals", {
    data: () => [
      {
        input: "Which country has the highest population?",
        expected: "China",
      },
    ],
    task: () => "People's Republic of China",
    scores: [Factuality],
  });
  ```

  Then, run

  ```bash
  npx braintrust run example.eval.js
  ```





  - Battle
  - ClosedQA
  - Humor
  - Factuality
  - Moderation
  - Security
  - Summarization
  - SQL
  - Translation
  - Fine-tuned binary classifiers



  - Context precision
  - Context relevancy
  - Context recall
  - Context entities recall
  - Faithfullness
  - Answer relevance
  - Answer semantic similarity
  - Answer correctness
  - Aspect critique



  - Semantic list contains
  - JSON validity



  - Embedding similarity
  - BERTScore



  - Levenshtein distance
  - Exact match
  - Numeric difference
  - JSON diff
  - Jaccard distance



  - BLEU
  - ROUGE
  - METEOR



  Autoevals supports custom evaluation prompts for model-graded evaluation. To use them, simply pass in a prompt and scoring mechanism:



  ```python
  from autoevals import LLMClassifier


  prompt_prefix = """
  You are a technical project manager who helps software engineers generate better titles for their GitHub issues.
  You will look at the issue description, and pick which of two titles better describes it.

  I'm going to provide you with the issue description, and two possible titles.

  Issue Description: {{input}}

  1: {{output}}
  2: {{expected}}
  """




  output_scores = {"1": 1, "2": 0}

  evaluator = LLMClassifier(
      name="TitleQuality",
      prompt_template=prompt_prefix,
      choice_scores=output_scores,
      use_cot=True,
  )


  page_content = """
  As suggested by Nicolo, we should standardize the error responses coming from GoTrue, postgres, and realtime (and any other/future APIs) so that it's better DX when writing a client,
  We can make this change on the servers themselves, but since postgrest and gotrue are fully/partially external may be harder to change, it might be an option to transform the errors within the client libraries/supabase-js, could be messy?
  Nicolo also dropped this as a reference: http://spec.openapis.org/oas/v3.0.3#openapi-specification"""
  output = (
      "Standardize error responses from GoTrue, Postgres, and Realtime APIs for better DX"
  )
  expected = "Standardize Error Responses across APIs"

  response = evaluator(output, expected, input=page_content)

  print(f"Score: {response.score}")
  print(f"Metadata: {response.metadata}")
  ```



  ```javascript
  import { LLMClassifierFromTemplate } from "autoevals";

  (async () => {
    const promptTemplate = `You are a technical project manager who helps software engineers generate better titles for their GitHub issues.
  You will look at the issue description, and pick which of two titles better describes it.

  I'm going to provide you with the issue description, and two possible titles.

  Issue Description: {{input}}

  1: {{output}}
  2: {{expected}}`;

    const choiceScores = { 1: 1, 2: 0 };

    const evaluator =
      LLMClassifierFromTemplate <
      { input: string } >
      {
        name: "TitleQuality",
        promptTemplate,
        choiceScores,
        useCoT: true,
      };

    const input = `As suggested by Nicolo, we should standardize the error responses coming from GoTrue, postgres, and realtime (and any other/future APIs) so that it's better DX when writing a client,
  We can make this change on the servers themselves, but since postgrest and gotrue are fully/partially external may be harder to change, it might be an option to transform the errors within the client libraries/supabase-js, could be messy?
  Nicolo also dropped this as a reference: http://spec.openapis.org/oas/v3.0.3#openapi-specification`;
    const output = `Standardize error responses from GoTrue, Postgres, and Realtime APIs for better DX`;
    const expected = `Standardize Error Responses across APIs`;

    const response = await evaluator({ input, output, expected });

    console.log("Score", response.score);
    console.log("Metadata", response.metadata);
  })();
  ```



  You can also create your own scoring functions that do not use LLMs. For example, to test whether the word `'banana'`
  is in the output, you can use the following:



  ```python
  from autoevals import Score


  def banana_scorer(output, expected, input):
      return Score(name="banana_scorer", score=1 if "banana" in output else 0)


  input = "What is 1 banana + 2 bananas?"
  output = "3"
  expected = "3 bananas"

  result = banana_scorer(output, expected, input)

  print(f"Banana score: {result.score}")
  ```



  ```javascript
  import { Score } from "autoevals";

  const bananaScorer = ({
    output,
    expected,
    input,
  }: {
    output: string;
    expected: string;
    input: string;
  }): Score => {
    return { name: "banana_scorer", score: output.includes("banana") ? 1 : 0 };
  };

  (async () => {
    const input = "What is 1 banana + 2 bananas?";
    const output = "3";
    const expected = "3 bananas";

    const result = bananaScorer({ output, expected, input });
    console.log(`Banana score: ${result.score}`);
  })();
  ```



  There is nothing particularly novel about the evaluation methods in this library. They are all well-known and well-documented. However, there are a few things that are particularly difficult when evaluating in practice:

  - Normalizing metrics between 0 and 1 is tough. For example, check out the calculation in [number.py](/py/autoevals/number.py) to see how it's done for numeric differences.
  - Parsing the outputs on model-graded evaluations is also challenging. There are frameworks that do this, but it's hard to
    debug one output at a time, propagate errors, and tweak the prompts. Autoevals makes these tasks easy.
  - Collecting metrics behind a uniform interface makes it easy to swap out evaluation methods and compare them. Prior to Autoevals, we couldn't find an open source library where you can simply pass in `input`, `output`, and `expected` values through a bunch of different evaluation methods.



  The full docs are available [here](https://www.braintrust.dev/docs/reference/autoevals).


pkgId: 6d543fd9e5065298ff663939b092336b0b3b2ceb9f2332e5527f6c4ec8f169b8
name: python-autofeat
arch: src
version: 2.1.3
epoch: 0
release: 1
summary: Automatic Feature Engineering and Selection Linear Prediction Model
url: https://franziskahorn.de/autofeat
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autofeat-2.1.3-1.src.rpm
checksum_type: sha256
description:
  This library contains `sklearn`-compatible linear prediction models with automated feature engineering and selection capabilities.

  For more information please have a look at the [documentation](https://franziskahorn.de/autofeat).

  The code is intended for research purposes.

  If you have any questions please don't hesitate to send me an [email](mailto:cod3licious@gmail.com) and of course if you should find any bugs or want to contribute other improvements, pull requests are very welcome!




  This project was made possible thanks to support by [BASF](https://www.basf.com).


pkgId: f0b492b0bcbc4c353267284fd29cc2ab7717d37274894ae7021da38c105f99fd
name: python-autofeather-dash-mantine-components
arch: src
version: 0.14.37
epoch: 0
release: 1
summary: Plotly Dash Components based on Mantine
url: https://github.com/snehilvj/dash-mantine-components
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autofeather-dash-mantine-components-0.14.37-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://raw.githubusercontent.com/snehilvj/dash-mantine-components/master/assets/logo.png" alt="logo" width=300 >
  </p>
  <p align="center">
      <img src="https://badgen.net/pypi/license/dash-mantine-components">
      <a href="https://pypi.org/project/dash-mantine-components/">
      <img src="https://badgen.net/pypi/v/dash-mantine-components">
      </a>
      <a href="https://discord.gg/KuJkh4Pyq5">
      <img src="https://img.shields.io/badge/Chat%20on-Discord-%235865f2">
      </a>
      <img src="https://static.pepy.tech/personalized-badge/dash-mantine-components?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=Downloads">
  </p>

  Dash Mantine Components is an extensive (90+) Dash components library based on [Mantine](https://mantine.dev/) React Components Library. It makes it easier to create good quality dashboards with very well designed components out of the box.


  <p align="center">
      <img src="https://raw.githubusercontent.com/snehilvj/dash-mantine-components/master/assets/datepicker.gif">
  </p>




  ```bash
  pip install dash-mantine-components
  ```



  ```python
  from datetime import date

  import dash
  from dash import Dash, Input, Output, callback, html
  from dash.exceptions import PreventUpdate

  import dash_mantine_components as dmc

  dash._dash_renderer._set_react_version('18.2.0')

  app = Dash(__name__, external_stylesheets=dmc.styles.ALL)

  app.layout = dmc.MantineProvider(
      [
          dmc.DatePicker(
              id="date-picker",
              label="Start Date",
              description="You can also provide a description",
              minDate=date(2020, 8, 5),
              value=None,
              w=200
          ),
          dmc.Space(h=10),
          dmc.Text(id="selected-date"),
      ]
  )


  @callback(Output("selected-date", "children"), Input("date-picker", "value"))
  def update_output(d):
      prefix = "You have selected: "
      if d:
          return prefix + d
      else:
          raise PreventUpdate


  if __name__ == "__main__":
      app.run_server(debug=True)
  ```



  For detailed information on how to use this project, check out the [Documentation](https://dash-mantine-components.com). You'll find guides, API references, and examples to help you get started!



  We welcome all contributions! Feel free to open issues for any bugs or feature requests, and don't hesitate to
  comment on existing issues or pull requests. PRs are encouraged! For more details, please check out our [Contributing Guide.](https://github.com/snehilvj/dash-mantine-components/blob/master/CONTRIBUTING.md)

  Join our [Discord](https://discord.gg/KuJkh4Pyq5) to connect with other contributors, or visit the [Plotly Dash Community Forum](https://community.plotly.com/)
  for discussions and support.




  We :heart: contributions to our documentation! It's a fantastic opportunity for first-time contributors since the
  project is simply a Dash app built with `dash-mantine-components`. For more details, check out the [dmc-docs GitHub.](https://github.com/snehilvj/dmc-docs)




  A huge thank you to our current sponsors for supporting this project! 🙏 Your contributions help drive development and improvements.

  If you’d like to support this project and help ensure its continued success, consider [becoming a sponsor](https://github.com/sponsors/snehilvj). Your support
  is greatly appreciated and helps keep the project growing and thriving!



  If you find this project helpful, consider giving it a star on GitHub! ⭐️ It helps others discover the project and
  motivates us to keep improving it. Your support is greatly appreciated!


pkgId: 0a0acf15e602b7c5b4a8cb8e4f2fb43b1137c068ce25755654cabe1021f2a978
name: python-autofish
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Control of automated fluidics system
url: https://github.com/fish-quant/autofish
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autofish-0.0.7-1.src.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/fish-quant/autofish)
  [![Python 3.9](https://img.shields.io/badge/python-3.9-blue.svg)](https://www.python.org/downloads/release/python-390/)



  Python library to control an automated fluidics system and perform acquisition on a microscope for sequential FISH experiments.

  > :warning: **TESTED FOR WINDOWS only**: micromanager and most microscope controls work only under Windows.

  <img src="docs/instrumentation-control.png" width="400">



  We provide detailed protocols for single molecule FISH adapated to autoFISH [**here**](https://drive.google.com/drive/folders/1m4SFZFpOHzQbgO7dFY38xFbccV2XqMKH?usp=sharing).

  <img src="docs/experimental-protocols.png" width="800">



  We provide details documentation for the fluidics system and the experimental workflows with the links below:



  - Documentation to use Python **control software**:
    [**PDF**](https://drive.google.com/open?id=1-Fr_Dbg0eQDSbhBmq2gmJ1FDb4Uy_ToI&usp=drive_fs) or
    [**WORD**](https://docs.google.com/document/d/1-IA6f02elFrF7JSLvXx199cNjnm8ciBB?rtpof=true&usp=drive_fs)

  - Documentation to **build the fluidics system**:
    [**PDF**](https://drive.google.com/open?id=1-3anf7ieKRPeKJ387K1XaBH0heWWIocm&usp=drive_fs) or
    [**WORD**](https://docs.google.com/document/d/1-NUsaEacdTHfEi9gJ_SppbXEfD7z9-im?rtpof=true&usp=drive_fs)

  - Documentation to **use a TTL trigger with the LEICA Thunder**:
    [**PDF**](https://drive.google.com/open?id=1-bkihEoPfgZdNXIDN6bbxiwU0kXM9xOt&usp=drive_fs) or
    [**WORD**](https://docs.google.com/document/d/1-ZXZ6kcjAJHre7fJ8rNfXpDT03TYYEI-?rtpof=true&usp=drive_fs)

  <img src="docs/fluidic-system.png" width="800">





  We recommend using a package manager (conda) to maintain a clean Python installation. This nees to be done only once.

  1. Download latest version of miniconda from [**here**](https://docs.conda.io/en/latest/miniconda.html).
  2. Open Anaconda terminal and create dedicated environment: `conda create --name autofish python=3.10`
  3. Activate environment: `conda activate autofish`
  4. Pip install **autofish** (as an alternative see development installation below)
     - Base version (without pycromanager) : `pip install autofish`
     - [Optional] Install pycromanager : `pip install pycromanager`



  1. Open Anaconda terminal and activate environment: `conda activate autofish`
  2. Start user interface with command `autofish`



  1. Open Anaconda terminal and activate environment: `conda activate autofish`
  2. Upgrade autoFISH `pip install --upgrade autofish`



  If you want to modify develop the package, several options exist.

  1. Recommended is to **`clone` the repository**. This will then also allow to propose your changes to the main autoFISH repository as a PullRequest. See for instance [here](https://codex.so/fork-and-pull-en) for an explanation for how this is done. This also allows to easier add changes from the main repository
  2. An alternative is a **local installation**. While this might be easier in the short run, it will be challenig to integrate future changes on the main repository. Rather than performing the pip install (step 4 above), you

     1. Download the zip archive of the branch you are interested in.
     2. Unzip on your machine.
     3. Open Anaconda terminal at location of the autofish package.
     4. Activate environment: `conda activate autofish`
     5. Editable install `pip install . -e`



  The behavior of the fluidics and acquistion system is defined by several config files.

  - To test the installation of autofish, you can use demo configurations which require neither a microscope nor a fluidics systems: <https://github.com/fish-quant/autofish/tree/main/demo>

  - We provide config files that we use on our system (with a Nikon Ti): <https://github.com/fish-quant/autofish/tree/main/configs>




  One of the acquisition options is by using Pycromanager. We found that keeping both micromanager and Pycromanager up-to-date can help to prevent problems.

  **Last tested, compatible versions**:

  - Pycromanager: 0.27.2
  - Micromanager: nightly 20230224




  If you encounter a problem or you have a suggestion, please file an [**issue**](https://github.com/fish-quant/autofish/issues).


