# packages

pkgId: 7009afecbf94ebad9de0e9a09d8629bb8ee35a93b9cf9a56d203bc993c6ea671
name: python-tox-factor
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Run tox testenvs that match a given factor
url: https://github.com/rpkilby/tox-factor
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-74bf498f-a72e-4df6-ad1c-7c83f1face46
location_href: 00012892-python-tox-factor/python-tox-factor-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/rpkilby/tox-factor.svg?style=shield)](https://circleci.com/gh/rpkilby/tox-factor)
  [![Appveyor](https://ci.appveyor.com/api/projects/status/8yqgrr22dct9rxxg?svg=true)](https://ci.appveyor.com/project/rpkilby/tox-factor)
  [![codecov](https://codecov.io/gh/rpkilby/tox-factor/branch/master/graph/badge.svg)](https://codecov.io/gh/rpkilby/tox-factor)
  [![version](https://img.shields.io/pypi/v/tox-factor.svg)](https://pypi.python.org/pypi/tox-factor)
  [![python](https://img.shields.io/pypi/pyversions/tox-factor.svg)](https://pypi.org/project/tox-factor/)
  [![license](https://img.shields.io/pypi/l/tox-factor.svg)](https://pypi.python.org/pypi/tox-factor)



  tox-factor enables running a subset of tox test envs, based on factor matching.




  Take the following tox config:

  ```ini
  [tox]
  envlist =
      py{35,36,37}-django{20,21,22}-{redis,memcached}
  ```

  The above defines 18 test envs, based on three factor groups - the python
  version, the django version, and a caching backend. While the above is powerful,
  tox does not provide a way to run builds based on a subset of those factors.
  For example, the call to run all Python 3.7 builds would be:

  ```shell
  $ tox -e py37-django20-redis,py37-django20-memcached,py37-django21-redis,py37-django21-memcached,py37-django22-redis,py37-django22-memcached
  ```

  tox-factor functions similarly to the `-e <env name>` argument, except it runs
  all envs that match the given factor. The six `py37` builds could be ran with:

  ```shell
  $ tox -f py37
  ```

  In addition to ease of use when running tox locally, this is useful for some CI
  setups. For example, two common tox CI patterns are to either:

  - Define a CI job for each tox test env. e.g.,

      `tox -e py37-django20-redis`

  - Define a CI job for a common environment that runs multiple test envs. e.g.,

      `tox -e py37-django20-redis,py37-django20-memcached,...`

  For the latter case, this plugin eases maintenance of CI, as it could be
  shortened to `tox -f py37`. Additionally, take the following update to the above
  tox config:

  ```ini
  [tox]
  envlist =
      py{35,36,37}-django{20,21,22}-{redis,memcached}
      py{36,37,38}-django{30}-{redis,memcached}
  ```

  By using tox-factor, it wouldn't be necessary to update the Python 3.7 build, as
  the new `py37-django30-*` env would be matched automatically.





  If you want to verify which test envs are actually ran, combine the factor
  matching with the `-l` flag. This will display all test envs that match. e.g.,

  ```shell
  $ tox -f py37 -l
  py37-django20-redis
  py37-django20-memcached
  py37-django21-redis
  py37-django21-memcached
  py37-django22-redis
  py37-django22-memcached
  ```




  The factor option accepts a comma-separated list (similar to the `-e` option).
  ```shell
  $ tox -f py27,py37 -l
  py27-django111
  py37-django21
  ```

  Alternatively, factors can be provided via the `TOXFACTOR` environment variable:
  ```shell
  $ TOXFACTOR=py27,py37 tox -l
  py27-django111
  py37-django21
  ```

  Factors can also match non-generative env names. For example, given the
  following tox config:

  ```ini
  [tox]
  envlist =
      py{35,36,37}-django20

  [testenv:list]
  ```

  Then the following would match:

  ```shell
  $ tox -f py37,lint -l
  py37-django20
  lint
  ```

  Factors are always superseded by a given `toxenv`. For example, tox-factor would
  noop in the following cases:

  ```shell
  $ tox -f py37 -e py35-django21 -l
  py35-django21

  $ TOXENV=py35-django21 tox -f py37 -l
  py35-django21
  ```

  Factors do not support partial matching. `tox -f py3` would not match `py37`.
  However, factors may match disparate dash-separated parts. Given the following:
  ```ini
  [tox]
  envlist =
      py{35,36,37}-django{20,21,22}-{redis,memcached}
  ```

  Then `tox -f py37-redis` would match:
  ```
  py37-django20-redis
  py37-django21-redis
  py37-django22-redis
  ```




  - Update changelog
  - Update package version in setup.py
  - Create git tag for version
  - Upload release to PyPI test server
  - Upload release to official PyPI server

  ```shell
  $ pip install -U pip setuptools wheel twine
  $ rm -rf dist/ build/
  $ python setup.py sdist bdist_wheel
  $ twine upload -r test dist/*
  $ twine upload dist/*
  ```




  This code is largely based off the work done by @ryanhiebert in [tox-travis][1].
  Without his efforts, it would have taken significantly more time to write and
  test this package.



  See: [LICENSE][2]

  [1]: https://github.com/tox-dev/tox-travis
  [2]: https://github.com/rpkilby/tox-factor/blob/master/LICENSE

  BSD 3-Clause License

  Copyright (c) 2019, Ryan P Kilby
  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: 4168213e4cae26e940a8f2abdabb539d5927b834e8accd9fdac67d83b9179547
name: python-tox-gh-actions
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Seamless integration of tox into GitHub Actions
url: https://github.com/ymyzk/tox-gh-actions
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6271f2c8-bd33-4fe2-be48-694b180d4726
location_href: 00010921-python-tox-gh-actions/python-tox-gh-actions-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/tox-gh-actions.svg)](https://badge.fury.io/py/tox-gh-actions)
  [![PyPI Supported Python Versions](https://img.shields.io/pypi/pyversions/tox-gh-actions.svg)](https://pypi.python.org/pypi/tox-gh-actions/)
  [![GitHub Actions (Tests)](https://github.com/ymyzk/tox-gh-actions/actions/workflows/tests.yml/badge.svg)](https://github.com/ymyzk/tox-gh-actions/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/gh/ymyzk/tox-gh-actions/branch/master/graph/badge.svg?token=7RWjRk2LkX)](https://codecov.io/gh/ymyzk/tox-gh-actions)

  **tox-gh-actions** is a tox plugin which helps running tox on GitHub Actions
  with multiple different Python versions on multiple workers in parallel.
  This project is inspired by [tox-travis](https://github.com/tox-dev/tox-travis).


  Currently, tox-gh-actions supports both tox 3 and 4, but users need to install the appropriate version by following the table below.

  | tox | tox-gh-actions | Supported by tox-gh-actions | Branch                                                    |
  |-----|----------------|-----------------------------|-----------------------------------------------------------|
  | 4.x | 3.x            | Yes (stable)                | [master](https://github.com/ymyzk/tox-gh-actions)         |
  | 3.x | 2.x            | Yes (stable)                | [tox3](https://github.com/ymyzk/tox-gh-actions/tree/tox3) |

  - [Features](#features)
  - [Usage](#usage)
  - [Examples](#examples)
    - [Basic Example](#basic-example)
      - [tox-gh-actions Configuration](#tox-gh-actions-configuration)
      - [Workflow Configuration](#workflow-configuration)
    - [Advanced Examples](#advanced-examples)
      - [Factor-Conditional Settings: Python Version](#factor-conditional-settings-python-version)
      - [Factor-Conditional Settings: Environment Variable](#factor-conditional-settings-environment-variable)
    - [Overriding Environments to Run](#overriding-environments-to-run)
  - [Versioning](#versioning)
  - [Understanding Behavior of tox-gh-actions](#understanding-behavior-of-tox-gh-actions)
    - [How tox-gh-actions Works](#how-tox-gh-actions-works)
    - [Logging](#logging)


  When running tox on GitHub Actions, tox-gh-actions
  * detects which environment to run based on configurations and
  * provides utilities such as [grouping log lines](https://github.com/actions/toolkit/blob/main/docs/commands.md#group-and-ungroup-log-lines).


  1. Add configurations under `[gh-actions]` section along with tox's configuration.
     - It will be `pyproject.toml`, `tox.ini`, or `setup.cfg`. See [tox's documentation](https://tox.wiki/en/latest/config.html) for more details.

  2. Install `tox-gh-actions` package in the GitHub Actions workflow before running `tox` command.



  The following configuration will create 4 jobs when running the workflow on GitHub Actions.
  - On Python 3.7 job, tox runs `py37` environment
  - On Python 3.8 job, tox runs `py38` environment
  - On Python 3.9 job, tox runs `py39` environment
  - On Python 3.10 job, tox runs `py310` and `mypy` environments


  Add `[gh-actions]` section to the same file as tox's configuration.

  If you're using `tox.ini`:
  ```ini
  [tox]
  envlist = py37, py38, py39, py310, mypy

  [gh-actions]
  python =
      3.7: py37
      3.8: py38
      3.9: py39
      3.10: py310, mypy

  [testenv]
  ...
  ```

  If you're using `setup.cfg`:
  ```ini
  [tox:tox]
  envlist = py37, py38, py39, py310, mypy

  [gh-actions]
  python =
      3.7: py37
      3.8: py38
      3.9: py39
      3.10: py310, mypy

  [testenv]
  ...
  ```

  If you're using `pyproject.toml`:
  ```toml
  [tool.tox]
  legacy_tox_ini = """
  [tox]
  envlist = py37, py38, py39, py310, mypy

  [gh-actions]
  python =
      3.7: py37
      3.8: py38
      3.9: py39
      3.10: py310, mypy

  [testenv]
  """
  ```


  `.github/workflows/<workflow>.yml`:
  ```yaml
  name: Python package

  on:
    - push
    - pull_request

  jobs:
    build:
      runs-on: ubuntu-latest
      strategy:
        matrix:
          python-version: ['3.7', '3.8', '3.9', '3.10']

      steps:
      - uses: actions/checkout@v3
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          python -m pip install tox tox-gh-actions
      - name: Test with tox
        run: tox
  ```



  The following configuration will create 2 jobs when running the workflow on GitHub Actions.
  - On Python 3.7 job, tox runs `py37-django22` and `py37-django32` environments
  - On Python 3.8 job, tox runs `py38-django32` environment

  `tox.ini`:
  ```ini
  [tox]
  envlist = py37-django{22,32}, py38-django32

  [gh-actions]
  python =
      3.7: py37
      3.8: py38

  [testenv]
  ...
  ```

  When using pre-release versions of Python, please do not specify `-beta` or `-dev` in `tox.ini`.

  `.github/workflows/<workflow>.yml`:
  ```yaml
  ...
  jobs:
    build:
      strategy:
        matrix:
          python-version: [3.9, 3.10.0-beta.3]
  ...
  ```

  `tox.ini`:
  ```ini
  [tox]
  envlist = py39, py310

  [gh-actions]
  python =
      3.9: py39
      3.10: py310
      
      
      

  [testenv]
  ...
  ```

  PyPy is also supported in the `python` configuration key.
  Support of Pyston is experimental and not tested by our CI.

   `tox.ini`:
  ```ini
  [tox]
  envlist = py37, py38, pypy3, pyston38

  [gh-actions]
  python =
      3.7: py37
      3.8: py38, mypy
      pypy-3.7: pypy3
      pyston-3.8: pyston38

  [testenv]
  ...

  [testenv:pyston38]
  basepython = pyston38
  ```

  You can also specify without minor versions in the `python` configuration key.

  `tox.ini`:
  ```ini
  [tox]
  envlist = py3, pypy3

  [gh-actions]
  python =
      3: py3, mypy
      pypy-3: pypy3

  [testenv]
  ...
  ```

  If there are multiple matching Python versions in the configuration, only the most precise one is used.
  For example, if you are running CPython 3.8 and `gh-actions.python` has both `3` and `3.8`,
  tox-gh-actions gets factors only from the key `3.8`.

  _Changed in 3.0_: `pypy3` is not supported in the configuration anymore. Please use `pypy-3` instead.


  You can also use environment variable to decide which environment to run.
  The following is an example to install different dependency based on platform.
  It will create 9 jobs when running the workflow on GitHub Actions.
  - On Python 3.8/ubuntu-latest job, tox runs `py38-linux` environment
  - On Python 3.9/ubuntu-latest job, tox runs `py39-linux` environment
  - and so on.

  `.github/workflows/<workflow>.yml`:
  ```yaml
  name: Python package

  on:
    - push
    - pull_request

  jobs:
    build:
      runs-on: ${{ matrix.platform }}
      strategy:
        matrix:
          platform: [ubuntu-latest, macos-latest, windows-latest]
          python-version: ['3.8', '3.9', '3.10']

      steps:
      - uses: actions/checkout@v3
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          python -m pip install tox tox-gh-actions
      - name: Test with tox
        run: tox
        env:
          PLATFORM: ${{ matrix.platform }}
  ```

  `tox.ini`:
  ```ini
  [tox]
  envlist = py{38,39,310}-{linux,macos,windows}

  [gh-actions]
  python =
      3.8: py38
      3.9: py39
      3.10: py310

  [gh-actions:env]
  PLATFORM =
      ubuntu-latest: linux
      macos-latest: macos
      windows-latest: windows

  [testenv]
  deps =
    <common dependency>
    linux: <Linux specific deps>
    macos: <macOS specific deps>
    windows: <Windows specific deps>
  ...
  ```

  _Changed in 3.0_: Environment variables should not use lowercase letters.
  Because of the limitation in tox's configuration loading API,
  tox-gh-actions always convert keys in `[gh-actions:env]` to uppercase.


  _Changed in 2.0_: When a list of environments to run is specified explicitly via `-e` option or `TOXENV` environment variable ([tox's help](https://tox.wiki/en/latest/cli_interface.html#tox-run--e)),
  tox-gh-actions respects the given environments and simply runs the given environments without enforcing its configuration.

  Before 2.0, tox-gh-actions was always enforcing its configuration even when a list of environments is given explicitly.


  This project follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) and uses a format of major.minor.patch (X.Y.Z).
  The major version (X) will be incremented when we make backward incompatible changes to a public API.
  The public API of this project is the configuration of tox-gh-actions.
  The major version can be also incremented when we require a new version of tox.

  This project tries not to introduce backward incompatibles changes as much as possible so that users don't need to
  update their project's configuration too frequently.

  tox-gh-actions 3.x may drop support of unsupported Python 3.y versions in the future without bumping its major version.



  See [ARCHITECTURE.md](./ARCHITECTURE.md) for more details.


  tox-gh-actions writes log messages using the standard `logging` module.
  This is handy for understanding behavior of tox-gh-actions and for debugging tox-gh-actions.
  To see the log messages, please run `tox -vv`.


pkgId: 52d36d03765112f7a207e98a5e854f1f590ba02e25871033af450a605163564f
name: python-tox-pip-version
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Select PIP version to use with tox
url: https://github.com/pglass/tox-pip-version
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-84acb6a1-089f-4120-8a0c-3087cf991748
location_href: 00011845-python-tox-pip-version/python-tox-pip-version-0.0.7-1.src.rpm
checksum_type: sha256
description:
  This is a tox plugin that preinstalls a specific version of pip in each tox
  environment.
  ```bash
  pip install tox-pip-version
  ```
  This works around the default behavior of tox/virtualenv that always installs
  the latest version pip. It is an improvment over the `VIRTUALENV_NO_DOWNLOAD=1`
  option that does not install the latest version, but could result in usage of
  an outdated version of pip.
  *Recommendation*: Do not pin the pip version long term. You get more stable
  repeatable builds, but at the cost of using an outdated (possibly vulnerable)
  package. This should be used as a temporary fix for breakages in upstream pip,
  or in conjunction with a regular process to update the version pin.
  *Note*: This relies on an [unstable tox plugin interface](
  https://tox.readthedocs.io/en/latest/plugins.html#tox.hookspecs.tox_testenv_create).
  You may experience breakage with new tox versions. If you do, please feel
  free to [report the issue](https://github.com/pglass/tox-pip-version/issues/new)
  on Github.

  Install the package and include `pip_version` in your tox.ini
  ```tox
  [testenv]
  pip_version = pip==19.0.1
  ```
  Or, set the `TOX_PIP_VERSION` environment variable,
  ```bash
  export TOX_PIP_VERSION=18.1
  tox
  ```
  The plugin will install that version of pip into the tox-created virtualenv,
  just after tox creates the virtualenv, but before dependencies are installed.
  The `pip_version` within tox.ini, if present, is always used over the
  environment variable.
  If neither `pip_version` or `TOX_PIP_VERSION` is present, the plugin does
  nothing.

  Version sets/ranges are supported, enabling installation of a version of pip
  matching a set of specifiers. There are two basic formats: a plain version
  number, or the package name with optional [PEP440-compatible](
  https://www.python.org/dev/peps/pep-0440/#version-specifiers) version
  specifiers.
  | tox.ini                      | effective pip command        |
  | ---------------------------- | ---------------------------- |
  | `pip_version = 19.0`         | `pip install -U pip==19.0`   |
  | `pip_version = pip==19.0`    | `pip install -U pip==19.0`   |
  | `pip_version = pip>=19.0`    | `pip install -U pip>=19.0`   |
  | `pip_version = pip!=19,>18`  | `pip install -U pip!=19,>18` |
  | `pip_version = pip`          | `pip install -U pip`         |

  Use `make test` to run the tests, which includes linting and functional tests.
  Each of the `tests/*` directories is a "feature" that needs testing. Each
  feature sub-directory contains a tox.ini file that sets pip version in a
  particular way, and then uses a tox command to check the correct pip version
  was installed.


pkgId: 84e1e2218cef87898ed83c8cd87916ba1869b11be63b7dc0313d0a014f93cdad
name: python-tqdm
arch: src
version: 4.65.0
epoch: 0
release: 1
summary: Fast, Extensible Progress Meter
url: https://tqdm.github.io
rpm_license: MPLv2.0, MIT Licences
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f68b00d-edab-4e56-9e1b-3eb3515a89d0
location_href: 00005324-python-tqdm/python-tqdm-4.65.0-1.src.rpm
checksum_type: sha256
description:
  |Py-Versions| |Versions| |Conda-Forge-Status| |Docker| |Snapcraft|
  |Build-Status| |Coverage-Status| |Branch-Coverage-Status| |Codacy-Grade| |Libraries-Rank| |PyPI-Downloads|
  |LICENCE| |OpenHub-Status| |binder-demo| |awesome-python|
  ``tqdm`` derives from the Arabic word *taqaddum* (تقدّم) which can mean "progress,"
  and is an abbreviation for "I love you so much" in Spanish (*te quiero demasiado*).
  Instantly make your loops show a smart progress meter - just wrap any
  iterable with ``tqdm(iterable)``, and you're done!
      from tqdm import tqdm
      for i in tqdm(range(10000)):
  ``76%|████████████████████████        | 7568/10000 [00:33<00:10, 229.00it/s]``
  ``trange(N)`` can be also used as a convenient shortcut for
  ``tqdm(range(N))``.
  |Screenshot|
      |Video| |Slides| |Merch|
  It can also be executed as a module with pipes:
      $ seq 9999999 | tqdm --bytes | wc -l
      75.2MB [00:00, 217MB/s]
      9999999
      $ tar -zcf - docs/ | tqdm --bytes --total `du -sb docs/ | cut -f1` \
          > backup.tgz
       32%|██████████▍                      | 8.89G/27.9G [00:42<01:31, 223MB/s]
  Overhead is low -- about 60ns per iteration (80ns with ``tqdm.gui``), and is
  unit tested against performance regression.
  By comparison, the well-established
  `ProgressBar <https://github.com/niltonvolpato/python-progressbar>`__ has
  an 800ns/iter overhead.
  In addition to its low overhead, ``tqdm`` uses smart algorithms to predict
  the remaining time and to skip unnecessary iteration displays, which allows
  for a negligible overhead in most cases.
  ``tqdm`` works on any platform
  (Linux, Windows, Mac, FreeBSD, NetBSD, Solaris/SunOS),
  in any console or in a GUI, and is also friendly with IPython/Jupyter notebooks.
  ``tqdm`` does not require any dependencies (not even ``curses``!), just
  Python and an environment supporting ``carriage return \r`` and


pkgId: 416727bb22ba08cf4f4e542730d76fddc0d87acf8269b2947faab4c53d52851a
name: python-traceback2
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Backports of the traceback module
url: https://github.com/testing-cabal/traceback2
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d7ce1394-c84b-465f-b561-1641a253f601
location_href: 00009724-python-traceback2/python-traceback2-1.4.0-1.src.rpm
checksum_type: sha256
description:
  A backport of traceback to older supported Pythons.

   >>> import traceback2 as traceback

  Profit.

  Things to be aware of!

  In Python 2.x, unlike traceback, traceback2 creates unicode output (because it
  depends on the linecache2 module).

  Exception frame clearing silently does nothing if the interpreter in use does
  not support it.

  traceback2._some_str, which while not an official API is so old its likely in
  use behaves similarly to the Python3 version - objects where unicode(obj) fails
  but str(object) works will be shown as b'thestrvaluerepr'.


pkgId: 8fabe9e2d1db24528596733fb09bf313c75f006b8ccf23f87129381c3c423d9f
name: python-tracer
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Centralized sys.settrace management
url: https://pypi.org/project/tracer/
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e00657a-c693-458f-89e5-ffa8fc6547fe
location_href: 00005325-python-tracer/python-tracer-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Centralized Trace management using sys.settrace.

  We allow several trace hooks to get registered and unregistered and
  allow tracing to be turned on and off temporarily without losing the
  trace hooks. You can also indicate filters on events for which trace
  hooks should fire and mark methods that should automatically be
  ignored.


pkgId: f1ff3c5c66ab252bb0c8a9c16eac839bd5ed9ed2f6c15c4c7ead5b4cd819f40e
name: python-tracers
arch: src
version: 21.8.6876
epoch: 0
release: 1
url: https://github.com/fluidattacks/tracers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2b4a4cf8-4a86-4ba4-a170-912aff55539d
location_href: 00010743-python-tracers/python-tracers-21.8.6876-1.src.rpm
checksum_type: sha256
summary:
  Open-Source APM (Application monitoring) project that offers you minimal overhead wrappers for profiling your code execution flow

description:
  +++ b/examples/with_tracers.py
  @@ -1,15 +1,18 @@
   import time
   from dateutil.parser import parse
  +from tracers.function import trace
  +@trace()
   def example():
       time.sleep(2.0)
       your_business_logic('Sat Oct 11')
  +@trace()
   def your_business_logic(date: str):
       parse(date)
       time.sleep(1.0)
   example()
  ```
  If you run it, all the functions you decorated will be traced
  and you'll have metrics of the execution flow:
  ```
  🛈  Finished transaction: 3.00 seconds
       
       1     0.00s     2.00s [ 66.7%]     3.00s [100.0%]    ✓ example
       2     2.00s     1.00s [ 33.3%]     1.00s [ 33.3%]    ¦   ✓ your_business_logic
             Count                Net              Total    Function
                 1     2.00s [ 66.7%]     3.00s [100.0%]    ✓ example
                 1     1.00s [ 33.3%]     1.00s [ 33.3%]    ✓ your_business_logic
  ```
  From the output you can conclude:
  - executing function *example* took a total of *3.0* seconds to complete
  - function *example* takes *66.7%* of the execution time
  - function *example encloses *100%* of your code time
  - function *example* called function: *your_business_logic*
  - function *your_business_logic* took *1.0* seconds out of the *3.0* seconds
    the function *example* needed to complete
  - function *your_business_logic* represents *33.3%* of your execution time
  Tracing code is not limited to your own code.
  You can trace any **callable object** including **third party packages**,
  **Python's standard library**, and almost anything
  The level of detail is up to you!


pkgId: cc916a5ba229f9ecad2e95f1ed8f514b5c9cb4cf85c317488e5a30f750076095
name: python-trademgen
arch: src
version: 1.0.6.post1
epoch: 0
release: 1
summary: Simple Python wrapper for AirInv
url: https://github.com/airsim/airinv
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f492f4a-2777-4913-bc81-24687687f410
location_href: 00005326-python-trademgen/python-trademgen-1.0.6.post1-1.src.rpm
checksum_type: sha256
description:
  TraDemGen aims at providing a clean API, and the corresponding
  C++ implementation, able to generate demand for travel solutions
  (_e.g._, from JFK to PEK on 25-05-2019) according to characteristics
  (_e.g._, Willingness-To-Pay, preferred airline, etc).
  TraDemGen makes an extensive use of existing open-source libraries for
  increased functionality, speed and accuracy. In particular the
  Boost (C++ Standard Extensions: https://www.boost.org) library is used.
  TraDemGen is the one of the components of the Travel Market Simulator
  (https://travel-sim.org). However, it may be used in a
  stand-alone mode.


  Just use DNF (or Yum on older distributions):
  ```bash
  $ dnf -y install trademgen-devel trademgen-doc
  ```
  You can also get the RPM packages (which may work on Linux
  distributions like Suse and Mandriva) from the Fedora repository
  (_e.g._, for Fedora 32,
  https://fr2.rpmfind.net/linux/RPM/fedora/32/x86_64/)

  The Git repository may be cloned as following:
  ```bash
  $ git clone git@github.com:airsim/trademgen.git trademgengit # through SSH
  $ git clone https://github.com/airsim/trademgen.git # if the firewall filters SSH
  $ cd trademgengit
  ```
  Then, you need the following packages (Fedora/RedHat/CentOS names here,
  but names may vary according to distributions):
  * cmake
  * gcc-c++
  * boost-devel / libboost-dev
  * python-devel / python-dev
  * gettext-devel / gettext-dev
  * sqlite3-devel / libsqlite3-dev
  * readline-devel / readline-dev
  * ncurses-devel
  * soci-mysql-devel, soci-sqlite3-devel
  * stdair-devel / libstdair-dev
  * sevmgr-devel / libsevmgr-dev
  * doxygen, ghostscript, graphviz
  * tetex-latex (optional)
  * rpm-build (optional)

  The latest stable source tarball (`trademgen*.tar.gz` or `.bz2`) can be
  found on GitHub: https://github.com/airsim/trademgen/tags, _e.g._,
  https://github.com/airsim/trademgen/archive/trademgen-1.00.6.tar.gz
  As TraDemGen depends on other
  [Travel Market Simulator (TvlSim/AirSim)](https://github.com/airsim/)
  modules, more specifically [StdAir](https://github.com/airsim/stdair)
  and [SEvMgr](https://github.com/airsim/sevmgr), it may be
  convenient to use the
  [MetaSim project](https://github.com/airsim/metasim),
  which pulls at once all the components of TvlSim in the same place,
  and then orchestrates the dependencies for the builds, installations
  and use of components.
  If MetaSim is not used, in order to customise the following to your
  environment, you can alter the path to the installation directory:
  ```bash
  export INSTALL_BASEDIR="/home/user/dev/deliveries"
  export TDG_VER="1.00.6"
  if [ -d /usr/lib64 ]; then LIBSUFFIX="64"; fi
  export LIBSUFFIX_4_CMAKE="-DLIB_SUFFIX=${LIBSUFFIX}"
  ```
  Then, as usual:
  * To configure the project, type something like:
  ```bash
    mkdir build && cd build
    cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_BASEDIR}/trademgen-$TDG_VER \
     -DWITH_SEVMGR_PREFIX=${INSTALL_BASEDIR}/sevmgr-stable \
     -DWITH_STDAIR_PREFIX=${INSTALL_BASEDIR}/stdair-stable \
     -DCMAKE_BUILD_TYPE:STRING=Debug -DENABLE_TEST:BOOL=ON \
     -DINSTALL_DOC:BOOL=ON -DRUN_GCOV:BOOL=OFF ${LIBSUFFIX_4_CMAKE} ..
  ```
  * To build the project, type:
  ```bash
    make
  ```
  * To test the project, type:
  ```bash
    make check
  ```
  * To install the library (`libtrademgen*.so*`) and the binary (trademgen),
    just type:
  ```bash
    make install
    cd ${INSTALL_BASEDIR}
    rm -f trademgen-stable && ln -s trademgen-${TDG_VER} trademgen-stable
    cd -
  ```
  * To package the source files, type:
  ```bash
    make dist
  ```
  * To package the binary and the (HTML and PDF) documentation:
  ```bash
    make package
  ```
  * To browse the (just installed, if enabled) HTML documentation:
  ```bash
    midori file://${INSTALL_BASEDIR}/trademgen-$TDG_VER/share/doc/trademgen/html/index.html
  ```
  * To browse the (just installed, if enabled) PDF documentation:
  ```bash
    evince ${INSTALL_BASEDIR}/trademgen-$TDG_VER/share/doc/trademgen/html/refman.pdf
  ```
  * To run the local binary version:
  ```bash
    ./trademgen/trademgen -b
  ```
  * To run the installed version:
  ```bash
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen -b
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/pytrademgen
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen_generateDemand
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen_extractBookingRequests
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen_drawBookingArrivals
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen_with_db
  ```

  The way to interact with a C++-based Python extension is extensively described
  in the [OpenTREP project](https://github.com/trep/opentrep).
  Only a quick start is given here.

  * Install Python dependencies:
  ```bash
  $ python3 -m pip install -U pip
  $ python3 -m pip install -U wheel
  $ python3 -m pip install -U build setuptools scikit-build tox pytest sphinx twine
  ```

  * Build the Python extension with SciKit-Build:
  ```bash
  $ rm -rf _skbuild/ dist/ MANIFEST_
  $ python3 setup.py --build-type=Debug build sdist bdist_wheel
  ```
  * The Python artifacts should be similar to:
  ```bash
  $ ls -lFh dist/
  total 5872
  -rw-r--r-- 1 user staff 2.0M Jun  1 15:49 rmol-1.0.5.post1-cp38-cp38-macosx_10_15_x86_64.whl
  -rw-r--r-- 1 user staff 834K Jun  1 15:49 rmol-1.0.5.post1.tar.gz
  ```
  * Updload the RMOL Python extension onto PyPi:
  ```bash
  $ twine upload -u __token__ --repository-url https://upload.pypi.org/legacy/ dist/*
  ```
  * The RMOL Python artifacts may then be browsed on PyyPI:
    https://pypi.org/project/rmol/

  * Launch the Python interpreter:
  ```bash
  $ export PYTHONPATH=${PWD}/_skbuild/macosx-10.15-x86_64-3.8/cmake-install/lib:${PWD}/_skbuild/macosx-10.15-x86_64-3.8/cmake-install/lib/python3.8/site-packages/pyrmol
  $ DYLD_INSERT_LIBRARIES=/Library/Developer/CommandLineTools/usr/lib/clang/11.0.0/lib/darwin/libclang_rt.asan_osx_dynamic.dylib ASAN_OPTIONS=detect_container_overflow=0 /usr/local/Cellar/python@3.8/3.8.3/Frameworks/Python.framework/Versions/3.8/Resources/Python.app/Contents/MacOS/Python
  ```
  * Within the Python interpreter, import, initialize
    and use the RMOL Python extension:
  ```python
  Python 3.8.3 (default, May 27 2020, 20:54:22)
  [Clang 11.0.3 (clang-1103.0.32.59)] on darwin
  Type "help", "copyright", "credits" or "license" for more information.
  >>> import pyrmol
  >>> rmolLibrary = pyrmol.RMOLer()
  >>> rmolLibrary.init('rmol.log', 40, 1, '')
  True
  >>> rmolLibrary.rmol(100, 10, 40.0)
  'RMOL has completed the generation of the booking requests. See the log file for more details.\n'
  >>> quit()
  ```
  * Back to the Shell session, look for the results in the RMOL log file:
  ```bash
  $ cat rmol.log
  Python wrapper initialisation
  [D]${STDAIR_PREFIX}/stdair/command/CmdBomManager.cpp:52: StdAir is building the BOM tree from built-in specifications.
  Python wrapper initialised
  Optimisation for 100 draws, capacity of 40, and with the following method: 10
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:491: Optimisation by Monte-Carlo performed in 0.000321
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:492: Result:
  Yield: 100.00, Protection: 70.48, Booking limit: 100.00
  Yield: 70.00, Protection: 156.19, Booking limit: 29.52
  Yield: 42.00, Protection: -0.00, Booking limit: -56.19
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:505: Bid-Price Vector (BPV): 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 99.00, 99.00, 99.00, 99.00, 99.00, 98.00, 98.00, 97.00, 96.00, 96.00, 96.00, 96.00, 96.00, 95.00, 94.00, 94.00, 90.00, 90.00, 89.00, 88.00, 86.00, 84.00, 82.00, 80.00, 80.00, 79.00, 77.00, 76.00, 75.00, 72.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00
  End of the optimisation.
  RMOL output:
  ```
  * Of course, a few more features could be added to the Python extension API,
    in order not to have to leave the Python interpreter to interact with the
    results of invoking the optimizer. Do not hesitate to contribute
    through [Pull Requests](https://github.com/airsim/rmol/pulls), which are
    always welcome!


pkgId: 7d5ba318f38e860227246b53914980347a47ca477f7eac622abb20d3531c5812
name: python-trafaret
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Validation and parsing library
url: https://github.com/Deepwalker/trafaret/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f141ae3-65df-41dc-a929-fa91607be732
location_href: 00010597-python-trafaret/python-trafaret-2.1.1-1.src.rpm
checksum_type: sha256
description:
  |circleci_build| |gitter_chat| |pypi_version| |pypi_license|
  Ultimate transformation library that supports validation, contexts and ``aiohttp``.
  Trafaret is rigid and powerful lib to work with foreign data, configs etc.
  It provides simple way to check anything, and convert it accordingly to your needs.
  It has shortcut syntax and ability to express anything that you can code:
      >>> from trafaret.constructor import construct
      >>> validator = construct({'a': int, 'b': [str]})
      >>> validator({'a': 5, 'b': ['lorem', 'ipsum']})
      {'a': 5, 'b': ['lorem', 'ipsum']}
      >>> validator({'a': 5, 'b': ['gorky', 9]})
      Traceback (most recent call last):
        File "<console>", line 1, in <module>
        File "/Users/mkrivushin/w/trafaret/trafaret/__init__.py", line 204, in __call__
          return self.check(val)
        File "/Users/mkrivushin/w/trafaret/trafaret/__init__.py", line 144, in check
          return self._convert(self.check_and_return(value))
        File "/Users/mkrivushin/w/trafaret/trafaret/__init__.py", line 1105, in check_and_return
          raise DataError(error=errors, trafaret=self)
      trafaret.DataError: {'b': DataError({1: DataError(value is not a string)})}
  Read The Docs hosted documentation http://trafaret.readthedocs.org/en/latest/
  or look to the `docs/intro.rst`_ for start.
  Trafaret can even generate Trafarets instances to build transformators from json,
  like in json schema implementation `Trafaret Schema <https://github.com/Deepwalker/trafaret_schema>`_


pkgId: daf85e9c62e159eab31b5bf7daf490856b2960a1aab2185684d0905cda7159b9
name: python-trafilatura
arch: src
version: 1.5.0
epoch: 0
release: 1
description:
  |
  |

url: https://trafilatura.readthedocs.io
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-96e13293-7830-4a3c-94a8-92fee2494c7e
location_href: 00012085-python-trafilatura/python-trafilatura-1.5.0-1.src.rpm
checksum_type: sha256
summary:
  Python package and command-line tool designed to gather text on the Web. It includes discovery, extraction and text processing components. Its main applications are web crawling, downloads, scraping, and extraction of main texts, metadata and comments.


pkgId: f0109231793793bdf136f3d408a54d4eb6b1d7abf9c369418f48e9446857d472
name: python-traits-debuginfo
arch: x86_64
version: 6.4.1
epoch: 0
release: 1
summary: Debug information for package python-traits
url: http://docs.enthought.com/traits
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-31e31df7-86a9-4f73-8e63-5a817c3b3a09
rpm_sourcerpm: python-traits-6.4.1-1.src.rpm
location_href: 00002888-python-Traits/python-traits-debuginfo-6.4.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-traits.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1a3eb9a9cdedbc1e4103bcf38982649c413a8b379374ad2d4e36a1f2ee3a1f81
name: python-traits-debugsource
arch: x86_64
version: 6.4.1
epoch: 0
release: 1
summary: Debug sources for package python-traits
url: http://docs.enthought.com/traits
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-31e31df7-86a9-4f73-8e63-5a817c3b3a09
rpm_sourcerpm: python-traits-6.4.1-1.src.rpm
location_href: 00002888-python-Traits/python-traits-debugsource-6.4.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-traits.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: c88c3d8e170db4e3be26cfa762669a94b7795dea13ded72921050af59565a9d2
name: python-transformers
arch: src
version: 4.27.4
epoch: 0
release: 1
summary: State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow
url: https://github.com/huggingface/transformers
rpm_license: Apache 2.0 License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ca007bfd-d138-4764-a0d1-5a20236c08d4
location_href: 00009242-python-transformers/python-transformers-4.27.4-1.src.rpm
checksum_type: sha256
description:
  <!---
  Copyright 2020 The HuggingFace Team. All rights reserved.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  -->

  <p align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-dark.svg">
      <source media="(prefers-color-scheme: light)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-light.svg">
      <img alt="Hugging Face Transformers Library" src="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-light.svg" width="352" height="59" style="max-width: 100%;">
    </picture>
    <br/>
    <br/>
  </p>

  <p align="center">
      <a href="https://circleci.com/gh/huggingface/transformers">
          <img alt="Build" src="https://img.shields.io/circleci/build/github/huggingface/transformers/main">
      </a>
      <a href="https://github.com/huggingface/transformers/blob/main/LICENSE">
          <img alt="GitHub" src="https://img.shields.io/github/license/huggingface/transformers.svg?color=blue">
      </a>
      <a href="https://huggingface.co/docs/transformers/index">
          <img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/transformers/index.svg?down_color=red&down_message=offline&up_message=online">
      </a>
      <a href="https://github.com/huggingface/transformers/releases">
          <img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/transformers.svg">
      </a>
      <a href="https://github.com/huggingface/transformers/blob/main/CODE_OF_CONDUCT.md">
          <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg">
      </a>
      <a href="https://zenodo.org/badge/latestdoi/155220641"><img src="https://zenodo.org/badge/155220641.svg" alt="DOI"></a>
  </p>

  <h4 align="center">
      <p>
          <b>English</b> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_zh-hans.md">简体中文</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_zh-hant.md">繁體中文</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_ko.md">한국어</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_es.md">Español</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_ja.md">日本語</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_hd.md">हिन्दी</a>
      <p>
  </h4>

  <h3 align="center">
      <p>State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow</p>
  </h3>

  <h3 align="center">
      <a href="https://hf.co/course"><img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/course_banner.png"></a>
  </h3>

  🤗 Transformers provides thousands of pretrained models to perform tasks on different modalities such as text, vision, and audio.

  These models can be applied on:

  * 📝 Text, for tasks like text classification, information extraction, question answering, summarization, translation, text generation, in over 100 languages.
  * 🖼️ Images, for tasks like image classification, object detection, and segmentation.
  * 🗣️ Audio, for tasks like speech recognition and audio classification.

  Transformer models can also perform tasks on **several modalities combined**, such as table question answering, optical character recognition, information extraction from scanned documents, video classification, and visual question answering.

  🤗 Transformers provides APIs to quickly download and use those pretrained models on a given text, fine-tune them on your own datasets and then share them with the community on our [model hub](https://huggingface.co/models). At the same time, each python module defining an architecture is fully standalone and can be modified to enable quick research experiments.

  🤗 Transformers is backed by the three most popular deep learning libraries — [Jax](https://jax.readthedocs.io/en/latest/), [PyTorch](https://pytorch.org/) and [TensorFlow](https://www.tensorflow.org/) — with a seamless integration between them. It's straightforward to train your models with one before loading them for inference with the other.



  You can test most of our models directly on their pages from the [model hub](https://huggingface.co/models). We also offer [private model hosting, versioning, & an inference API](https://huggingface.co/pricing) for public and private models.

  Here are a few examples:

   In Natural Language Processing:
  - [Masked word completion with BERT](https://huggingface.co/bert-base-uncased?text=Paris+is+the+%5BMASK%5D+of+France)
  - [Name Entity Recognition with Electra](https://huggingface.co/dbmdz/electra-large-discriminator-finetuned-conll03-english?text=My+name+is+Sarah+and+I+live+in+London+city)
  - [Text generation with GPT-2](https://huggingface.co/gpt2?text=A+long+time+ago%2C+)
  - [Natural Language Inference with RoBERTa](https://huggingface.co/roberta-large-mnli?text=The+dog+was+lost.+Nobody+lost+any+animal)
  - [Summarization with BART](https://huggingface.co/facebook/bart-large-cnn?text=The+tower+is+324+metres+%281%2C063+ft%29+tall%2C+about+the+same+height+as+an+81-storey+building%2C+and+the+tallest+structure+in+Paris.+Its+base+is+square%2C+measuring+125+metres+%28410+ft%29+on+each+side.+During+its+construction%2C+the+Eiffel+Tower+surpassed+the+Washington+Monument+to+become+the+tallest+man-made+structure+in+the+world%2C+a+title+it+held+for+41+years+until+the+Chrysler+Building+in+New+York+City+was+finished+in+1930.+It+was+the+first+structure+to+reach+a+height+of+300+metres.+Due+to+the+addition+of+a+broadcasting+aerial+at+the+top+of+the+tower+in+1957%2C+it+is+now+taller+than+the+Chrysler+Building+by+5.2+metres+%2817+ft%29.+Excluding+transmitters%2C+the+Eiffel+Tower+is+the+second+tallest+free-standing+structure+in+France+after+the+Millau+Viaduct)
  - [Question answering with DistilBERT](https://huggingface.co/distilbert-base-uncased-distilled-squad?text=Which+name+is+also+used+to+describe+the+Amazon+rainforest+in+English%3F&context=The+Amazon+rainforest+%28Portuguese%3A+Floresta+Amaz%C3%B4nica+or+Amaz%C3%B4nia%3B+Spanish%3A+Selva+Amaz%C3%B3nica%2C+Amazon%C3%ADa+or+usually+Amazonia%3B+French%3A+For%C3%AAt+amazonienne%3B+Dutch%3A+Amazoneregenwoud%29%2C+also+known+in+English+as+Amazonia+or+the+Amazon+Jungle%2C+is+a+moist+broadleaf+forest+that+covers+most+of+the+Amazon+basin+of+South+America.+This+basin+encompasses+7%2C000%2C000+square+kilometres+%282%2C700%2C000+sq+mi%29%2C+of+which+5%2C500%2C000+square+kilometres+%282%2C100%2C000+sq+mi%29+are+covered+by+the+rainforest.+This+region+includes+territory+belonging+to+nine+nations.+The+majority+of+the+forest+is+contained+within+Brazil%2C+with+60%25+of+the+rainforest%2C+followed+by+Peru+with+13%25%2C+Colombia+with+10%25%2C+and+with+minor+amounts+in+Venezuela%2C+Ecuador%2C+Bolivia%2C+Guyana%2C+Suriname+and+French+Guiana.+States+or+departments+in+four+nations+contain+%22Amazonas%22+in+their+names.+The+Amazon+represents+over+half+of+the+planet%27s+remaining+rainforests%2C+and+comprises+the+largest+and+most+biodiverse+tract+of+tropical+rainforest+in+the+world%2C+with+an+estimated+390+billion+individual+trees+divided+into+16%2C000+species)
  - [Translation with T5](https://huggingface.co/t5-base?text=My+name+is+Wolfgang+and+I+live+in+Berlin)

  In Computer Vision:
  - [Image classification with ViT](https://huggingface.co/google/vit-base-patch16-224)
  - [Object Detection with DETR](https://huggingface.co/facebook/detr-resnet-50)
  - [Semantic Segmentation with SegFormer](https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512)
  - [Panoptic Segmentation with MaskFormer](https://huggingface.co/facebook/maskformer-swin-small-coco)
  - [Depth Estimation with DPT](https://huggingface.co/docs/transformers/model_doc/dpt)
  - [Video Classification with VideoMAE](https://huggingface.co/docs/transformers/model_doc/videomae)
  - [Universal Segmentation with OneFormer](https://huggingface.co/shi-labs/oneformer_ade20k_dinat_large)

  In Audio:
  - [Automatic Speech Recognition with Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base-960h)
  - [Keyword Spotting with Wav2Vec2](https://huggingface.co/superb/wav2vec2-base-superb-ks)
  - [Audio Classification with Audio Spectrogram Transformer](https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593)

  In Multimodal tasks:
  - [Table Question Answering with TAPAS](https://huggingface.co/google/tapas-base-finetuned-wtq)
  - [Visual Question Answering with ViLT](https://huggingface.co/dandelin/vilt-b32-finetuned-vqa)
  - [Zero-shot Image Classification with CLIP](https://huggingface.co/openai/clip-vit-large-patch14)
  - [Document Question Answering with LayoutLM](https://huggingface.co/impira/layoutlm-document-qa)
  - [Zero-shot Video Classification with X-CLIP](https://huggingface.co/docs/transformers/model_doc/xclip)

  **[Write With Transformer](https://transformer.huggingface.co)**, built by the Hugging Face team, is the official demo of this repo’s text generation capabilities.



  <a target="_blank" href="https://huggingface.co/support">
      <img alt="HuggingFace Expert Acceleration Program" src="https://cdn-media.huggingface.co/marketing/transformers/new-support-improved.png" style="max-width: 600px; border: 1px solid #eee; border-radius: 4px; box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);">
  </a><br>



  To immediately use a model on a given input (text, image, audio, ...), we provide the `pipeline` API. Pipelines group together a pretrained model with the preprocessing that was used during that model's training. Here is how to quickly use a pipeline to classify positive versus negative texts:

  ```python
  >>> from transformers import pipeline


  >>> classifier = pipeline('sentiment-analysis')
  >>> classifier('We are very happy to introduce pipeline to the transformers repository.')
  [{'label': 'POSITIVE', 'score': 0.9996980428695679}]
  ```

  The second line of code downloads and caches the pretrained model used by the pipeline, while the third evaluates it on the given text. Here the answer is "positive" with a confidence of 99.97%.

  Many tasks have a pre-trained `pipeline` ready to go, in NLP but also in computer vision and speech. For example, we can easily extract detected objects in an image:

  ``` python
  >>> import requests
  >>> from PIL import Image
  >>> from transformers import pipeline


  >>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png"
  >>> image_data = requests.get(url, stream=True).raw
  >>> image = Image.open(image_data)


  >>> object_detector = pipeline('object-detection')
  >>> object_detector(image)
  [{'score': 0.9982201457023621,
    'label': 'remote',
    'box': {'xmin': 40, 'ymin': 70, 'xmax': 175, 'ymax': 117}},
   {'score': 0.9960021376609802,
    'label': 'remote',
    'box': {'xmin': 333, 'ymin': 72, 'xmax': 368, 'ymax': 187}},
   {'score': 0.9954745173454285,
    'label': 'couch',
    'box': {'xmin': 0, 'ymin': 1, 'xmax': 639, 'ymax': 473}},
   {'score': 0.9988006353378296,
    'label': 'cat',
    'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
   {'score': 0.9986783862113953,
    'label': 'cat',
    'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}}]
  ```

  Here we get a list of objects detected in the image, with a box surrounding the object and a confidence score. Here is the original image on the left, with the predictions displayed on the right:

  <h3 align="center">
      <a><img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png" width="400"></a>
      <a><img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample_post_processed.png" width="400"></a>
  </h3>

  You can learn more about the tasks supported by the `pipeline` API in [this tutorial](https://huggingface.co/docs/transformers/task_summary).

  In addition to `pipeline`, to download and use any of the pretrained models on your given task, all it takes is three lines of code. Here is the PyTorch version:
  ```python
  >>> from transformers import AutoTokenizer, AutoModel

  >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
  >>> model = AutoModel.from_pretrained("bert-base-uncased")

  >>> inputs = tokenizer("Hello world!", return_tensors="pt")
  >>> outputs = model(**inputs)
  ```

  And here is the equivalent code for TensorFlow:
  ```python
  >>> from transformers import AutoTokenizer, TFAutoModel

  >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
  >>> model = TFAutoModel.from_pretrained("bert-base-uncased")

  >>> inputs = tokenizer("Hello world!", return_tensors="tf")
  >>> outputs = model(**inputs)
  ```

  The tokenizer is responsible for all the preprocessing the pretrained model expects, and can be called directly on a single string (as in the above examples) or a list. It will output a dictionary that you can use in downstream code or simply directly pass to your model using the ** argument unpacking operator.

  The model itself is a regular [Pytorch `nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) or a [TensorFlow `tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model) (depending on your backend) which you can use as usual. [This tutorial](https://huggingface.co/docs/transformers/training) explains how to integrate such a model into a classic PyTorch or TensorFlow training loop, or how to use our `Trainer` API to quickly fine-tune on a new dataset.



  1. Easy-to-use state-of-the-art models:
      - High performance on natural language understanding & generation, computer vision, and audio tasks.
      - Low barrier to entry for educators and practitioners.
      - Few user-facing abstractions with just three classes to learn.
      - A unified API for using all our pretrained models.

  1. Lower compute costs, smaller carbon footprint:
      - Researchers can share trained models instead of always retraining.
      - Practitioners can reduce compute time and production costs.
      - Dozens of architectures with over 60,000 pretrained models across all modalities.

  1. Choose the right framework for every part of a model's lifetime:
      - Train state-of-the-art models in 3 lines of code.
      - Move a single model between TF2.0/PyTorch/JAX frameworks at will.
      - Seamlessly pick the right framework for training, evaluation and production.

  1. Easily customize a model or an example to your needs:
      - We provide examples for each architecture to reproduce the results published by its original authors.
      - Model internals are exposed as consistently as possible.
      - Model files can be used independently of the library for quick experiments.



  - This library is not a modular toolbox of building blocks for neural nets. The code in the model files is not refactored with additional abstractions on purpose, so that researchers can quickly iterate on each of the models without diving into additional abstractions/files.
  - The training API is not intended to work on any model but is optimized to work with the models provided by the library. For generic machine learning loops, you should use another library (possibly, [Accelerate](https://huggingface.co/docs/accelerate)).
  - While we strive to present as many use cases as possible, the scripts in our [examples folder](https://github.com/huggingface/transformers/tree/main/examples) are just that: examples. It is expected that they won't work out-of-the box on your specific problem and that you will be required to change a few lines of code to adapt them to your needs.





  This repository is tested on Python 3.6+, Flax 0.3.2+, PyTorch 1.3.1+ and TensorFlow 2.3+.

  You should install 🤗 Transformers in a [virtual environment](https://docs.python.org/3/library/venv.html). If you're unfamiliar with Python virtual environments, check out the [user guide](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).

  First, create a virtual environment with the version of Python you're going to use and activate it.

  Then, you will need to install at least one of Flax, PyTorch or TensorFlow.
  Please refer to [TensorFlow installation page](https://www.tensorflow.org/install/), [PyTorch installation page](https://pytorch.org/get-started/locally/#start-locally) and/or [Flax](https://github.com/google/flax#quick-install) and [Jax](https://github.com/google/jax#installation) installation pages regarding the specific installation command for your platform.

  When one of those backends has been installed, 🤗 Transformers can be installed using pip as follows:

  ```bash
  pip install transformers
  ```

  If you'd like to play with the examples or need the bleeding edge of the code and can't wait for a new release, you must [install the library from source](https://huggingface.co/docs/transformers/installation#installing-from-source).



  Since Transformers version v4.0.0, we now have a conda channel: `huggingface`.

  🤗 Transformers can be installed using conda as follows:

  ```shell script
  conda install -c huggingface transformers
  ```

  Follow the installation pages of Flax, PyTorch or TensorFlow to see how to install them with conda.

  > **_NOTE:_**  On Windows, you may be prompted to activate Developer Mode in order to benefit from caching. If this is not an option for you, please let us know in [this issue](https://github.com/huggingface/huggingface_hub/issues/1062).



  **[All the model checkpoints](https://huggingface.co/models)** provided by 🤗 Transformers are seamlessly integrated from the huggingface.co [model hub](https://huggingface.co/models) where they are uploaded directly by [users](https://huggingface.co/users) and [organizations](https://huggingface.co/organizations).

  Current number of checkpoints: ![](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/models&color=brightgreen)

  🤗 Transformers currently provides the following architectures (see [here](https://huggingface.co/docs/transformers/model_summary) for a high-level summary of each them):

  1. **[ALBERT](https://huggingface.co/docs/transformers/model_doc/albert)** (from Google Research and the Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.
  1. **[ALIGN](https://huggingface.co/docs/transformers/model_doc/align)** (from Google Research) released with the paper [Scaling Up Visual and Vision-Language Representation Learning With Noisy Text Supervision](https://arxiv.org/abs/2102.05918) by Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V. Le, Yunhsuan Sung, Zhen Li, Tom Duerig.
  1. **[AltCLIP](https://huggingface.co/docs/transformers/model_doc/altclip)** (from BAAI) released with the paper [AltCLIP: Altering the Language Encoder in CLIP for Extended Language Capabilities](https://arxiv.org/abs/2211.06679) by Chen, Zhongzhi and Liu, Guang and Zhang, Bo-Wen and Ye, Fulong and Yang, Qinghong and Wu, Ledell.
  1. **[Audio Spectrogram Transformer](https://huggingface.co/docs/transformers/model_doc/audio-spectrogram-transformer)** (from MIT) released with the paper [AST: Audio Spectrogram Transformer](https://arxiv.org/abs/2104.01778) by Yuan Gong, Yu-An Chung, James Glass.
  1. **[BART](https://huggingface.co/docs/transformers/model_doc/bart)** (from Facebook) released with the paper [BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension](https://arxiv.org/abs/1910.13461) by Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov and Luke Zettlemoyer.
  1. **[BARThez](https://huggingface.co/docs/transformers/model_doc/barthez)** (from École polytechnique) released with the paper [BARThez: a Skilled Pretrained French Sequence-to-Sequence Model](https://arxiv.org/abs/2010.12321) by Moussa Kamal Eddine, Antoine J.-P. Tixier, Michalis Vazirgiannis.
  1. **[BARTpho](https://huggingface.co/docs/transformers/model_doc/bartpho)** (from VinAI Research) released with the paper [BARTpho: Pre-trained Sequence-to-Sequence Models for Vietnamese](https://arxiv.org/abs/2109.09701) by Nguyen Luong Tran, Duong Minh Le and Dat Quoc Nguyen.
  1. **[BEiT](https://huggingface.co/docs/transformers/model_doc/beit)** (from Microsoft) released with the paper [BEiT: BERT Pre-Training of Image Transformers](https://arxiv.org/abs/2106.08254) by Hangbo Bao, Li Dong, Furu Wei.
  1. **[BERT](https://huggingface.co/docs/transformers/model_doc/bert)** (from Google) released with the paper [BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding](https://arxiv.org/abs/1810.04805) by Jacob Devlin, Ming-Wei Chang, Kenton Lee and Kristina Toutanova.
  1. **[BERT For Sequence Generation](https://huggingface.co/docs/transformers/model_doc/bert-generation)** (from Google) released with the paper [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
  1. **[BERTweet](https://huggingface.co/docs/transformers/model_doc/bertweet)** (from VinAI Research) released with the paper [BERTweet: A pre-trained language model for English Tweets](https://aclanthology.org/2020.emnlp-demos.2/) by Dat Quoc Nguyen, Thanh Vu and Anh Tuan Nguyen.
  1. **[BigBird-Pegasus](https://huggingface.co/docs/transformers/model_doc/bigbird_pegasus)** (from Google Research) released with the paper [Big Bird: Transformers for Longer Sequences](https://arxiv.org/abs/2007.14062) by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.
  1. **[BigBird-RoBERTa](https://huggingface.co/docs/transformers/model_doc/big_bird)** (from Google Research) released with the paper [Big Bird: Transformers for Longer Sequences](https://arxiv.org/abs/2007.14062) by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.
  1. **[BioGpt](https://huggingface.co/docs/transformers/model_doc/biogpt)** (from Microsoft Research AI4Science) released with the paper [BioGPT: generative pre-trained transformer for biomedical text generation and mining](https://academic.oup.com/bib/advance-article/doi/10.1093/bib/bbac409/6713511?guestAccessKey=a66d9b5d-4f83-4017-bb52-405815c907b9) by Renqian Luo, Liai Sun, Yingce Xia, Tao Qin, Sheng Zhang, Hoifung Poon and Tie-Yan Liu.
  1. **[BiT](https://huggingface.co/docs/transformers/model_doc/bit)** (from Google AI) released with the paper [Big Transfer (BiT): General Visual Representation Learning](https://arxiv.org/abs/1912.11370) by Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Joan Puigcerver, Jessica Yung, Sylvain Gelly, Neil Houlsby.
  1. **[Blenderbot](https://huggingface.co/docs/transformers/model_doc/blenderbot)** (from Facebook) released with the paper [Recipes for building an open-domain chatbot](https://arxiv.org/abs/2004.13637) by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.
  1. **[BlenderbotSmall](https://huggingface.co/docs/transformers/model_doc/blenderbot-small)** (from Facebook) released with the paper [Recipes for building an open-domain chatbot](https://arxiv.org/abs/2004.13637) by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.
  1. **[BLIP](https://huggingface.co/docs/transformers/model_doc/blip)** (from Salesforce) released with the paper [BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation](https://arxiv.org/abs/2201.12086) by Junnan Li, Dongxu Li, Caiming Xiong, Steven Hoi.
  1. **[BLIP-2](https://huggingface.co/docs/transformers/model_doc/blip-2)** (from Salesforce) released with the paper [BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models](https://arxiv.org/abs/2301.12597) by Junnan Li, Dongxu Li, Silvio Savarese, Steven Hoi.
  1. **[BLOOM](https://huggingface.co/docs/transformers/model_doc/bloom)** (from BigScience workshop) released by the [BigScience Workshop](https://bigscience.huggingface.co/).
  1. **[BORT](https://huggingface.co/docs/transformers/model_doc/bort)** (from Alexa) released with the paper [Optimal Subarchitecture Extraction For BERT](https://arxiv.org/abs/2010.10499) by Adrian de Wynter and Daniel J. Perry.
  1. **[BridgeTower](https://huggingface.co/docs/transformers/model_doc/bridgetower)** (from Harbin Institute of Technology/Microsoft Research Asia/Intel Labs) released with the paper [BridgeTower: Building Bridges Between Encoders in Vision-Language Representation Learning](https://arxiv.org/abs/2206.08657) by Xiao Xu, Chenfei Wu, Shachar Rosenman, Vasudev Lal, Wanxiang Che, Nan Duan.
  1. **[ByT5](https://huggingface.co/docs/transformers/model_doc/byt5)** (from Google Research) released with the paper [ByT5: Towards a token-free future with pre-trained byte-to-byte models](https://arxiv.org/abs/2105.13626) by Linting Xue, Aditya Barua, Noah Constant, Rami Al-Rfou, Sharan Narang, Mihir Kale, Adam Roberts, Colin Raffel.
  1. **[CamemBERT](https://huggingface.co/docs/transformers/model_doc/camembert)** (from Inria/Facebook/Sorbonne) released with the paper [CamemBERT: a Tasty French Language Model](https://arxiv.org/abs/1911.03894) by Louis Martin*, Benjamin Muller*, Pedro Javier Ortiz Suárez*, Yoann Dupont, Laurent Romary, Éric Villemonte de la Clergerie, Djamé Seddah and Benoît Sagot.
  1. **[CANINE](https://huggingface.co/docs/transformers/model_doc/canine)** (from Google Research) released with the paper [CANINE: Pre-training an Efficient Tokenization-Free Encoder for Language Representation](https://arxiv.org/abs/2103.06874) by Jonathan H. Clark, Dan Garrette, Iulia Turc, John Wieting.
  1. **[Chinese-CLIP](https://huggingface.co/docs/transformers/model_doc/chinese_clip)** (from OFA-Sys) released with the paper [Chinese CLIP: Contrastive Vision-Language Pretraining in Chinese](https://arxiv.org/abs/2211.01335) by An Yang, Junshu Pan, Junyang Lin, Rui Men, Yichang Zhang, Jingren Zhou, Chang Zhou.
  1. **[CLAP](https://huggingface.co/docs/transformers/model_doc/clap)** (from LAION-AI) released with the paper [Large-scale Contrastive Language-Audio Pretraining with Feature Fusion and Keyword-to-Caption Augmentation]https://arxiv.org/abs/2211.06687) by Yusong Wu, Ke Chen, Tianyu Zhang, Yuchen Hui, Taylor Berg-Kirkpatrick, Shlomo Dubnov.
  1. **[CLIP](https://huggingface.co/docs/transformers/model_doc/clip)** (from OpenAI) released with the paper [Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/abs/2103.00020) by Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, Ilya Sutskever.
  1. **[CLIPSeg](https://huggingface.co/docs/transformers/model_doc/clipseg)** (from University of Göttingen) released with the paper [Image Segmentation Using Text and Image Prompts](https://arxiv.org/abs/2112.10003) by Timo Lüddecke and Alexander Ecker.
  1. **[CodeGen](https://huggingface.co/docs/transformers/model_doc/codegen)** (from Salesforce) released with the paper [A Conversational Paradigm for Program Synthesis](https://arxiv.org/abs/2203.13474) by Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, Caiming Xiong.
  1. **[Conditional DETR](https://huggingface.co/docs/transformers/model_doc/conditional_detr)** (from Microsoft Research Asia) released with the paper [Conditional DETR for Fast Training Convergence](https://arxiv.org/abs/2108.06152) by Depu Meng, Xiaokang Chen, Zejia Fan, Gang Zeng, Houqiang Li, Yuhui Yuan, Lei Sun, Jingdong Wang.
  1. **[ConvBERT](https://huggingface.co/docs/transformers/model_doc/convbert)** (from YituTech) released with the paper [ConvBERT: Improving BERT with Span-based Dynamic Convolution](https://arxiv.org/abs/2008.02496) by Zihang Jiang, Weihao Yu, Daquan Zhou, Yunpeng Chen, Jiashi Feng, Shuicheng Yan.
  1. **[ConvNeXT](https://huggingface.co/docs/transformers/model_doc/convnext)** (from Facebook AI) released with the paper [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545) by Zhuang Liu, Hanzi Mao, Chao-Yuan Wu, Christoph Feichtenhofer, Trevor Darrell, Saining Xie.
  1. **[ConvNeXTV2](https://huggingface.co/docs/transformers/model_doc/convnextv2)** (from Facebook AI) released with the paper [ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders](https://arxiv.org/abs/2301.00808) by Sanghyun Woo, Shoubhik Debnath, Ronghang Hu, Xinlei Chen, Zhuang Liu, In So Kweon, Saining Xie.
  1. **[CPM](https://huggingface.co/docs/transformers/model_doc/cpm)** (from Tsinghua University) released with the paper [CPM: A Large-scale Generative Chinese Pre-trained Language Model](https://arxiv.org/abs/2012.00413) by Zhengyan Zhang, Xu Han, Hao Zhou, Pei Ke, Yuxian Gu, Deming Ye, Yujia Qin, Yusheng Su, Haozhe Ji, Jian Guan, Fanchao Qi, Xiaozhi Wang, Yanan Zheng, Guoyang Zeng, Huanqi Cao, Shengqi Chen, Daixuan Li, Zhenbo Sun, Zhiyuan Liu, Minlie Huang, Wentao Han, Jie Tang, Juanzi Li, Xiaoyan Zhu, Maosong Sun.
  1. **[CTRL](https://huggingface.co/docs/transformers/model_doc/ctrl)** (from Salesforce) released with the paper [CTRL: A Conditional Transformer Language Model for Controllable Generation](https://arxiv.org/abs/1909.05858) by Nitish Shirish Keskar*, Bryan McCann*, Lav R. Varshney, Caiming Xiong and Richard Socher.
  1. **[CvT](https://huggingface.co/docs/transformers/model_doc/cvt)** (from Microsoft) released with the paper [CvT: Introducing Convolutions to Vision Transformers](https://arxiv.org/abs/2103.15808) by Haiping Wu, Bin Xiao, Noel Codella, Mengchen Liu, Xiyang Dai, Lu Yuan, Lei Zhang.
  1. **[Data2Vec](https://huggingface.co/docs/transformers/model_doc/data2vec)** (from Facebook) released with the paper [Data2Vec:  A General Framework for Self-supervised Learning in Speech, Vision and Language](https://arxiv.org/abs/2202.03555) by Alexei Baevski, Wei-Ning Hsu, Qiantong Xu, Arun Babu, Jiatao Gu, Michael Auli.
  1. **[DeBERTa](https://huggingface.co/docs/transformers/model_doc/deberta)** (from Microsoft) released with the paper [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.
  1. **[DeBERTa-v2](https://huggingface.co/docs/transformers/model_doc/deberta-v2)** (from Microsoft) released with the paper [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.
  1. **[Decision Transformer](https://huggingface.co/docs/transformers/model_doc/decision_transformer)** (from Berkeley/Facebook/Google) released with the paper [Decision Transformer: Reinforcement Learning via Sequence Modeling](https://arxiv.org/abs/2106.01345) by Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch.
  1. **[Deformable DETR](https://huggingface.co/docs/transformers/model_doc/deformable_detr)** (from SenseTime Research) released with the paper [Deformable DETR: Deformable Transformers for End-to-End Object Detection](https://arxiv.org/abs/2010.04159) by Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, Jifeng Dai.
  1. **[DeiT](https://huggingface.co/docs/transformers/model_doc/deit)** (from Facebook) released with the paper [Training data-efficient image transformers & distillation through attention](https://arxiv.org/abs/2012.12877) by Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, Hervé Jégou.
  1. **[DETA](https://huggingface.co/docs/transformers/model_doc/deta)** (from The University of Texas at Austin) released with the paper [NMS Strikes Back](https://arxiv.org/abs/2212.06137) by Jeffrey Ouyang-Zhang, Jang Hyun Cho, Xingyi Zhou, Philipp Krähenbühl.
  1. **[DETR](https://huggingface.co/docs/transformers/model_doc/detr)** (from Facebook) released with the paper [End-to-End Object Detection with Transformers](https://arxiv.org/abs/2005.12872) by Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, Sergey Zagoruyko.
  1. **[DialoGPT](https://huggingface.co/docs/transformers/model_doc/dialogpt)** (from Microsoft Research) released with the paper [DialoGPT: Large-Scale Generative Pre-training for Conversational Response Generation](https://arxiv.org/abs/1911.00536) by Yizhe Zhang, Siqi Sun, Michel Galley, Yen-Chun Chen, Chris Brockett, Xiang Gao, Jianfeng Gao, Jingjing Liu, Bill Dolan.
  1. **[DiNAT](https://huggingface.co/docs/transformers/model_doc/dinat)** (from SHI Labs) released with the paper [Dilated Neighborhood Attention Transformer](https://arxiv.org/abs/2209.15001) by Ali Hassani and Humphrey Shi.
  1. **[DistilBERT](https://huggingface.co/docs/transformers/model_doc/distilbert)** (from HuggingFace), released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same method has been applied to compress GPT2 into [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation), RoBERTa into [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation), Multilingual BERT into [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation) and a German version of DistilBERT.
  1. **[DiT](https://huggingface.co/docs/transformers/model_doc/dit)** (from Microsoft Research) released with the paper [DiT: Self-supervised Pre-training for Document Image Transformer](https://arxiv.org/abs/2203.02378) by Junlong Li, Yiheng Xu, Tengchao Lv, Lei Cui, Cha Zhang, Furu Wei.
  1. **[Donut](https://huggingface.co/docs/transformers/model_doc/donut)** (from NAVER), released together with the paper [OCR-free Document Understanding Transformer](https://arxiv.org/abs/2111.15664) by Geewook Kim, Teakgyu Hong, Moonbin Yim, Jeongyeon Nam, Jinyoung Park, Jinyeong Yim, Wonseok Hwang, Sangdoo Yun, Dongyoon Han, Seunghyun Park.
  1. **[DPR](https://huggingface.co/docs/transformers/model_doc/dpr)** (from Facebook) released with the paper [Dense Passage Retrieval for Open-Domain Question Answering](https://arxiv.org/abs/2004.04906) by Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih.
  1. **[DPT](https://huggingface.co/docs/transformers/master/model_doc/dpt)** (from Intel Labs) released with the paper [Vision Transformers for Dense Prediction](https://arxiv.org/abs/2103.13413) by René Ranftl, Alexey Bochkovskiy, Vladlen Koltun.
  1. **[EfficientFormer](https://huggingface.co/docs/transformers/model_doc/efficientformer)** (from Snap Research) released with the paper [EfficientFormer: Vision Transformers at MobileNetSpeed](https://arxiv.org/abs/2206.01191) by Yanyu Li, Geng Yuan, Yang Wen, Ju Hu, Georgios Evangelidis, Sergey Tulyakov, Yanzhi Wang, Jian Ren.
  1. **[EfficientNet](https://huggingface.co/docs/transformers/model_doc/efficientnet)** (from Google Brain) released with the paper [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946) by Mingxing Tan, Quoc V. Le.
  1. **[ELECTRA](https://huggingface.co/docs/transformers/model_doc/electra)** (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang Luong, Quoc V. Le, Christopher D. Manning.
  1. **[EncoderDecoder](https://huggingface.co/docs/transformers/model_doc/encoder-decoder)** (from Google Research) released with the paper [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
  1. **[ERNIE](https://huggingface.co/docs/transformers/model_doc/ernie)** (from Baidu) released with the paper [ERNIE: Enhanced Representation through Knowledge Integration](https://arxiv.org/abs/1904.09223) by Yu Sun, Shuohuan Wang, Yukun Li, Shikun Feng, Xuyi Chen, Han Zhang, Xin Tian, Danxiang Zhu, Hao Tian, Hua Wu.
  1. **[ErnieM](https://huggingface.co/docs/transformers/model_doc/ernie_m)** (from Baidu) released with the paper [ERNIE-M: Enhanced Multilingual Representation by Aligning Cross-lingual Semantics with Monolingual Corpora](https://arxiv.org/abs/2012.15674) by Xuan Ouyang, Shuohuan Wang, Chao Pang, Yu Sun, Hao Tian, Hua Wu, Haifeng Wang.
  1. **[ESM](https://huggingface.co/docs/transformers/model_doc/esm)** (from Meta AI) are transformer protein language models.  **ESM-1b** was released with the paper [Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences](https://www.pnas.org/content/118/15/e2016239118) by Alexander Rives, Joshua Meier, Tom Sercu, Siddharth Goyal, Zeming Lin, Jason Liu, Demi Guo, Myle Ott, C. Lawrence Zitnick, Jerry Ma, and Rob Fergus. **ESM-1v** was released with the paper [Language models enable zero-shot prediction of the effects of mutations on protein function](https://doi.org/10.1101/2021.07.09.450648) by Joshua Meier, Roshan Rao, Robert Verkuil, Jason Liu, Tom Sercu and Alexander Rives. **ESM-2 and ESMFold** were released with the paper [Language models of protein sequences at the scale of evolution enable accurate structure prediction](https://doi.org/10.1101/2022.07.20.500902) by Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido, Alexander Rives.
  1. **[FLAN-T5](https://huggingface.co/docs/transformers/model_doc/flan-t5)** (from Google AI) released in the repository [google-research/t5x](https://github.com/google-research/t5x/blob/main/docs/models.md#flan-t5-checkpoints) by Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Albert Webson, Shixiang Shane Gu, Zhuyun Dai, Mirac Suzgun, Xinyun Chen, Aakanksha Chowdhery, Sharan Narang, Gaurav Mishra, Adams Yu, Vincent Zhao, Yanping Huang, Andrew Dai, Hongkun Yu, Slav Petrov, Ed H. Chi, Jeff Dean, Jacob Devlin, Adam Roberts, Denny Zhou, Quoc V. Le, and Jason Wei
  1. **[FLAN-UL2](https://huggingface.co/docs/transformers/model_doc/flan-ul2)** (from Google AI) released in the repository [google-research/t5x](https://github.com/google-research/t5x/blob/main/docs/models.md#flan-ul2-checkpoints) by Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Albert Webson, Shixiang Shane Gu, Zhuyun Dai, Mirac Suzgun, Xinyun Chen, Aakanksha Chowdhery, Sharan Narang, Gaurav Mishra, Adams Yu, Vincent Zhao, Yanping Huang, Andrew Dai, Hongkun Yu, Slav Petrov, Ed H. Chi, Jeff Dean, Jacob Devlin, Adam Roberts, Denny Zhou, Quoc V. Le, and Jason Wei
  1. **[FlauBERT](https://huggingface.co/docs/transformers/model_doc/flaubert)** (from CNRS) released with the paper [FlauBERT: Unsupervised Language Model Pre-training for French](https://arxiv.org/abs/1912.05372) by Hang Le, Loïc Vial, Jibril Frej, Vincent Segonne, Maximin Coavoux, Benjamin Lecouteux, Alexandre Allauzen, Benoît Crabbé, Laurent Besacier, Didier Schwab.
  1. **[FLAVA](https://huggingface.co/docs/transformers/model_doc/flava)** (from Facebook AI) released with the paper [FLAVA: A Foundational Language And Vision Alignment Model](https://arxiv.org/abs/2112.04482) by Amanpreet Singh, Ronghang Hu, Vedanuj Goswami, Guillaume Couairon, Wojciech Galuba, Marcus Rohrbach, and Douwe Kiela.
  1. **[FNet](https://huggingface.co/docs/transformers/model_doc/fnet)** (from Google Research) released with the paper [FNet: Mixing Tokens with Fourier Transforms](https://arxiv.org/abs/2105.03824) by James Lee-Thorp, Joshua Ainslie, Ilya Eckstein, Santiago Ontanon.
  1. **[Funnel Transformer](https://huggingface.co/docs/transformers/model_doc/funnel)** (from CMU/Google Brain) released with the paper [Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing](https://arxiv.org/abs/2006.03236) by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le.
  1. **[GIT](https://huggingface.co/docs/transformers/model_doc/git)** (from Microsoft Research) released with the paper [GIT: A Generative Image-to-text Transformer for Vision and Language](https://arxiv.org/abs/2205.14100) by Jianfeng Wang, Zhengyuan Yang, Xiaowei Hu, Linjie Li, Kevin Lin, Zhe Gan, Zicheng Liu, Ce Liu, Lijuan Wang.
  1. **[GLPN](https://huggingface.co/docs/transformers/model_doc/glpn)** (from KAIST) released with the paper [Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth](https://arxiv.org/abs/2201.07436) by Doyeon Kim, Woonghyun Ga, Pyungwhan Ahn, Donggyu Joo, Sehwan Chun, Junmo Kim.
  1. **[GPT](https://huggingface.co/docs/transformers/model_doc/openai-gpt)** (from OpenAI) released with the paper [Improving Language Understanding by Generative Pre-Training](https://blog.openai.com/language-unsupervised/) by Alec Radford, Karthik Narasimhan, Tim Salimans and Ilya Sutskever.
  1. **[GPT Neo](https://huggingface.co/docs/transformers/model_doc/gpt_neo)** (from EleutherAI) released in the repository [EleutherAI/gpt-neo](https://github.com/EleutherAI/gpt-neo) by Sid Black, Stella Biderman, Leo Gao, Phil Wang and Connor Leahy.
  1. **[GPT NeoX](https://huggingface.co/docs/transformers/model_doc/gpt_neox)** (from EleutherAI) released with the paper [GPT-NeoX-20B: An Open-Source Autoregressive Language Model](https://arxiv.org/abs/2204.06745) by Sid Black, Stella Biderman, Eric Hallahan, Quentin Anthony, Leo Gao, Laurence Golding, Horace He, Connor Leahy, Kyle McDonell, Jason Phang, Michael Pieler, USVSN Sai Prashanth, Shivanshu Purohit, Laria Reynolds, Jonathan Tow, Ben Wang, Samuel Weinbach
  1. **[GPT NeoX Japanese](https://huggingface.co/docs/transformers/model_doc/gpt_neox_japanese)** (from ABEJA) released by Shinya Otani, Takayoshi Makabe, Anuj Arora, and Kyo Hattori.
  1. **[GPT-2](https://huggingface.co/docs/transformers/model_doc/gpt2)** (from OpenAI) released with the paper [Language Models are Unsupervised Multitask Learners](https://blog.openai.com/better-language-models/) by Alec Radford*, Jeffrey Wu*, Rewon Child, David Luan, Dario Amodei** and Ilya Sutskever**.
  1. **[GPT-J](https://huggingface.co/docs/transformers/model_doc/gptj)** (from EleutherAI) released in the repository [kingoflolz/mesh-transformer-jax](https://github.com/kingoflolz/mesh-transformer-jax/) by Ben Wang and Aran Komatsuzaki.
  1. **[GPT-Sw3](https://huggingface.co/docs/transformers/model_doc/gpt-sw3)** (from AI-Sweden) released with the paper [Lessons Learned from GPT-SW3: Building the First Large-Scale Generative Language Model for Swedish](http://www.lrec-conf.org/proceedings/lrec2022/pdf/2022.lrec-1.376.pdf) by Ariel Ekgren, Amaru Cuba Gyllensten, Evangelia Gogoulou, Alice Heiman, Severine Verlinden, Joey Öhman, Fredrik Carlsson, Magnus Sahlgren.
  1. **[GPTSAN-japanese](https://huggingface.co/docs/transformers/model_doc/gptsan-japanese)** released in the repository [tanreinama/GPTSAN](https://github.com/tanreinama/GPTSAN/blob/main/report/model.md) by Toshiyuki Sakamoto(tanreinama).
  1. **[Graphormer](https://huggingface.co/docs/transformers/model_doc/graphormer)** (from Microsoft) released with the paper [Do Transformers Really Perform Bad for Graph Representation?](https://arxiv.org/abs/2106.05234) by Chengxuan Ying, Tianle Cai, Shengjie Luo, Shuxin Zheng, Guolin Ke, Di He, Yanming Shen, Tie-Yan Liu.
  1. **[GroupViT](https://huggingface.co/docs/transformers/model_doc/groupvit)** (from UCSD, NVIDIA) released with the paper [GroupViT: Semantic Segmentation Emerges from Text Supervision](https://arxiv.org/abs/2202.11094) by Jiarui Xu, Shalini De Mello, Sifei Liu, Wonmin Byeon, Thomas Breuel, Jan Kautz, Xiaolong Wang.
  1. **[Hubert](https://huggingface.co/docs/transformers/model_doc/hubert)** (from Facebook) released with the paper [HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units](https://arxiv.org/abs/2106.07447) by Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed.
  1. **[I-BERT](https://huggingface.co/docs/transformers/model_doc/ibert)** (from Berkeley) released with the paper [I-BERT: Integer-only BERT Quantization](https://arxiv.org/abs/2101.01321) by Sehoon Kim, Amir Gholami, Zhewei Yao, Michael W. Mahoney, Kurt Keutzer.
  1. **[ImageGPT](https://huggingface.co/docs/transformers/model_doc/imagegpt)** (from OpenAI) released with the paper [Generative Pretraining from Pixels](https://openai.com/blog/image-gpt/) by Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, Ilya Sutskever.
  1. **[Informer](https://huggingface.co/docs/transformers/model_doc/informer)** (from Beihang University, UC Berkeley, Rutgers University, SEDD Company) released with the paper [Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting](https://arxiv.org/abs/2012.07436) by Haoyi Zhou, Shanghang Zhang, Jieqi Peng, Shuai Zhang, Jianxin Li, Hui Xiong, and Wancai Zhang.
  1. **[Jukebox](https://huggingface.co/docs/transformers/model_doc/jukebox)** (from OpenAI) released with the paper [Jukebox: A Generative Model for Music](https://arxiv.org/pdf/2005.00341.pdf) by Prafulla Dhariwal, Heewoo Jun, Christine Payne, Jong Wook Kim, Alec Radford, Ilya Sutskever.
  1. **[LayoutLM](https://huggingface.co/docs/transformers/model_doc/layoutlm)** (from Microsoft Research Asia) released with the paper [LayoutLM: Pre-training of Text and Layout for Document Image Understanding](https://arxiv.org/abs/1912.13318) by Yiheng Xu, Minghao Li, Lei Cui, Shaohan Huang, Furu Wei, Ming Zhou.
  1. **[LayoutLMv2](https://huggingface.co/docs/transformers/model_doc/layoutlmv2)** (from Microsoft Research Asia) released with the paper [LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding](https://arxiv.org/abs/2012.14740) by Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang, Lidong Zhou.
  1. **[LayoutLMv3](https://huggingface.co/docs/transformers/model_doc/layoutlmv3)** (from Microsoft Research Asia) released with the paper [LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking](https://arxiv.org/abs/2204.08387) by Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei.
  1. **[LayoutXLM](https://huggingface.co/docs/transformers/model_doc/layoutxlm)** (from Microsoft Research Asia) released with the paper [LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding](https://arxiv.org/abs/2104.08836) by Yiheng Xu, Tengchao Lv, Lei Cui, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Furu Wei.
  1. **[LED](https://huggingface.co/docs/transformers/model_doc/led)** (from AllenAI) released with the paper [Longformer: The Long-Document Transformer](https://arxiv.org/abs/2004.05150) by Iz Beltagy, Matthew E. Peters, Arman Cohan.
  1. **[LeViT](https://huggingface.co/docs/transformers/model_doc/levit)** (from Meta AI) released with the paper [LeViT: A Vision Transformer in ConvNet's Clothing for Faster Inference](https://arxiv.org/abs/2104.01136) by Ben Graham, Alaaeldin El-Nouby, Hugo Touvron, Pierre Stock, Armand Joulin, Hervé Jégou, Matthijs Douze.
  1. **[LiLT](https://huggingface.co/docs/transformers/model_doc/lilt)** (from South China University of Technology) released with the paper [LiLT: A Simple yet Effective Language-Independent Layout Transformer for Structured Document Understanding](https://arxiv.org/abs/2202.13669) by Jiapeng Wang, Lianwen Jin, Kai Ding.
  1. **[Longformer](https://huggingface.co/docs/transformers/model_doc/longformer)** (from AllenAI) released with the paper [Longformer: The Long-Document Transformer](https://arxiv.org/abs/2004.05150) by Iz Beltagy, Matthew E. Peters, Arman Cohan.
  1. **[LongT5](https://huggingface.co/docs/transformers/model_doc/longt5)** (from Google AI) released with the paper [LongT5: Efficient Text-To-Text Transformer for Long Sequences](https://arxiv.org/abs/2112.07916) by Mandy Guo, Joshua Ainslie, David Uthus, Santiago Ontanon, Jianmo Ni, Yun-Hsuan Sung, Yinfei Yang.
  1. **[LUKE](https://huggingface.co/docs/transformers/model_doc/luke)** (from Studio Ousia) released with the paper [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention](https://arxiv.org/abs/2010.01057) by Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda, Yuji Matsumoto.
  1. **[LXMERT](https://huggingface.co/docs/transformers/model_doc/lxmert)** (from UNC Chapel Hill) released with the paper [LXMERT: Learning Cross-Modality Encoder Representations from Transformers for Open-Domain Question Answering](https://arxiv.org/abs/1908.07490) by Hao Tan and Mohit Bansal.
  1. **[M-CTC-T](https://huggingface.co/docs/transformers/model_doc/mctct)** (from Facebook) released with the paper [Pseudo-Labeling For Massively Multilingual Speech Recognition](https://arxiv.org/abs/2111.00161) by Loren Lugosch, Tatiana Likhomanenko, Gabriel Synnaeve, and Ronan Collobert.
  1. **[M2M100](https://huggingface.co/docs/transformers/model_doc/m2m_100)** (from Facebook) released with the paper [Beyond English-Centric Multilingual Machine Translation](https://arxiv.org/abs/2010.11125) by Angela Fan, Shruti Bhosale, Holger Schwenk, Zhiyi Ma, Ahmed El-Kishky, Siddharth Goyal, Mandeep Baines, Onur Celebi, Guillaume Wenzek, Vishrav Chaudhary, Naman Goyal, Tom Birch, Vitaliy Liptchinsky, Sergey Edunov, Edouard Grave, Michael Auli, Armand Joulin.
  1. **[MarianMT](https://huggingface.co/docs/transformers/model_doc/marian)** Machine translation models trained using [OPUS](http://opus.nlpl.eu/) data by Jörg Tiedemann. The [Marian Framework](https://marian-nmt.github.io/) is being developed by the Microsoft Translator Team.
  1. **[MarkupLM](https://huggingface.co/docs/transformers/model_doc/markuplm)** (from Microsoft Research Asia) released with the paper [MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding](https://arxiv.org/abs/2110.08518) by Junlong Li, Yiheng Xu, Lei Cui, Furu Wei.
  1. **[Mask2Former](https://huggingface.co/docs/transformers/model_doc/mask2former)** (from FAIR and UIUC) released with the paper [Masked-attention Mask Transformer for Universal Image Segmentation](https://arxiv.org/abs/2112.01527) by Bowen Cheng, Ishan Misra, Alexander G. Schwing, Alexander Kirillov, Rohit Girdhar.
  1. **[MaskFormer](https://huggingface.co/docs/transformers/model_doc/maskformer)** (from Meta and UIUC) released with the paper [Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://arxiv.org/abs/2107.06278) by Bowen Cheng, Alexander G. Schwing, Alexander Kirillov.
  1. **[mBART](https://huggingface.co/docs/transformers/model_doc/mbart)** (from Facebook) released with the paper [Multilingual Denoising Pre-training for Neural Machine Translation](https://arxiv.org/abs/2001.08210) by Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer.
  1. **[mBART-50](https://huggingface.co/docs/transformers/model_doc/mbart)** (from Facebook) released with the paper [Multilingual Translation with Extensible Multilingual Pretraining and Finetuning](https://arxiv.org/abs/2008.00401) by Yuqing Tang, Chau Tran, Xian Li, Peng-Jen Chen, Naman Goyal, Vishrav Chaudhary, Jiatao Gu, Angela Fan.
  1. **[Megatron-BERT](https://huggingface.co/docs/transformers/model_doc/megatron-bert)** (from NVIDIA) released with the paper [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053) by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.
  1. **[Megatron-GPT2](https://huggingface.co/docs/transformers/model_doc/megatron_gpt2)** (from NVIDIA) released with the paper [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053) by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.
  1. **[MGP-STR](https://huggingface.co/docs/transformers/model_doc/mgp-str)** (from Alibaba Research) released with the paper [Multi-Granularity Prediction for Scene Text Recognition](https://arxiv.org/abs/2209.03592) by Peng Wang, Cheng Da, and Cong Yao.
  1. **[mLUKE](https://huggingface.co/docs/transformers/model_doc/mluke)** (from Studio Ousia) released with the paper [mLUKE: The Power of Entity Representations in Multilingual Pretrained Language Models](https://arxiv.org/abs/2110.08151) by Ryokan Ri, Ikuya Yamada, and Yoshimasa Tsuruoka.
  1. **[MobileBERT](https://huggingface.co/docs/transformers/model_doc/mobilebert)** (from CMU/Google Brain) released with the paper [MobileBERT: a Compact Task-Agnostic BERT for Resource-Limited Devices](https://arxiv.org/abs/2004.02984) by Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou.
  1. **[MobileNetV1](https://huggingface.co/docs/transformers/model_doc/mobilenet_v1)** (from Google Inc.) released with the paper [MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications](https://arxiv.org/abs/1704.04861) by Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, Hartwig Adam.
  1. **[MobileNetV2](https://huggingface.co/docs/transformers/model_doc/mobilenet_v2)** (from Google Inc.) released with the paper [MobileNetV2: Inverted Residuals and Linear Bottlenecks](https://arxiv.org/abs/1801.04381) by Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, Liang-Chieh Chen.
  1. **[MobileViT](https://huggingface.co/docs/transformers/model_doc/mobilevit)** (from Apple) released with the paper [MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer](https://arxiv.org/abs/2110.02178) by Sachin Mehta and Mohammad Rastegari.
  1. **[MPNet](https://huggingface.co/docs/transformers/model_doc/mpnet)** (from Microsoft Research) released with the paper [MPNet: Masked and Permuted Pre-training for Language Understanding](https://arxiv.org/abs/2004.09297) by Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, Tie-Yan Liu.
  1. **[MT5](https://huggingface.co/docs/transformers/model_doc/mt5)** (from Google AI) released with the paper [mT5: A massively multilingual pre-trained text-to-text transformer](https://arxiv.org/abs/2010.11934) by Linting Xue, Noah Constant, Adam Roberts, Mihir Kale, Rami Al-Rfou, Aditya Siddhant, Aditya Barua, Colin Raffel.
  1. **[MVP](https://huggingface.co/docs/transformers/model_doc/mvp)** (from RUC AI Box) released with the paper [MVP: Multi-task Supervised Pre-training for Natural Language Generation](https://arxiv.org/abs/2206.12131) by Tianyi Tang, Junyi Li, Wayne Xin Zhao and Ji-Rong Wen.
  1. **[NAT](https://huggingface.co/docs/transformers/model_doc/nat)** (from SHI Labs) released with the paper [Neighborhood Attention Transformer](https://arxiv.org/abs/2204.07143) by Ali Hassani, Steven Walton, Jiachen Li, Shen Li, and Humphrey Shi.
  1. **[Nezha](https://huggingface.co/docs/transformers/model_doc/nezha)** (from Huawei Noah’s Ark Lab) released with the paper [NEZHA: Neural Contextualized Representation for Chinese Language Understanding](https://arxiv.org/abs/1909.00204) by Junqiu Wei, Xiaozhe Ren, Xiaoguang Li, Wenyong Huang, Yi Liao, Yasheng Wang, Jiashu Lin, Xin Jiang, Xiao Chen and Qun Liu.
  1. **[NLLB](https://huggingface.co/docs/transformers/model_doc/nllb)** (from Meta) released with the paper [No Language Left Behind: Scaling Human-Centered Machine Translation](https://arxiv.org/abs/2207.04672) by the NLLB team.
  1. **[Nyströmformer](https://huggingface.co/docs/transformers/model_doc/nystromformer)** (from the University of Wisconsin - Madison) released with the paper [Nyströmformer: A Nyström-Based Algorithm for Approximating Self-Attention](https://arxiv.org/abs/2102.03902) by Yunyang Xiong, Zhanpeng Zeng, Rudrasis Chakraborty, Mingxing Tan, Glenn Fung, Yin Li, Vikas Singh.
  1. **[OneFormer](https://huggingface.co/docs/transformers/model_doc/oneformer)** (from SHI Labs) released with the paper [OneFormer: One Transformer to Rule Universal Image Segmentation](https://arxiv.org/abs/2211.06220) by Jitesh Jain, Jiachen Li, MangTik Chiu, Ali Hassani, Nikita Orlov, Humphrey Shi.
  1. **[OPT](https://huggingface.co/docs/transformers/master/model_doc/opt)** (from Meta AI) released with the paper [OPT: Open Pre-trained Transformer Language Models](https://arxiv.org/abs/2205.01068) by Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen et al.
  1. **[OWL-ViT](https://huggingface.co/docs/transformers/model_doc/owlvit)** (from Google AI) released with the paper [Simple Open-Vocabulary Object Detection with Vision Transformers](https://arxiv.org/abs/2205.06230) by Matthias Minderer, Alexey Gritsenko, Austin Stone, Maxim Neumann, Dirk Weissenborn, Alexey Dosovitskiy, Aravindh Mahendran, Anurag Arnab, Mostafa Dehghani, Zhuoran Shen, Xiao Wang, Xiaohua Zhai, Thomas Kipf, and Neil Houlsby.
  1. **[Pegasus](https://huggingface.co/docs/transformers/model_doc/pegasus)** (from Google) released with the paper [PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization](https://arxiv.org/abs/1912.08777) by Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu.
  1. **[PEGASUS-X](https://huggingface.co/docs/transformers/model_doc/pegasus_x)** (from Google) released with the paper [Investigating Efficiently Extending Transformers for Long Input Summarization](https://arxiv.org/abs/2208.04347) by Jason Phang, Yao Zhao, and Peter J. Liu.
  1. **[Perceiver IO](https://huggingface.co/docs/transformers/model_doc/perceiver)** (from Deepmind) released with the paper [Perceiver IO: A General Architecture for Structured Inputs & Outputs](https://arxiv.org/abs/2107.14795) by Andrew Jaegle, Sebastian Borgeaud, Jean-Baptiste Alayrac, Carl Doersch, Catalin Ionescu, David Ding, Skanda Koppula, Daniel Zoran, Andrew Brock, Evan Shelhamer, Olivier Hénaff, Matthew M. Botvinick, Andrew Zisserman, Oriol Vinyals, João Carreira.
  1. **[PhoBERT](https://huggingface.co/docs/transformers/model_doc/phobert)** (from VinAI Research) released with the paper [PhoBERT: Pre-trained language models for Vietnamese](https://www.aclweb.org/anthology/2020.findings-emnlp.92/) by Dat Quoc Nguyen and Anh Tuan Nguyen.
  1. **[PLBart](https://huggingface.co/docs/transformers/model_doc/plbart)** (from UCLA NLP) released with the paper [Unified Pre-training for Program Understanding and Generation](https://arxiv.org/abs/2103.06333) by Wasi Uddin Ahmad, Saikat Chakraborty, Baishakhi Ray, Kai-Wei Chang.
  1. **[PoolFormer](https://huggingface.co/docs/transformers/model_doc/poolformer)** (from Sea AI Labs) released with the paper [MetaFormer is Actually What You Need for Vision](https://arxiv.org/abs/2111.11418) by Yu, Weihao and Luo, Mi and Zhou, Pan and Si, Chenyang and Zhou, Yichen and Wang, Xinchao and Feng, Jiashi and Yan, Shuicheng.
  1. **[ProphetNet](https://huggingface.co/docs/transformers/model_doc/prophetnet)** (from Microsoft Research) released with the paper [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://arxiv.org/abs/2001.04063) by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.
  1. **[QDQBert](https://huggingface.co/docs/transformers/model_doc/qdqbert)** (from NVIDIA) released with the paper [Integer Quantization for Deep Learning Inference: Principles and Empirical Evaluation](https://arxiv.org/abs/2004.09602) by Hao Wu, Patrick Judd, Xiaojie Zhang, Mikhail Isaev and Paulius Micikevicius.
  1. **[RAG](https://huggingface.co/docs/transformers/model_doc/rag)** (from Facebook) released with the paper [Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks](https://arxiv.org/abs/2005.11401) by Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, Douwe Kiela.
  1. **[REALM](https://huggingface.co/docs/transformers/model_doc/realm.html)** (from Google Research) released with the paper [REALM: Retrieval-Augmented Language Model Pre-Training](https://arxiv.org/abs/2002.08909) by Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat and Ming-Wei Chang.
  1. **[Reformer](https://huggingface.co/docs/transformers/model_doc/reformer)** (from Google Research) released with the paper [Reformer: The Efficient Transformer](https://arxiv.org/abs/2001.04451) by Nikita Kitaev, Łukasz Kaiser, Anselm Levskaya.
  1. **[RegNet](https://huggingface.co/docs/transformers/model_doc/regnet)** (from META Platforms) released with the paper [Designing Network Design Space](https://arxiv.org/abs/2003.13678) by Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, Piotr Dollár.
  1. **[RemBERT](https://huggingface.co/docs/transformers/model_doc/rembert)** (from Google Research) released with the paper [Rethinking embedding coupling in pre-trained language models](https://arxiv.org/abs/2010.12821) by Hyung Won Chung, Thibault Févry, Henry Tsai, M. Johnson, Sebastian Ruder.
  1. **[ResNet](https://huggingface.co/docs/transformers/model_doc/resnet)** (from Microsoft Research) released with the paper [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385) by Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun.
  1. **[RoBERTa](https://huggingface.co/docs/transformers/model_doc/roberta)** (from Facebook), released together with the paper [RoBERTa: A Robustly Optimized BERT Pretraining Approach](https://arxiv.org/abs/1907.11692) by Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, Veselin Stoyanov.
  1. **[RoBERTa-PreLayerNorm](https://huggingface.co/docs/transformers/model_doc/roberta-prelayernorm)** (from Facebook) released with the paper [fairseq: A Fast, Extensible Toolkit for Sequence Modeling](https://arxiv.org/abs/1904.01038) by Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, Michael Auli.
  1. **[RoCBert](https://huggingface.co/docs/transformers/model_doc/roc_bert)** (from WeChatAI) released with the paper [RoCBert: Robust Chinese Bert with Multimodal Contrastive Pretraining](https://aclanthology.org/2022.acl-long.65.pdf) by HuiSu, WeiweiShi, XiaoyuShen, XiaoZhou, TuoJi, JiaruiFang, JieZhou.
  1. **[RoFormer](https://huggingface.co/docs/transformers/model_doc/roformer)** (from ZhuiyiTechnology), released together with the paper [RoFormer: Enhanced Transformer with Rotary Position Embedding](https://arxiv.org/abs/2104.09864) by Jianlin Su and Yu Lu and Shengfeng Pan and Bo Wen and Yunfeng Liu.
  1. **[SegFormer](https://huggingface.co/docs/transformers/model_doc/segformer)** (from NVIDIA) released with the paper [SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers](https://arxiv.org/abs/2105.15203) by Enze Xie, Wenhai Wang, Zhiding Yu, Anima Anandkumar, Jose M. Alvarez, Ping Luo.
  1. **[SEW](https://huggingface.co/docs/transformers/model_doc/sew)** (from ASAPP) released with the paper [Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition](https://arxiv.org/abs/2109.06870) by Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
  1. **[SEW-D](https://huggingface.co/docs/transformers/model_doc/sew_d)** (from ASAPP) released with the paper [Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition](https://arxiv.org/abs/2109.06870) by Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
  1. **[SpeechT5](https://huggingface.co/docs/transformers/model_doc/speecht5)** (from Microsoft Research) released with the paper [SpeechT5: Unified-Modal Encoder-Decoder Pre-Training for Spoken Language Processing](https://arxiv.org/abs/2110.07205) by Junyi Ao, Rui Wang, Long Zhou, Chengyi Wang, Shuo Ren, Yu Wu, Shujie Liu, Tom Ko, Qing Li, Yu Zhang, Zhihua Wei, Yao Qian, Jinyu Li, Furu Wei.
  1. **[SpeechToTextTransformer](https://huggingface.co/docs/transformers/model_doc/speech_to_text)** (from Facebook), released together with the paper [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Dmytro Okhonko, Juan Pino.
  1. **[SpeechToTextTransformer2](https://huggingface.co/docs/transformers/model_doc/speech_to_text_2)** (from Facebook), released together with the paper [Large-Scale Self- and Semi-Supervised Learning for Speech Translation](https://arxiv.org/abs/2104.06678) by Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli, Alexis Conneau.
  1. **[Splinter](https://huggingface.co/docs/transformers/model_doc/splinter)** (from Tel Aviv University), released together with the paper [Few-Shot Question Answering by Pretraining Span Selection](https://arxiv.org/abs/2101.00438) by Ori Ram, Yuval Kirstain, Jonathan Berant, Amir Globerson, Omer Levy.
  1. **[SqueezeBERT](https://huggingface.co/docs/transformers/model_doc/squeezebert)** (from Berkeley) released with the paper [SqueezeBERT: What can computer vision teach NLP about efficient neural networks?](https://arxiv.org/abs/2006.11316) by Forrest N. Iandola, Albert E. Shaw, Ravi Krishna, and Kurt W. Keutzer.
  1. **[Swin Transformer](https://huggingface.co/docs/transformers/model_doc/swin)** (from Microsoft) released with the paper [Swin Transformer: Hierarchical Vision Transformer using Shifted Windows](https://arxiv.org/abs/2103.14030) by Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, Baining Guo.
  1. **[Swin Transformer V2](https://huggingface.co/docs/transformers/model_doc/swinv2)** (from Microsoft) released with the paper [Swin Transformer V2: Scaling Up Capacity and Resolution](https://arxiv.org/abs/2111.09883) by Ze Liu, Han Hu, Yutong Lin, Zhuliang Yao, Zhenda Xie, Yixuan Wei, Jia Ning, Yue Cao, Zheng Zhang, Li Dong, Furu Wei, Baining Guo.
  1. **[Swin2SR](https://huggingface.co/docs/transformers/model_doc/swin2sr)** (from University of Würzburg) released with the paper [Swin2SR: SwinV2 Transformer for Compressed Image Super-Resolution and Restoration](https://arxiv.org/abs/2209.11345) by Marcos V. Conde, Ui-Jin Choi, Maxime Burchi, Radu Timofte.
  1. **[SwitchTransformers](https://huggingface.co/docs/transformers/model_doc/switch_transformers)** (from Google) released with the paper [Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity](https://arxiv.org/abs/2101.03961) by William Fedus, Barret Zoph, Noam Shazeer.
  1. **[T5](https://huggingface.co/docs/transformers/model_doc/t5)** (from Google AI) released with the paper [Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer](https://arxiv.org/abs/1910.10683) by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.
  1. **[T5v1.1](https://huggingface.co/docs/transformers/model_doc/t5v1.1)** (from Google AI) released in the repository [google-research/text-to-text-transfer-transformer](https://github.com/google-research/text-to-text-transfer-transformer/blob/main/released_checkpoints.md#t511) by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.
  1. **[Table Transformer](https://huggingface.co/docs/transformers/model_doc/table-transformer)** (from Microsoft Research) released with the paper [PubTables-1M: Towards Comprehensive Table Extraction From Unstructured Documents](https://arxiv.org/abs/2110.00061) by Brandon Smock, Rohith Pesala, Robin Abraham.
  1. **[TAPAS](https://huggingface.co/docs/transformers/model_doc/tapas)** (from Google AI) released with the paper [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://arxiv.org/abs/2004.02349) by Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno and Julian Martin Eisenschlos.
  1. **[TAPEX](https://huggingface.co/docs/transformers/model_doc/tapex)** (from Microsoft Research) released with the paper [TAPEX: Table Pre-training via Learning a Neural SQL Executor](https://arxiv.org/abs/2107.07653) by Qian Liu, Bei Chen, Jiaqi Guo, Morteza Ziyadi, Zeqi Lin, Weizhu Chen, Jian-Guang Lou.
  1. **[Time Series Transformer](https://huggingface.co/docs/transformers/model_doc/time_series_transformer)** (from HuggingFace).
  1. **[TimeSformer](https://huggingface.co/docs/transformers/model_doc/timesformer)** (from Facebook) released with the paper [Is Space-Time Attention All You Need for Video Understanding?](https://arxiv.org/abs/2102.05095) by Gedas Bertasius, Heng Wang, Lorenzo Torresani.
  1. **[Trajectory Transformer](https://huggingface.co/docs/transformers/model_doc/trajectory_transformers)** (from the University of California at Berkeley) released with the paper [Offline Reinforcement Learning as One Big Sequence Modeling Problem](https://arxiv.org/abs/2106.02039) by Michael Janner, Qiyang Li, Sergey Levine
  1. **[Transformer-XL](https://huggingface.co/docs/transformers/model_doc/transfo-xl)** (from Google/CMU) released with the paper [Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context](https://arxiv.org/abs/1901.02860) by Zihang Dai*, Zhilin Yang*, Yiming Yang, Jaime Carbonell, Quoc V. Le, Ruslan Salakhutdinov.
  1. **[TrOCR](https://huggingface.co/docs/transformers/model_doc/trocr)** (from Microsoft), released together with the paper [TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models](https://arxiv.org/abs/2109.10282) by Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei.
  1. **[TVLT](https://huggingface.co/docs/transformers/model_doc/tvlt)** (from UNC Chapel Hill) released with the paper [TVLT: Textless Vision-Language Transformer](https://arxiv.org/abs/2209.14156) by Zineng Tang, Jaemin Cho, Yixin Nie, Mohit Bansal.
  1. **[UL2](https://huggingface.co/docs/transformers/model_doc/ul2)** (from Google Research) released with the paper [Unifying Language Learning Paradigms](https://arxiv.org/abs/2205.05131v1) by Yi Tay, Mostafa Dehghani, Vinh Q. Tran, Xavier Garcia, Dara Bahri, Tal Schuster, Huaixiu Steven Zheng, Neil Houlsby, Donald Metzler
  1. **[UniSpeech](https://huggingface.co/docs/transformers/model_doc/unispeech)** (from Microsoft Research) released with the paper [UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data](https://arxiv.org/abs/2101.07597) by Chengyi Wang, Yu Wu, Yao Qian, Kenichi Kumatani, Shujie Liu, Furu Wei, Michael Zeng, Xuedong Huang.
  1. **[UniSpeechSat](https://huggingface.co/docs/transformers/model_doc/unispeech-sat)** (from Microsoft Research) released with the paper [UNISPEECH-SAT: UNIVERSAL SPEECH REPRESENTATION LEARNING WITH SPEAKER AWARE PRE-TRAINING](https://arxiv.org/abs/2110.05752) by Sanyuan Chen, Yu Wu, Chengyi Wang, Zhengyang Chen, Zhuo Chen, Shujie Liu, Jian Wu, Yao Qian, Furu Wei, Jinyu Li, Xiangzhan Yu.
  1. **[UPerNet](https://huggingface.co/docs/transformers/model_doc/upernet)** (from Peking University) released with the paper [Unified Perceptual Parsing for Scene Understanding](https://arxiv.org/abs/1807.10221) by Tete Xiao, Yingcheng Liu, Bolei Zhou, Yuning Jiang, Jian Sun.
  1. **[VAN](https://huggingface.co/docs/transformers/model_doc/van)** (from Tsinghua University and Nankai University) released with the paper [Visual Attention Network](https://arxiv.org/abs/2202.09741) by Meng-Hao Guo, Cheng-Ze Lu, Zheng-Ning Liu, Ming-Ming Cheng, Shi-Min Hu.
  1. **[VideoMAE](https://huggingface.co/docs/transformers/model_doc/videomae)** (from Multimedia Computing Group, Nanjing University) released with the paper [VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training](https://arxiv.org/abs/2203.12602) by Zhan Tong, Yibing Song, Jue Wang, Limin Wang.
  1. **[ViLT](https://huggingface.co/docs/transformers/model_doc/vilt)** (from NAVER AI Lab/Kakao Enterprise/Kakao Brain) released with the paper [ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision](https://arxiv.org/abs/2102.03334) by Wonjae Kim, Bokyung Son, Ildoo Kim.
  1. **[Vision Transformer (ViT)](https://huggingface.co/docs/transformers/model_doc/vit)** (from Google AI) released with the paper [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) by Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.
  1. **[VisualBERT](https://huggingface.co/docs/transformers/model_doc/visual_bert)** (from UCLA NLP) released with the paper [VisualBERT: A Simple and Performant Baseline for Vision and Language](https://arxiv.org/pdf/1908.03557) by Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, Kai-Wei Chang.
  1. **[ViT Hybrid](https://huggingface.co/docs/transformers/model_doc/vit_hybrid)** (from Google AI) released with the paper [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) by Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.
  1. **[ViTMAE](https://huggingface.co/docs/transformers/model_doc/vit_mae)** (from Meta AI) released with the paper [Masked Autoencoders Are Scalable Vision Learners](https://arxiv.org/abs/2111.06377) by Kaiming He, Xinlei Chen, Saining Xie, Yanghao Li, Piotr Dollár, Ross Girshick.
  1. **[ViTMSN](https://huggingface.co/docs/transformers/model_doc/vit_msn)** (from Meta AI) released with the paper [Masked Siamese Networks for Label-Efficient Learning](https://arxiv.org/abs/2204.07141) by Mahmoud Assran, Mathilde Caron, Ishan Misra, Piotr Bojanowski, Florian Bordes, Pascal Vincent, Armand Joulin, Michael Rabbat, Nicolas Ballas.
  1. **[Wav2Vec2](https://huggingface.co/docs/transformers/model_doc/wav2vec2)** (from Facebook AI) released with the paper [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://arxiv.org/abs/2006.11477) by Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.
  1. **[Wav2Vec2-Conformer](https://huggingface.co/docs/transformers/model_doc/wav2vec2-conformer)** (from Facebook AI) released with the paper [FAIRSEQ S2T: Fast Speech-to-Text Modeling with FAIRSEQ](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko, Juan Pino.
  1. **[Wav2Vec2Phoneme](https://huggingface.co/docs/transformers/model_doc/wav2vec2_phoneme)** (from Facebook AI) released with the paper [Simple and Effective Zero-shot Cross-lingual Phoneme Recognition](https://arxiv.org/abs/2109.11680) by Qiantong Xu, Alexei Baevski, Michael Auli.
  1. **[WavLM](https://huggingface.co/docs/transformers/model_doc/wavlm)** (from Microsoft Research) released with the paper [WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing](https://arxiv.org/abs/2110.13900) by Sanyuan Chen, Chengyi Wang, Zhengyang Chen, Yu Wu, Shujie Liu, Zhuo Chen, Jinyu Li, Naoyuki Kanda, Takuya Yoshioka, Xiong Xiao, Jian Wu, Long Zhou, Shuo Ren, Yanmin Qian, Yao Qian, Jian Wu, Michael Zeng, Furu Wei.
  1. **[Whisper](https://huggingface.co/docs/transformers/model_doc/whisper)** (from OpenAI) released with the paper [Robust Speech Recognition via Large-Scale Weak Supervision](https://cdn.openai.com/papers/whisper.pdf) by Alec Radford, Jong Wook Kim, Tao Xu, Greg Brockman, Christine McLeavey, Ilya Sutskever.
  1. **[X-CLIP](https://huggingface.co/docs/transformers/model_doc/xclip)** (from Microsoft Research) released with the paper [Expanding Language-Image Pretrained Models for General Video Recognition](https://arxiv.org/abs/2208.02816) by Bolin Ni, Houwen Peng, Minghao Chen, Songyang Zhang, Gaofeng Meng, Jianlong Fu, Shiming Xiang, Haibin Ling.
  1. **[X-MOD](https://huggingface.co/docs/transformers/model_doc/xmod)** (from Meta AI) released with the paper [Lifting the Curse of Multilinguality by Pre-training Modular Transformers](http://dx.doi.org/10.18653/v1/2022.naacl-main.255) by Jonas Pfeiffer, Naman Goyal, Xi Lin, Xian Li, James Cross, Sebastian Riedel, Mikel Artetxe.
  1. **[XGLM](https://huggingface.co/docs/transformers/model_doc/xglm)** (From Facebook AI) released with the paper [Few-shot Learning with Multilingual Language Models](https://arxiv.org/abs/2112.10668) by Xi Victoria Lin, Todor Mihaylov, Mikel Artetxe, Tianlu Wang, Shuohui Chen, Daniel Simig, Myle Ott, Naman Goyal, Shruti Bhosale, Jingfei Du, Ramakanth Pasunuru, Sam Shleifer, Punit Singh Koura, Vishrav Chaudhary, Brian O'Horo, Jeff Wang, Luke Zettlemoyer, Zornitsa Kozareva, Mona Diab, Veselin Stoyanov, Xian Li.
  1. **[XLM](https://huggingface.co/docs/transformers/model_doc/xlm)** (from Facebook) released together with the paper [Cross-lingual Language Model Pretraining](https://arxiv.org/abs/1901.07291) by Guillaume Lample and Alexis Conneau.
  1. **[XLM-ProphetNet](https://huggingface.co/docs/transformers/model_doc/xlm-prophetnet)** (from Microsoft Research) released with the paper [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://arxiv.org/abs/2001.04063) by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.
  1. **[XLM-RoBERTa](https://huggingface.co/docs/transformers/model_doc/xlm-roberta)** (from Facebook AI), released together with the paper [Unsupervised Cross-lingual Representation Learning at Scale](https://arxiv.org/abs/1911.02116) by Alexis Conneau*, Kartikay Khandelwal*, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettlemoyer and Veselin Stoyanov.
  1. **[XLM-RoBERTa-XL](https://huggingface.co/docs/transformers/model_doc/xlm-roberta-xl)** (from Facebook AI), released together with the paper [Larger-Scale Transformers for Multilingual Masked Language Modeling](https://arxiv.org/abs/2105.00572) by Naman Goyal, Jingfei Du, Myle Ott, Giri Anantharaman, Alexis Conneau.
  1. **[XLM-V](https://huggingface.co/docs/transformers/model_doc/xlm-v)** (from Meta AI) released with the paper [XLM-V: Overcoming the Vocabulary Bottleneck in Multilingual Masked Language Models](https://arxiv.org/abs/2301.10472) by Davis Liang, Hila Gonen, Yuning Mao, Rui Hou, Naman Goyal, Marjan Ghazvininejad, Luke Zettlemoyer, Madian Khabsa.
  1. **[XLNet](https://huggingface.co/docs/transformers/model_doc/xlnet)** (from Google/CMU) released with the paper [​XLNet: Generalized Autoregressive Pretraining for Language Understanding](https://arxiv.org/abs/1906.08237) by Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le.
  1. **[XLS-R](https://huggingface.co/docs/transformers/model_doc/xls_r)** (from Facebook AI) released with the paper [XLS-R: Self-supervised Cross-lingual Speech Representation Learning at Scale](https://arxiv.org/abs/2111.09296) by Arun Babu, Changhan Wang, Andros Tjandra, Kushal Lakhotia, Qiantong Xu, Naman Goyal, Kritika Singh, Patrick von Platen, Yatharth Saraf, Juan Pino, Alexei Baevski, Alexis Conneau, Michael Auli.
  1. **[XLSR-Wav2Vec2](https://huggingface.co/docs/transformers/model_doc/xlsr_wav2vec2)** (from Facebook AI) released with the paper [Unsupervised Cross-Lingual Representation Learning For Speech Recognition](https://arxiv.org/abs/2006.13979) by Alexis Conneau, Alexei Baevski, Ronan Collobert, Abdelrahman Mohamed, Michael Auli.
  1. **[YOLOS](https://huggingface.co/docs/transformers/model_doc/yolos)** (from Huazhong University of Science & Technology) released with the paper [You Only Look at One Sequence: Rethinking Transformer in Vision through Object Detection](https://arxiv.org/abs/2106.00666) by Yuxin Fang, Bencheng Liao, Xinggang Wang, Jiemin Fang, Jiyang Qi, Rui Wu, Jianwei Niu, Wenyu Liu.
  1. **[YOSO](https://huggingface.co/docs/transformers/model_doc/yoso)** (from the University of Wisconsin - Madison) released with the paper [You Only Sample (Almost) Once: Linear Cost Self-Attention Via Bernoulli Sampling](https://arxiv.org/abs/2111.09714) by Zhanpeng Zeng, Yunyang Xiong, Sathya N. Ravi, Shailesh Acharya, Glenn Fung, Vikas Singh.
  1. Want to contribute a new model? We have added a **detailed guide and templates** to guide you in the process of adding a new model. You can find them in the [`templates`](./templates) folder of the repository. Be sure to check the [contributing guidelines](./CONTRIBUTING.md) and contact the maintainers or open an issue to collect feedbacks before starting your PR.

  To check if each model has an implementation in Flax, PyTorch or TensorFlow, or has an associated tokenizer backed by the 🤗 Tokenizers library, refer to [this table](https://huggingface.co/docs/transformers/index#supported-frameworks).

  These implementations have been tested on several datasets (see the example scripts) and should match the performance of the original implementations. You can find more details on performance in the Examples section of the [documentation](https://github.com/huggingface/transformers/tree/main/examples).




  | Section | Description |
  |-|-|
  | [Documentation](https://huggingface.co/docs/transformers/) | Full API documentation and tutorials |
  | [Task summary](https://huggingface.co/docs/transformers/task_summary) | Tasks supported by 🤗 Transformers |
  | [Preprocessing tutorial](https://huggingface.co/docs/transformers/preprocessing) | Using the `Tokenizer` class to prepare data for the models |
  | [Training and fine-tuning](https://huggingface.co/docs/transformers/training) | Using the models provided by 🤗 Transformers in a PyTorch/TensorFlow training loop and the `Trainer` API |
  | [Quick tour: Fine-tuning/usage scripts](https://github.com/huggingface/transformers/tree/main/examples) | Example scripts for fine-tuning models on a wide range of tasks |
  | [Model sharing and uploading](https://huggingface.co/docs/transformers/model_sharing) | Upload and share your fine-tuned models with the community |
  | [Migration](https://huggingface.co/docs/transformers/migration) | Migrate to 🤗 Transformers from `pytorch-transformers` or `pytorch-pretrained-bert` |



  We now have a [paper](https://www.aclweb.org/anthology/2020.emnlp-demos.6/) you can cite for the 🤗 Transformers library:
  ```bibtex
  @inproceedings{wolf-etal-2020-transformers,
      title = "Transformers: State-of-the-Art Natural Language Processing",
      author = "Thomas Wolf and Lysandre Debut and Victor Sanh and Julien Chaumond and Clement Delangue and Anthony Moi and Pierric Cistac and Tim Rault and Rémi Louf and Morgan Funtowicz and Joe Davison and Sam Shleifer and Patrick von Platen and Clara Ma and Yacine Jernite and Julien Plu and Canwen Xu and Teven Le Scao and Sylvain Gugger and Mariama Drame and Quentin Lhoest and Alexander M. Rush",
      booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
      month = oct,
      year = "2020",
      address = "Online",
      publisher = "Association for Computational Linguistics",
      url = "https://www.aclweb.org/anthology/2020.emnlp-demos.6",
      pages = "38--45"
  }
  ```


pkgId: f09b4f38121e10a4f0dd543e248b706d902c800d6c529851bb997ca3907a1398
name: python-transforms3d
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Functions for 3D coordinate transformations
url: http://github.com/matthew-brett/transforms3d
rpm_license: BSD license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-155bda9e-ff34-41c2-8f39-99f268a0850d
location_href: 00005329-python-transforms3d/python-transforms3d-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Transforms3d


  Code to convert between various geometric transformations.

  * Composing rotations / zooms / shears / translations into affine matrix;
  * Decomposing affine matrix into rotations / zooms / shears / translations;
  * Conversions between different representations of rotations, including:

    * 3x3 Rotation matrices;
    * Euler angles;
    * quaternions.

  We have tried to document the algorithms carefully and write clear code in the
  hope that this code can be a teaching reference.  We document the math behind
  some of the algorithms using `sympy <http://www.sympy.org>`_ in
  ``transforms3d/derivations``.  We would be very pleased if y'all would like to
  add your own algorithms and derivations - please get a copy of the code from
  https://github.com/matthew-brett/transforms3d and get on down,
  algorithmically.  Feel free to use the github issue tracker and pull request
  system to ask for advice and support.

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

  Documentation for latest released version at
  http://matthew-brett.github.io/transforms3d

  ****
  Code
  ****

  See https://github.com/matthew-brett/transforms3d

  Released under the BSD two-clause license - see the file ``LICENSE`` in the
  source distribution.

  Much of the code comes from `transformations.py
  <http://www.lfd.uci.edu/~gohlke/code/transformations.py.html>`_ by Christoph
  Gohlke, also released under the BSD license.

  We use Github actions to test the code automatically under Pythons 3.7 through
  3.10.

  We depend on numpy >= 1.15.  You may be able to make it work on an earlier
  numpy if you really needed that.

  The latest released version is at https://pypi.python.org/pypi/transforms3d

  *******
  Support
  *******

  Please put up issues on the `transforms3d issue tracker
  <https://github.com/matthew-brett/transforms3d/issues>`_.


pkgId: 74492b8dbe685a9abb99d5afeeb0d8ab56308ec04f7bcb6a138e73ea773d9cb1
name: python-transifex-client
arch: src
version: 0.14.4
epoch: 0
release: 1
summary: A command line interface for Transifex
url: https://www.transifex.com
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-79f2cbed-3196-40c2-8c01-3d5d783b88a1
location_href: 00011459-python-transifex-client/python-transifex-client-0.14.4-1.src.rpm
checksum_type: sha256
description:
  [![image](https://circleci.com/gh/transifex/transifex-client/tree/master.svg?style=shield&circle-token=33aafd984726261eff1b73278a0cf761382c478a)](https://circleci.com/gh/transifex/transifex-client/tree/master)
  [![image](https://ci.appveyor.com/api/projects/status/github/transifex/transifex-client?branch=master&svg=true)](https://ci.appveyor.com/project/transifex/transifex-client/branch/master)
  [![codecov](https://codecov.io/gh/transifex/transifex-client/branch/master/graph/badge.svg)](https://codecov.io/gh/transifex/transifex-client)
  [![PyPI version](https://badge.fury.io/py/transifex-client.svg)](https://badge.fury.io/py/transifex-client)
  > _⚠️ A new client, compatible with the [new API](https://transifex.github.io/openapi/), is under development. Check out the Alpha version [here](https://github.com/transifex/cli)._

  Whether you have experience with the command line or not, [this interactive tutorial](https://www.transifex.com/learn/txclient/) is intended for everyone who wishes to learn how the Transifex client works. There is no need to download anything - Just click on the link provided above, and follow the instructions.
  For more information about TX client, please visit our [documentation guide here](https://docs.transifex.com/client/introduction).


pkgId: 53b731194360920bcf93dd029de6dff1ca65da01e50f79e148474b1e0544d861
name: python-transitions
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: A lightweight, object-oriented Python state machine implementation with many extensions.
url: http://github.com/pytransitions/transitions
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1434ad66-e889-4793-b6d5-32c23d7bcb58
location_href: 00005330-python-transitions/python-transitions-0.9.0-1.src.rpm
checksum_type: sha256
description:
  They say [a good example is worth](https://www.google.com/webhp?ie=UTF-8#q=%22a+good+example+is+worth%22&start=20) 100 pages of API documentation, a million directives, or a thousand words.

  Well, "they" probably lie... but here's an example anyway:

  ```python
  from transitions import Machine
  import random

  class NarcolepticSuperhero(object):

      
      
      states = ['asleep', 'hanging out', 'hungry', 'sweaty', 'saving the world']

      def __init__(self, name):

          
          
          self.name = name

          
          self.kittens_rescued = 0

          
          self.machine = Machine(model=self, states=NarcolepticSuperhero.states, initial='asleep')

          
          
          

          
          self.machine.add_transition(trigger='wake_up', source='asleep', dest='hanging out')

          
          self.machine.add_transition('work_out', 'hanging out', 'hungry')

          
          self.machine.add_transition('eat', 'hungry', 'hanging out')

          
          
          self.machine.add_transition('distress_call', '*', 'saving the world',
                           before='change_into_super_secret_costume')

          
          
          
          self.machine.add_transition('complete_mission', 'saving the world', 'sweaty',
                           after='update_journal')

          
          
          self.machine.add_transition('clean_up', 'sweaty', 'asleep', conditions=['is_exhausted'])
          self.machine.add_transition('clean_up', 'sweaty', 'hanging out')

          
          self.machine.add_transition('nap', '*', 'asleep')

      def update_journal(self):
          """ Dear Diary, today I saved Mr. Whiskers. Again. """
          self.kittens_rescued += 1

      @property
      def is_exhausted(self):
          """ Basically a coin toss. """
          return random.random() < 0.5

      def change_into_super_secret_costume(self):
          print("Beauty, eh?")
  ```

  There, now you've baked a state machine into `NarcolepticSuperhero`. Let's take him/her/it out for a spin...

  ```python
  >>> batman = NarcolepticSuperhero("Batman")
  >>> batman.state
  'asleep'

  >>> batman.wake_up()
  >>> batman.state
  'hanging out'

  >>> batman.nap()
  >>> batman.state
  'asleep'

  >>> batman.clean_up()
  MachineError: "Can't trigger event clean_up from state asleep!"

  >>> batman.wake_up()
  >>> batman.work_out()
  >>> batman.state
  'hungry'


  >>> batman.kittens_rescued
  0


  >>> batman.distress_call()
  'Beauty, eh?'
  >>> batman.state
  'saving the world'


  >>> batman.complete_mission()
  >>> batman.state
  'sweaty'

  >>> batman.clean_up()
  >>> batman.state
  'asleep'   # Too tired to shower!


  >>> batman.kittens_rescued
  1
  ```

  While we cannot read the mind of the actual batman, we surely can visualize the current state of our `NarcolepticSuperhero`.

  ![batman diagram](https://user-images.githubusercontent.com/205986/104932302-c2f24580-59a7-11eb-8963-5dce738b9305.png)

  Have a look at the [Diagrams](#diagrams) extensions if you want to know how.





  Getting a state machine up and running is pretty simple. Let's say you have the object `lump` (an instance of class `Matter`), and you want to manage its states:

  ```python
  class Matter(object):
      pass

  lump = Matter()
  ```

  You can initialize a (_minimal_) working state machine bound to `lump` like this:

  ```python
  from transitions import Machine
  machine = Machine(model=lump, states=['solid', 'liquid', 'gas', 'plasma'], initial='solid')


  lump.state
  >>> 'solid'
  ```

  I say "minimal", because while this state machine is technically operational, it doesn't actually _do_ anything. It starts in the `'solid'` state, but won't ever move into another state, because no transitions are defined... yet!

  Let's try again.

  ```python

  states=['solid', 'liquid', 'gas', 'plasma']



  transitions = [
      { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' },
      { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' },
      { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' },
      { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' }
  ]


  machine = Machine(lump, states=states, transitions=transitions, initial='liquid')


  lump.state
  >>> 'liquid'


  lump.evaporate()
  lump.state
  >>> 'gas'
  lump.trigger('ionize')
  lump.state
  >>> 'plasma'
  ```

  Notice the shiny new methods attached to the `Matter` instance (`evaporate()`, `ionize()`, etc.). Each method triggers the corresponding transition. You don't have to explicitly define these methods anywhere; the name of each transition is bound to the model passed to the `Machine` initializer (in this case, `lump`).
  To be more precise, your model **should not** already contain methods with the same name as event triggers since `transitions` will only attach convenience methods to your model if the spot is not already taken.
  If you want to modify that behaviour, have a look at the [FAQ](examples/Frequently%20asked%20questions.ipynb).
  Furthermore, there is a method called `trigger` now attached to your model (if it hasn't been there before).
  This method lets you execute transitions by name in case dynamic triggering is required.



  The soul of any good state machine (and of many bad ones, no doubt) is a set of states. Above, we defined the valid model states by passing a list of strings to the `Machine` initializer. But internally, states are actually represented as `State` objects.

  You can initialize and modify States in a number of ways. Specifically, you can:

  - pass a string to the `Machine` initializer giving the name(s) of the state(s), or
  - directly initialize each new `State` object, or
  - pass a dictionary with initialization arguments

  The following snippets illustrate several ways to achieve the same goal:

  ```python

  from transitions import Machine, State




  states = [
      State(name='solid'),
      'liquid',
      { 'name': 'gas'}
      ]
  machine = Machine(lump, states)




  machine = Machine(lump)
  solid = State('solid')
  liquid = State('liquid')
  gas = State('gas')
  machine.add_states([solid, liquid, gas])
  ```

  States are initialized _once_ when added to the machine and will persist until they are removed from it. In other words: if you alter the attributes of a state object, this change will NOT be reset the next time you enter that state. Have a look at how to [extend state features](#state-features) in case you require some other behaviour.



  A `State` can also be associated with a list of `enter` and `exit` callbacks, which are called whenever the state machine enters or leaves that state. You can specify callbacks during initialization by passing them to a `State` object constructor, in a state property dictionary, or add them later.

  For convenience, whenever a new `State` is added to a `Machine`, the methods `on_enter_«state name»` and `on_exit_«state name»` are dynamically created on the Machine (not on the model!), which allow you to dynamically add new enter and exit callbacks later if you need them.

  ```python


  class Matter(object):
      def say_hello(self): print("hello, new state!")
      def say_goodbye(self): print("goodbye, old state!")

  lump = Matter()


  states = [
      State(name='solid', on_exit=['say_goodbye']),
      'liquid',
      { 'name': 'gas', 'on_exit': ['say_goodbye']}
      ]

  machine = Machine(lump, states=states)
  machine.add_transition('sublimate', 'solid', 'gas')





  machine.on_enter_gas('say_hello')


  machine.set_state('solid')
  lump.sublimate()
  >>> 'goodbye, old state!'
  >>> 'hello, new state!'
  ```

  Note that `on_enter_«state name»` callback will _not_ fire when a Machine is first initialized. For example if you have an `on_enter_A()` callback defined, and initialize the `Machine` with `initial='A'`, `on_enter_A()` will not be fired until the next time you enter state `A`. (If you need to make sure `on_enter_A()` fires at initialization, you can simply create a dummy initial state and then explicitly call `to_A()` inside the `__init__` method.)

  In addition to passing in callbacks when initializing a `State`, or adding them dynamically, it's also possible to define callbacks in the model class itself, which may increase code clarity. For example:

  ```python
  class Matter(object):
      def say_hello(self): print("hello, new state!")
      def say_goodbye(self): print("goodbye, old state!")
      def on_enter_A(self): print("We've just entered state A!")

  lump = Matter()
  machine = Machine(lump, states=['A', 'B', 'C'])
  ```

  Now, any time `lump` transitions to state `A`, the `on_enter_A()` method defined in the `Matter` class will fire.



  You can always check the current state of the model by either:

  - inspecting the `.state` attribute, or
  - calling `is_«state name»()`

  And if you want to retrieve the actual `State` object for the current state, you can do that through the `Machine` instance's `get_state()` method.

  ```python
  lump.state
  >>> 'solid'
  lump.is_gas()
  >>> False
  lump.is_solid()
  >>> True
  machine.get_state(lump.state).name
  >>> 'solid'
  ```

  If you'd like you can choose your own state attribute name by passing the `model_attribute` argument while initializing the `Machine`. This will also change the name of `is_«state name»()` to `is_«model_attribute»_«state name»()` though. Similarly, auto transitions will be named `to_«model_attribute»_«state name»()` instead of `to_«state name»()`. This is done to allow multiple machines to work on the same model with individual state attribute names.

  ```python
  lump = Matter()
  machine = Machine(lump, states=['solid', 'liquid', 'gas'],  model_attribute='matter_state', initial='solid')
  lump.matter_state
  >>> 'solid'

  lump.is_matter_state_solid()
  >>> True
  lump.to_matter_state_gas()
  >>> True
  ```



  So far we have seen how we can give state names and use these names to work with our state machine.
  If you favour stricter typing and more IDE code completion (or you just can't type 'sesquipedalophobia' any longer because the word scares you) using [Enumerations](https://docs.python.org/3/library/enum.html) might be what you are looking for:

  ```python
  import enum  # Python 2.7 users need to have 'enum34' installed
  from transitions import Machine

  class States(enum.Enum):
      ERROR = 0
      RED = 1
      YELLOW = 2
      GREEN = 3

  transitions = [['proceed', States.RED, States.YELLOW],
                 ['proceed', States.YELLOW, States.GREEN],
                 ['error', '*', States.ERROR]]

  m = Machine(states=States, transitions=transitions, initial=States.RED)
  assert m.is_RED()
  assert m.state is States.RED
  state = m.get_state(States.RED)  # get transitions.State object
  print(state.name)  # >>> RED
  m.proceed()
  m.proceed()
  assert m.is_GREEN()
  m.error()
  assert m.state is States.ERROR
  ```

  You can mix enums and strings if you like (e.g. `[States.RED, 'ORANGE', States.YELLOW, States.GREEN]`) but note that internally, `transitions` will still handle states by name (`enum.Enum.name`).
  Thus, it is not possible to have the states `'GREEN'` and `States.GREEN` at the same time.



  Some of the above examples already illustrate the use of transitions in passing, but here we'll explore them in more detail.

  As with states, each transition is represented internally as its own object – an instance of class `Transition`. The quickest way to initialize a set of transitions is to pass a dictionary, or list of dictionaries, to the `Machine` initializer. We already saw this above:

  ```python
  transitions = [
      { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' },
      { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' },
      { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' },
      { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' }
  ]
  machine = Machine(model=Matter(), states=states, transitions=transitions)
  ```

  Defining transitions in dictionaries has the benefit of clarity, but can be cumbersome. If you're after brevity, you might choose to define transitions using lists. Just make sure that the elements in each list are in the same order as the positional arguments in the `Transition` initialization (i.e., `trigger`, `source`, `destination`, etc.).

  The following list-of-lists is functionally equivalent to the list-of-dictionaries above:

  ```python
  transitions = [
      ['melt', 'solid', 'liquid'],
      ['evaporate', 'liquid', 'gas'],
      ['sublimate', 'solid', 'gas'],
      ['ionize', 'gas', 'plasma']
  ]
  ```

  Alternatively, you can add transitions to a `Machine` after initialization:

  ```python
  machine = Machine(model=lump, states=states, initial='solid')
  machine.add_transition('melt', source='solid', dest='liquid')
  ```

  The `trigger` argument defines the name of the new triggering method that gets attached to the base model. When this method is called, it will try to execute the transition:

  ```python
  >>> lump.melt()
  >>> lump.state
  'liquid'
  ```

  By default, calling an invalid trigger will raise an exception:

  ```python
  >>> lump.to_gas()
  >>> # This won't work because only objects in a solid state can melt
  >>> lump.melt()
  transitions.core.MachineError: "Can't trigger event melt from state gas!"
  ```

  This behavior is generally desirable, since it helps alert you to problems in your code. But in some cases, you might want to silently ignore invalid triggers. You can do this by setting `ignore_invalid_triggers=True` (either on a state-by-state basis, or globally for all states):

  ```python
  >>> # Globally suppress invalid trigger exceptions
  >>> m = Machine(lump, states, initial='solid', ignore_invalid_triggers=True)
  >>> # ...or suppress for only one group of states
  >>> states = ['new_state1', 'new_state2']
  >>> m.add_states(states, ignore_invalid_triggers=True)
  >>> # ...or even just for a single state. Here, exceptions will only be suppressed when the current state is A.
  >>> states = [State('A', ignore_invalid_triggers=True), 'B', 'C']
  >>> m = Machine(lump, states)
  >>> # ...this can be inverted as well if just one state should raise an exception
  >>> # since the machine's global value is not applied to a previously initialized state.
  >>> states = ['A', 'B', State('C')] # the default value for 'ignore_invalid_triggers' is False
  >>> m = Machine(lump, states, ignore_invalid_triggers=True)
  ```

  If you need to know which transitions are valid from a certain state, you can use `get_triggers`:

  ```python
  m.get_triggers('solid')
  >>> ['melt', 'sublimate']
  m.get_triggers('liquid')
  >>> ['evaporate']
  m.get_triggers('plasma')
  >>> []

  m.get_triggers('solid', 'liquid', 'gas', 'plasma')
  >>> ['melt', 'evaporate', 'sublimate', 'ionize']
  ```



  In addition to any transitions added explicitly, a `to_«state»()` method is created automatically whenever a state is added to a `Machine` instance. This method transitions to the target state no matter which state the machine is currently in:

  ```python
  lump.to_liquid()
  lump.state
  >>> 'liquid'
  lump.to_solid()
  lump.state
  >>> 'solid'
  ```

  If you desire, you can disable this behavior by setting `auto_transitions=False` in the `Machine` initializer.



  A given trigger can be attached to multiple transitions, some of which can potentially begin or end in the same state. For example:

  ```python
  machine.add_transition('transmogrify', ['solid', 'liquid', 'gas'], 'plasma')
  machine.add_transition('transmogrify', 'plasma', 'solid')

  machine.add_transition('transmogrify', 'plasma', 'gas')
  ```

  In this case, calling `transmogrify()` will set the model's state to `'solid'` if it's currently `'plasma'`, and set it to `'plasma'` otherwise. (Note that only the _first_ matching transition will execute; thus, the transition defined in the last line above won't do anything.)

  You can also make a trigger cause a transition from _all_ states to a particular destination by using the `'*'` wildcard:

  ```python
  machine.add_transition('to_liquid', '*', 'liquid')
  ```

  Note that wildcard transitions will only apply to states that exist at the time of the add_transition() call. Calling a wildcard-based transition when the model is in a state added after the transition was defined will elicit an invalid transition message, and will not transition to the target state.



  A reflexive trigger (trigger that has the same state as source and destination) can easily be added specifying `=` as destination.
  This is handy if the same reflexive trigger should be added to multiple states.
  For example:

  ```python
  machine.add_transition('touch', ['liquid', 'gas', 'plasma'], '=', after='change_shape')
  ```

  This will add reflexive transitions for all three states with `touch()` as trigger and with `change_shape` executed after each trigger.



  In contrast to reflexive transitions, internal transitions will never actually leave the state.
  This means that transition-related callbacks such as `before` or `after` will be processed while state-related callbacks `exit` or `enter` will not.
  To define a transition to be internal, set the destination to `None`.

  ```python
  machine.add_transition('internal', ['liquid', 'gas'], None, after='change_shape')
  ```



  A common desire is for state transitions to follow a strict linear sequence. For instance, given states `['A', 'B', 'C']`, you might want valid transitions for `A` → `B`, `B` → `C`, and `C` → `A` (but no other pairs).

  To facilitate this behavior, Transitions provides an `add_ordered_transitions()` method in the `Machine` class:

  ```python
  states = ['A', 'B', 'C']
   
  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions()
  machine.next_state()
  print(machine.state)
  >>> 'B'

  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions(['A', 'C', 'B'])
  machine.next_state()
  print(machine.state)
  >>> 'C'


  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions(conditions='check')


  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions(conditions=['check_A2B', ..., 'check_X2A'])

  machine = Machine(states=states, initial='B')
  machine.add_ordered_transitions(conditions=['check_B2C', ..., 'check_A2B'])


  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions(loop=False)
  machine.next_state()
  machine.next_state()
  machine.next_state() # transitions.core.MachineError: "Can't trigger event next_state from state C!"
  ```



  The default behaviour in Transitions is to process events instantly. This means events within an `on_enter` method will be processed _before_ callbacks bound to `after` are called.

  ```python
  def go_to_C():
      global machine
      machine.to_C()

  def after_advance():
      print("I am in state B now!")

  def entering_C():
      print("I am in state C now!")

  states = ['A', 'B', 'C']
  machine = Machine(states=states, initial='A')


  machine.add_transition('advance', 'A', 'B', after=after_advance)


  machine.on_enter_B(go_to_C)


  machine.on_enter_C(entering_C)
  machine.advance()
  >>> 'I am in state C now!'
  >>> 'I am in state B now!' # what?
  ```

  The execution order of this example is

  ```
  prepare -> before -> on_enter_B -> on_enter_C -> after.
  ```

  If queued processing is enabled, a transition will be finished before the next transition is triggered:

  ```python
  machine = Machine(states=states, queued=True, initial='A')
  ...
  machine.advance()
  >>> 'I am in state B now!'
  >>> 'I am in state C now!' # That's better!
  ```

  This results in

  ```
  prepare -> before -> on_enter_B -> queue(to_C) -> after  -> on_enter_C.
  ```

  **Important note:** when processing events in a queue, the trigger call will _always_ return `True`, since there is no way to determine at queuing time whether a transition involving queued calls will ultimately complete successfully. This is true even when only a single event is processed.

  ```python
  machine.add_transition('jump', 'A', 'C', conditions='will_fail')
  ...

  machine.jump()
  >>> False

  machine.jump()
  >>> True
  ```

  When a model is removed from the machine, `transitions` will also remove all related events from the queue.

  ```python
  class Model:
      def on_enter_B(self):
          self.to_C()  # add event to queue ...
          self.machine.remove_model(self)  # aaaand it's gone
  ```



  Sometimes you only want a particular transition to execute if a specific condition occurs. You can do this by passing a method, or list of methods, in the `conditions` argument:

  ```python

  class Matter(object):
      def is_flammable(self): return False
      def is_really_hot(self): return True

  machine.add_transition('heat', 'solid', 'gas', conditions='is_flammable')
  machine.add_transition('heat', 'solid', 'liquid', conditions=['is_really_hot'])
  ```

  In the above example, calling `heat()` when the model is in state `'solid'` will transition to state `'gas'` if `is_flammable` returns `True`. Otherwise, it will transition to state `'liquid'` if `is_really_hot` returns `True`.

  For convenience, there's also an `'unless'` argument that behaves exactly like conditions, but inverted:

  ```python
  machine.add_transition('heat', 'solid', 'gas', unless=['is_flammable', 'is_really_hot'])
  ```

  In this case, the model would transition from solid to gas whenever `heat()` fires, provided that both `is_flammable()` and `is_really_hot()` return `False`.

  Note that condition-checking methods will passively receive optional arguments and/or data objects passed to triggering methods. For instance, the following call:

  ```python
  lump.heat(temp=74)

  ```

  ... would pass the `temp=74` optional kwarg to the `is_flammable()` check (possibly wrapped in an `EventData` instance). For more on this, see the [Passing data](#passing-data) section below.



  If you want to check whether a transition is possible before you execute it ('look before you leap'), you can use `may_<trigger_name>` convenience functions that have been attached to your model:

  ```python

  if lump.may_heat():
      lump.heat()
  ```

  This will execute all `prepare` callbacks and evaluate the conditions assigned to the potential transitions.
  Transition checks can also be used when a transition's destination is not available (yet):

  ```python
  machine.add_transition('elevate', 'solid', 'spiritual')
  assert not lump.may_elevate()  # not ready yet :(
  ```



  You can attach callbacks to transitions as well as states. Every transition has `'before'` and `'after'` attributes that contain a list of methods to call before and after the transition executes:

  ```python
  class Matter(object):
      def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS")
      def disappear(self): print("where'd all the liquid go?")

  transitions = [
      { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'before': 'make_hissing_noises'},
      { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas', 'after': 'disappear' }
  ]

  lump = Matter()
  machine = Machine(lump, states, transitions=transitions, initial='solid')
  lump.melt()
  >>> "HISSSSSSSSSSSSSSSS"
  lump.evaporate()
  >>> "where'd all the liquid go?"
  ```

  There is also a `'prepare'` callback that is executed as soon as a transition starts, before any `'conditions'` are checked or other callbacks are executed.

  ```python
  class Matter(object):
      heat = False
      attempts = 0
      def count_attempts(self): self.attempts += 1
      def heat_up(self): self.heat = random.random() < 0.25
      def stats(self): print('It took you %i attempts to melt the lump!' %self.attempts)

      @property
      def is_really_hot(self):
          return self.heat


  states=['solid', 'liquid', 'gas', 'plasma']

  transitions = [
      { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'prepare': ['heat_up', 'count_attempts'], 'conditions': 'is_really_hot', 'after': 'stats'},
  ]

  lump = Matter()
  machine = Machine(lump, states, transitions=transitions, initial='solid')
  lump.melt()
  lump.melt()
  lump.melt()
  lump.melt()
  >>> "It took you 4 attempts to melt the lump!"
  ```

  Note that `prepare` will not be called unless the current state is a valid source for the named transition.

  Default actions meant to be executed before or after _every_ transition can be passed to `Machine` during initialization with
  `before_state_change` and `after_state_change` respectively:

  ```python
  class Matter(object):
      def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS")
      def disappear(self): print("where'd all the liquid go?")

  states=['solid', 'liquid', 'gas', 'plasma']

  lump = Matter()
  m = Machine(lump, states, before_state_change='make_hissing_noises', after_state_change='disappear')
  lump.to_gas()
  >>> "HISSSSSSSSSSSSSSSS"
  >>> "where'd all the liquid go?"
  ```

  There are also two keywords for callbacks which should be executed _independently_ a) of how many transitions are possible,
  b) if any transition succeeds and c) even if an error is raised during the execution of some other callback.
  Callbacks passed to `Machine` with `prepare_event` will be executed _once_ before processing possible transitions
  (and their individual `prepare` callbacks) takes place.
  Callbacks of `finalize_event` will be executed regardless of the success of the processed transitions.
  Note that if an error occurred it will be attached to `event_data` as `error` and can be retrieved with `send_event=True`.

  ```python
  from transitions import Machine

  class Matter(object):
      def raise_error(self, event): raise ValueError("Oh no")
      def prepare(self, event): print("I am ready!")
      def finalize(self, event): print("Result: ", type(event.error), event.error)

  states=['solid', 'liquid', 'gas', 'plasma']

  lump = Matter()
  m = Machine(lump, states, prepare_event='prepare', before_state_change='raise_error',
              finalize_event='finalize', send_event=True)
  try:
      lump.to_gas()
  except ValueError:
      pass
  print(lump.state)




  ```

  Sometimes things just don't work out as intended and we need to handle exceptions and clean up the mess to keep things going.
  We can pass callbacks to `on_exception` to do this:

  ```python
  from transitions import Machine

  class Matter(object):
      def raise_error(self, event): raise ValueError("Oh no")
      def handle_error(self, event):
          print("Fixing things ...")
          del event.error  # it did not happen if we cannot see it ...

  states=['solid', 'liquid', 'gas', 'plasma']

  lump = Matter()
  m = Machine(lump, states, before_state_change='raise_error', on_exception='handle_error', send_event=True)
  try:
      lump.to_gas()
  except ValueError:
      pass
  print(lump.state)



  ```



  As you have probably already realized, the standard way of passing callables to states, conditions and transitions is by name. When processing callbacks and conditions, `transitions` will use their name to retrieve the related callable from the model. If the method cannot be retrieved and it contains dots, `transitions` will treat the name as a path to a module function and try to import it. Alternatively, you can pass names of properties or attributes. They will be wrapped into functions but cannot receive event data for obvious reasons. You can also pass callables such as (bound) functions directly. As mentioned earlier, you can also pass lists/tuples of callables names to the callback parameters. Callbacks will be executed in the order they were added.

  ```python
  from transitions import Machine
  from mod import imported_func

  import random


  class Model(object):

      def a_callback(self):
          imported_func()

      @property
      def a_property(self):
          """ Basically a coin toss. """
          return random.random() < 0.5

      an_attribute = False


  model = Model()
  machine = Machine(model=model, states=['A'], initial='A')
  machine.add_transition('by_name', 'A', 'A', conditions='a_property', after='a_callback')
  machine.add_transition('by_reference', 'A', 'A', unless=['a_property', 'an_attribute'], after=model.a_callback)
  machine.add_transition('imported', 'A', 'A', after='mod.imported_func')

  model.by_name()
  model.by_reference()
  model.imported()
  ```

  The callable resolution is done in `Machine.resolve_callable`.
  This method can be overridden in case more complex callable resolution strategies are required.

  **Example**

  ```python
  class CustomMachine(Machine):
      @staticmethod
      def resolve_callable(func, event_data):
          
          super(CustomMachine, CustomMachine).resolve_callable(func, event_data)
  ```



  In summary, there are currently three ways to trigger events. You can call a model's convenience functions like `lump.melt()`,
  execute triggers by name such as `lump.trigger("melt")` or dispatch events on multiple models with `machine.dispatch("melt")`
  (see section about multiple models in [alternative initialization patterns](#alternative-initialization-patterns)).
  Callbacks on transitions are then executed in the following order:

  | Callback                        |    Current State     | Comments                                                                                    |
  | ------------------------------- | :------------------: | ------------------------------------------------------------------------------------------- |
  | `'machine.prepare_event'`       |       `source`       | executed _once_ before individual transitions are processed                                 |
  | `'transition.prepare'`          |       `source`       | executed as soon as the transition starts                                                   |
  | `'transition.conditions'`       |       `source`       | conditions _may_ fail and halt the transition                                               |
  | `'transition.unless'`           |       `source`       | conditions _may_ fail and halt the transition                                               |
  | `'machine.before_state_change'` |       `source`       | default callbacks declared on model                                                         |
  | `'transition.before'`           |       `source`       |                                                                                             |
  | `'state.on_exit'`               |       `source`       | callbacks declared on the source state                                                      |
  | `<STATE CHANGE>`                |                      |                                                                                             |
  | `'state.on_enter'`              |    `destination`     | callbacks declared on the destination state                                                 |
  | `'transition.after'`            |    `destination`     |                                                                                             |
  | `'machine.after_state_change'`  |    `destination`     | default callbacks declared on model                                                         |
  | `'machine.on_exception'`        | `source/destination` | callbacks will be executed when an exception has been raised                                |
  | `'machine.finalize_event'`      | `source/destination` | callbacks will be executed even if no transition took place or an exception has been raised |

  If any callback raises an exception, the processing of callbacks is not continued. This means that when an error occurs before the transition (in `state.on_exit` or earlier), it is halted. In case there is a raise after the transition has been conducted (in `state.on_enter` or later), the state change persists and no rollback is happening. Callbacks specified in `machine.finalize_event` will always be executed unless the exception is raised by a finalizing callback itself. Note that each callback sequence has to be finished before the next stage is executed. Blocking callbacks will halt the execution order and therefore block the `trigger` or `dispatch` call itself. If you want callbacks to be executed in parallel, you could have a look at the [extensions](#extensions) `AsyncMachine` for asynchronous processing or `LockedMachine` for threading.



  Sometimes you need to pass the callback functions registered at machine initialization some data that reflects the model's current state.
  Transitions allows you to do this in two different ways.

  First (the default), you can pass any positional or keyword arguments directly to the trigger methods (created when you call `add_transition()`):

  ```python
  class Matter(object):
      def __init__(self): self.set_environment()
      def set_environment(self, temp=0, pressure=101.325):
          self.temp = temp
          self.pressure = pressure
      def print_temperature(self): print("Current temperature is %d degrees celsius." % self.temp)
      def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure)

  lump = Matter()
  machine = Machine(lump, ['solid', 'liquid'], initial='solid')
  machine.add_transition('melt', 'solid', 'liquid', before='set_environment')

  lump.melt(45)  # positional arg;

  lump.print_temperature()
  >>> 'Current temperature is 45 degrees celsius.'

  machine.set_state('solid')  # reset state so we can melt again
  lump.melt(pressure=300.23)  # keyword args also work
  lump.print_pressure()
  >>> 'Current pressure is 300.23 kPa.'

  ```

  You can pass any number of arguments you like to the trigger.

  There is one important limitation to this approach: every callback function triggered by the state transition must be able to handle _all_ of the arguments. This may cause problems if the callbacks each expect somewhat different data.

  To get around this, Transitions supports an alternate method for sending data. If you set `send_event=True` at `Machine` initialization, all arguments to the triggers will be wrapped in an `EventData` instance and passed on to every callback. (The `EventData` object also maintains internal references to the source state, model, transition, machine, and trigger associated with the event, in case you need to access these for anything.)

  ```python
  class Matter(object):

      def __init__(self):
          self.temp = 0
          self.pressure = 101.325

      
      
      
      def set_environment(self, event):
          self.temp = event.kwargs.get('temp', 0)
          self.pressure = event.kwargs.get('pressure', 101.325)

      def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure)

  lump = Matter()
  machine = Machine(lump, ['solid', 'liquid'], send_event=True, initial='solid')
  machine.add_transition('melt', 'solid', 'liquid', before='set_environment')

  lump.melt(temp=45, pressure=1853.68)  # keyword args
  lump.print_pressure()
  >>> 'Current pressure is 1853.68 kPa.'

  ```



  In all of the examples so far, we've attached a new `Machine` instance to a separate model (`lump`, an instance of class `Matter`). While this separation keeps things tidy (because you don't have to monkey patch a whole bunch of new methods into the `Matter` class), it can also get annoying, since it requires you to keep track of which methods are called on the state machine, and which ones are called on the model that the state machine is bound to (e.g., `lump.on_enter_StateA()` vs. `machine.add_transition()`).

  Fortunately, Transitions is flexible, and supports two other initialization patterns.

  First, you can create a standalone state machine that doesn't require another model at all. Simply omit the model argument during initialization:

  ```python
  machine = Machine(states=states, transitions=transitions, initial='solid')
  machine.melt()
  machine.state
  >>> 'liquid'
  ```

  If you initialize the machine this way, you can then attach all triggering events (like `evaporate()`, `sublimate()`, etc.) and all callback functions directly to the `Machine` instance.

  This approach has the benefit of consolidating all of the state machine functionality in one place, but can feel a little bit unnatural if you think state logic should be contained within the model itself rather than in a separate controller.

  An alternative (potentially better) approach is to have the model inherit from the `Machine` class. Transitions is designed to support inheritance seamlessly. (just be sure to override class `Machine`'s `__init__` method!):

  ```python
  class Matter(Machine):
      def say_hello(self): print("hello, new state!")
      def say_goodbye(self): print("goodbye, old state!")

      def __init__(self):
          states = ['solid', 'liquid', 'gas']
          Machine.__init__(self, states=states, initial='solid')
          self.add_transition('melt', 'solid', 'liquid')

  lump = Matter()
  lump.state
  >>> 'solid'
  lump.melt()
  lump.state
  >>> 'liquid'
  ```

  Here you get to consolidate all state machine functionality into your existing model, which often feels more natural than sticking all of the functionality we want in a separate standalone `Machine` instance.

  A machine can handle multiple models which can be passed as a list like `Machine(model=[model1, model2, ...])`.
  In cases where you want to add models _as well as_ the machine instance itself, you can pass the class variable placeholder (string) `Machine.self_literal` during initialization like `Machine(model=[Machine.self_literal, model1, ...])`.
  You can also create a standalone machine, and register models dynamically via `machine.add_model` by passing `model=None` to the constructor.
  Furthermore, you can use `machine.dispatch` to trigger events on all currently added models.
  Remember to call `machine.remove_model` if machine is long-lasting and your models are temporary and should be garbage collected:

  ```python
  class Matter():
      pass

  lump1 = Matter()
  lump2 = Matter()


  machine = Machine(model=None, states=states, transitions=transitions, initial='solid')

  machine.add_model(lump1)
  machine.add_model(lump2, initial='liquid')

  lump1.state
  >>> 'solid'
  lump2.state
  >>> 'liquid'


  machine.dispatch("to_plasma")

  lump1.state
  >>> 'plasma'
  assert lump1.state == lump2.state

  machine.remove_model([lump1, lump2])
  del lump1  # lump1 is garbage collected
  del lump2  # lump2 is garbage collected
  ```

  If you don't provide an initial state in the state machine constructor, `transitions` will create and add a default state called `'initial'`.
  If you do not want a default initial state, you can pass `initial=None`.
  However, in this case you need to pass an initial state every time you add a model.

  ```python
  machine = Machine(model=None, states=states, transitions=transitions, initial=None)

  machine.add_model(Matter())
  >>> "MachineError: No initial state configured for machine, must specify when adding model."
  machine.add_model(Matter(), initial='liquid')
  ```

  Models with multiple states could attach multiple machines using different `model_attribute` values. As mentioned in [Checking state](#checking-state), this will add custom `is/to_<model_attribute>_<state_name>` functions:

  ```python
  lump = Matter()

  matter_machine = Machine(lump, states=['solid', 'liquid', 'gas'], initial='solid')

  shipment_machine = Machine(lump, states=['delivered', 'shipping'], initial='delivered', model_attribute='shipping_state')

  lump.state
  >>> 'solid'
  lump.is_solid()  # check the default field
  >>> True
  lump.shipping_state
  >>> 'delivered'
  lump.is_shipping_state_delivered()  # check the custom field.
  >>> True
  lump.to_shipping_state_shipping()
  >>> True
  lump.is_shipping_state_delivered()
  >>> False
  ```



  Transitions includes very rudimentary logging capabilities. A number of events – namely, state changes, transition triggers, and conditional checks – are logged as INFO-level events using the standard Python `logging` module. This means you can easily configure logging to standard output in a script:

  ```python

  import logging
  logging.basicConfig(level=logging.DEBUG)

  logging.getLogger('transitions').setLevel(logging.INFO)


  machine = Machine(states=states, transitions=transitions, initial='solid')
  ...
  ```



  Machines are picklable and can be stored and loaded with `pickle`. For Python 3.3 and earlier `dill` is required.

  ```python
  import dill as pickle # only required for Python 3.3 and earlier

  m = Machine(states=['A', 'B', 'C'], initial='A')
  m.to_B()
  m.state
  >>> B


  dump = pickle.dumps(m)


  m2 = pickle.loads(dump)

  m2.state
  >>> B

  m2.states.keys()
  >>> ['A', 'B', 'C']
  ```



  Even though the core of transitions is kept lightweight, there are a variety of MixIns to extend its functionality. Currently supported are:

  - **Diagrams** to visualize the current state of a machine
  - **Hierarchical State Machines** for nesting and reuse
  - **Threadsafe Locks** for parallel execution
  - **Async callbacks** for asynchronous execution
  - **Custom States** for extended state-related behaviour

  There are two mechanisms to retrieve a state machine instance with the desired features enabled.
  The first approach makes use of the convenience `factory` with the four parameters `graph`, `nested`, `locked` or `asyncio` set to `True` if the feature is required:

  ```python
  from transitions.extensions import MachineFactory


  diagram_cls = MachineFactory.get_predefined(graph=True)
  nested_locked_cls = MachineFactory.get_predefined(nested=True, locked=True)
  async_machine_cls = MachineFactory.get_predefined(asyncio=True)



  machine1 = diagram_cls(model, state, transitions)
  machine2 = nested_locked_cls(model, state, transitions)
  ```

  This approach targets experimental use since in this case the underlying classes do not have to be known.
  However, classes can also be directly imported from `transitions.extensions`. The naming scheme is as follows:

  |                                | Diagrams | Nested | Locked | Asyncio |
  | -----------------------------: | :------: | :----: | :----: | :-----: |
  |                        Machine |    ✘     |   ✘    |   ✘    |    ✘    |
  |                   GraphMachine |    ✓     |   ✘    |   ✘    |    ✘    |
  |            HierarchicalMachine |    ✘     |   ✓    |   ✘    |    ✘    |
  |                  LockedMachine |    ✘     |   ✘    |   ✓    |    ✘    |
  |       HierarchicalGraphMachine |    ✓     |   ✓    |   ✘    |    ✘    |
  |             LockedGraphMachine |    ✓     |   ✘    |   ✓    |    ✘    |
  |      LockedHierarchicalMachine |    ✘     |   ✓    |   ✓    |    ✘    |
  | LockedHierarchicalGraphMachine |    ✓     |   ✓    |   ✓    |    ✘    |
  |                   AsyncMachine |    ✘     |   ✘    |   ✘    |    ✓    |
  |              AsyncGraphMachine |    ✓     |   ✘    |   ✘    |    ✓    |
  |       HierarchicalAsyncMachine |    ✘     |   ✓    |   ✘    |    ✓    |
  |  HierarchicalAsyncGraphMachine |    ✓     |   ✓    |   ✘    |    ✓    |

  To use a feature-rich state machine, one could write:

  ```python
  from transitions.extensions import LockedHierarchicalGraphMachine as LHGMachine

  machine = LHGMachine(model, states, transitions)
  ```



  Additional Keywords:

  - `title` (optional): Sets the title of the generated image.
  - `show_conditions` (default False): Shows conditions at transition edges
  - `show_auto_transitions` (default False): Shows auto transitions in graph
  - `show_state_attributes` (default False): Show callbacks (enter, exit), tags and timeouts in graph

  Transitions can generate basic state diagrams displaying all valid transitions between states. To use the graphing functionality, you'll need to have `graphviz` and/or `pygraphviz` installed:
  To generate graphs with the package `graphviz`, you need to install [Graphviz](https://graphviz.org/) manually or via a package manager.

      sudo apt-get install graphviz graphviz-dev  # Ubuntu and Debian
      brew install graphviz  # MacOS
      conda install graphviz python-graphviz  # (Ana)conda

  Now you can install the actual Python packages

      pip install graphviz pygraphviz # install graphviz and/or pygraphviz manually...
      pip install transitions[diagrams]  # ... or install transitions with 'diagrams' extras which currently depends on pygraphviz

  Currently, `GraphMachine` will use `pygraphviz` when available and fall back to `graphviz` when `pygraphviz` cannot be
  found. This can be overridden by passing `use_pygraphviz=False` to the constructor. Note that this default might change
  in the future and `pygraphviz` support may be dropped.
  With `Model.get_graph()` you can get the current graph or the region of interest (roi) and draw it like this:

  ```python


  from transitions.extensions import GraphMachine
  m = Model()

  machine = GraphMachine(model=m, ...)

  machine = GraphMachine(model=m, use_pygraphviz=False, ...)

  machine = GraphMachine(model=m, show_auto_transitions=True, ...)


  m.get_graph().draw('my_state_diagram.png', prog='dot')


  roi = m.get_graph(show_roi=True).draw('my_state_diagram.png', prog='dot')
  ```

  This produces something like this:

  ![state diagram example](https://user-images.githubusercontent.com/205986/47524268-725c1280-d89a-11e8-812b-1d3b6e667b91.png)

  Independent of the backend you use, the draw function also accepts a file descriptor or a binary stream as the first argument. If you set this parameter to `None`, the byte stream will be returned:

  ```python
  import io

  with open('a_graph.png', 'bw') as f:
      
      m.get_graph().draw(f, format="png", prog='dot')


  b = io.BytesIO()
  m.get_graph().draw(b, format="png", prog='dot')


  result = m.get_graph().draw(None, format="png", prog='dot')
  assert result == b.getvalue()
  ```

  References and partials passed as callbacks will be resolved as good as possible:

  ```python
  from transitions.extensions import GraphMachine
  from functools import partial


  class Model:

      def clear_state(self, deep=False, force=False):
          print("Clearing state ...")
          return True


  model = Model()
  machine = GraphMachine(model=model, states=['A', 'B', 'C'],
                         transitions=[
                             {'trigger': 'clear', 'source': 'B', 'dest': 'A', 'conditions': model.clear_state},
                             {'trigger': 'clear', 'source': 'C', 'dest': 'A',
                              'conditions': partial(model.clear_state, False, force=True)},
                         ],
                         initial='A', show_conditions=True)

  model.get_graph().draw('my_state_diagram.png', prog='dot')
  ```

  This should produce something similar to this:

  ![state diagram references_example](https://user-images.githubusercontent.com/205986/110783076-39087f80-8268-11eb-8fa1-fc7bac97f4cf.png)

  If the format of references does not suit your needs, you can override the static method `GraphMachine.format_references`. If you want to skip reference entirely, just let `GraphMachine.format_references` return `None`.
  Also, have a look at our [example](./examples) IPython/Jupyter notebooks for a more detailed example about how to use and edit graphs.



  Transitions includes an extension module which allows nesting states.
  This allows us to create contexts and to model cases where states are related to certain subtasks in the state machine.
  To create a nested state, either import `NestedState` from transitions or use a dictionary with the initialization arguments `name` and `children`.
  Optionally, `initial` can be used to define a sub state to transit to, when the nested state is entered.

  ```python
  from transitions.extensions import HierarchicalMachine

  states = ['standing', 'walking', {'name': 'caffeinated', 'children':['dithering', 'running']}]
  transitions = [
    ['walk', 'standing', 'walking'],
    ['stop', 'walking', 'standing'],
    ['drink', '*', 'caffeinated'],
    ['walk', ['caffeinated', 'caffeinated_dithering'], 'caffeinated_running'],
    ['relax', 'caffeinated', 'standing']
  ]

  machine = HierarchicalMachine(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True)

  machine.walk() # Walking now
  machine.stop() # let's stop for a moment
  machine.drink() # coffee time
  machine.state
  >>> 'caffeinated'
  machine.walk() # we have to go faster
  machine.state
  >>> 'caffeinated_running'
  machine.stop() # can't stop moving!
  machine.state
  >>> 'caffeinated_running'
  machine.relax() # leave nested state
  machine.state # phew, what a ride
  >>> 'standing'

  ```

  A configuration making use of `initial` could look like this:

  ```python

  states = ['standing', 'walking', {'name': 'caffeinated', 'initial': 'dithering', 'children': ['dithering', 'running']}]
  transitions = [
    ['walk', 'standing', 'walking'],
    ['stop', 'walking', 'standing'],
    
    ['drink', '*', 'caffeinated'],
    
    ['walk', 'caffeinated_dithering', 'caffeinated_running'],
    ['relax', 'caffeinated', 'standing']
  ]

  ```

  The `initial` keyword of the `HierarchicalMachine` constructor accepts nested states (e.g. `initial='caffeinated_running'`) and a list of states which is considered to be a parallel state (e.g. `initial=['A', 'B']`) or the current state of another model (`initial=model.state`) which should be effectively one of the previous mentioned options. Note that when passing a string, `transition` will check the targeted state for `initial` substates and use this as an entry state. This will be done recursively until a substate does not mention an initial state. Parallel states or a state passed as a list will be used 'as is' and no further initial evaluation will be conducted.

  Note that your previously created state object _must be_ a `NestedState` or a derived class of it.
  The standard `State` class used in simple `Machine` instances lacks features required for nesting.

  ```python
  from transitions.extensions.nesting import HierarchicalMachine, NestedState
  from transitions import  State
  m = HierarchicalMachine(states=['A'], initial='initial')
  m.add_state('B')  # fine
  m.add_state({'name': 'C'})  # also fine
  m.add_state(NestedState('D'))  # fine as well
  m.add_state(State('E'))  # does not work!
  ```

  Some things that have to be considered when working with nested states: State _names are concatenated_ with `NestedState.separator`.
  Currently the separator is set to underscore ('\_') and therefore behaves similar to the basic machine.
  This means a substate `bar` from state `foo` will be known by `foo_bar`. A substate `baz` of `bar` will be referred to as `foo_bar_baz` and so on.
  When entering a substate, `enter` will be called for all parent states. The same is true for exiting substates.
  Third, nested states can overwrite transition behaviour of their parents.
  If a transition is not known to the current state it will be delegated to its parent.

  **This means that in the standard configuration, state names in HSMs MUST NOT contain underscores.**
  For `transitions` it's impossible to tell whether `machine.add_state('state_name')` should add a state named `state_name` or add a substate `name` to the state `state`.
  In some cases this is not sufficient however.
  For instance if state names consist of more than one word and you want/need to use underscore to separate them instead of `CamelCase`.
  To deal with this, you can change the character used for separation quite easily.
  You can even use fancy unicode characters if you use Python 3.
  Setting the separator to something else than underscore changes some of the behaviour (auto_transition and setting callbacks) though:

  ```python
  from transitions.extensions import HierarchicalMachine
  from transitions.extensions.nesting import NestedState
  NestedState.separator = '↦'
  states = ['A', 'B',
    {'name': 'C', 'children':['1', '2',
      {'name': '3', 'children': ['a', 'b', 'c']}
    ]}
  ]

  transitions = [
      ['reset', 'C', 'A'],
      ['reset', 'C↦2', 'C']  # overwriting parent reset
  ]


  machine = HierarchicalMachine(states=states, transitions=transitions, initial='A')
  machine.to_B()  # exit state A, enter state B
  machine.to_C()  # exit B, enter C
  machine.to_C.s3.a()  # enter C↦a; enter C↦3↦a;
  machine.state
  >>> 'C↦3↦a'
  assert machine.is_C.s3.a()
  machine.to('C↦2')  # not interactive; exit C↦3↦a, exit C↦3, enter C↦2
  machine.reset()  # exit C↦2; reset C has been overwritten by C↦3
  machine.state
  >>> 'C'
  machine.reset()  # exit C, enter A
  machine.state
  >>> 'A'

  ```

  Instead of `to_C_3_a()` auto transition is called as `to_C.s3.a()`. If your substate starts with a digit, transitions adds a prefix 's' ('3' becomes 's3') to the auto transition `FunctionWrapper` to comply with the attribute naming scheme of Python.
  If interactive completion is not required, `to('C↦3↦a')` can be called directly. Additionally, `on_enter/exit_<<state name>>` is replaced with `on_enter/exit(state_name, callback)`. State checks can be conducted in a similar fashion. Instead of `is_C_3_a()`, the `FunctionWrapper` variant `is_C.s3.a()` can be used.

  To check whether the current state is a substate of a specific state, `is_state` supports the keyword `allow_substates`:

  ```python
  machine.state
  >>> 'C.2.a'
  machine.is_C() # checks for specific states
  >>> False
  machine.is_C(allow_substates=True)
  >>> True
  assert machine.is_C.s2() is False
  assert machine.is_C.s2(allow_substates=True)  # FunctionWrapper support allow_substate as well
  ```

  _new in 0.8.0_
  You can use enumerations in HSMs as well but keep in mind that `Enum` are compared by value.
  If you have a value more than once in a state tree those states cannot be distinguished.

  ```python
  states = [States.RED, States.YELLOW, {'name': States.GREEN, 'children': ['tick', 'tock']}]
  states = ['A', {'name': 'B', 'children': states, 'initial': States.GREEN}, States.GREEN]
  machine = HierarchicalMachine(states=states)
  machine.to_B()
  machine.is_GREEN()  # returns True even though the actual state is B_GREEN
  ```

  _new in 0.8.0_
  `HierarchicalMachine` has been rewritten from scratch to support parallel states and better isolation of nested states.
  This involves some tweaks based on community feedback.
  To get an idea of processing order and configuration have a look at the following example:

  ```python
  from transitions.extensions.nesting import HierarchicalMachine
  import logging
  states = ['A', 'B', {'name': 'C', 'parallel': [{'name': '1', 'children': ['a', 'b', 'c'], 'initial': 'a',
                                                  'transitions': [['go', 'a', 'b']]},
                                                 {'name': '2', 'children': ['x', 'y', 'z'], 'initial': 'z'}],
                        'transitions': [['go', '2_z', '2_x']]}]

  transitions = [['reset', 'C_1_b', 'B']]
  logging.basicConfig(level=logging.INFO)
  machine = HierarchicalMachine(states=states, transitions=transitions, initial='A')
  machine.to_C()






  machine.go()




  machine.reset()






  ```

  When using `parallel` instead of `children`, `transitions` will enter all states of the passed list at the same time.
  Which substate to enter is defined by `initial` which should _always_ point to a direct substate.
  A novel feature is to define local transitions by passing the `transitions` keyword in a state definition.
  The above defined transition `['go', 'a', 'b']` is only valid in `C_1`.
  While you can reference substates as done in `['go', '2_z', '2_x']` you cannot reference parent states directly in locally defined transitions.
  When a parent state is exited, its children will also be exited.
  In addition to the processing order of transitions known from `Machine` where transitions are considered in the order they were added, `HierarchicalMachine` considers hierarchy as well.
  Transitions defined in substates will be evaluated first (e.g. `C_1_a` is left before `C_2_z`) and transitions defined with wildcard `*` will (for now) only add transitions to root states (in this example `A`, `B`, `C`)
  Starting with _0.8.0_ nested states can be added directly and will issue the creation of parent states on-the-fly:

  ```python
  m = HierarchicalMachine(states=['A'], initial='A')
  m.add_state('B_1_a')
  m.to_B_1()
  assert m.is_B(allow_substates=True)
  ```



  Besides semantic order, nested states are very handy if you want to specify state machines for specific tasks and plan to reuse them.
  Before _0.8.0_, a `HierarchicalMachine` would not integrate the machine instance itself but the states and transitions by creating copies of them.
  However, since _0.8.0_ `(Nested)State` instances are just **referenced** which means changes in one machine's collection of states and events will influence the other machine instance. Models and their state will not be shared though.
  Note that events and transitions are also copied by reference and will be shared by both instances if you do not use the `remap` keyword.
  This change was done to be more in line with `Machine` which also uses passed `State` instances by reference.

  ```python
  count_states = ['1', '2', '3', 'done']
  count_trans = [
      ['increase', '1', '2'],
      ['increase', '2', '3'],
      ['decrease', '3', '2'],
      ['decrease', '2', '1'],
      ['done', '3', 'done'],
      ['reset', '*', '1']
  ]

  counter = HierarchicalMachine(states=count_states, transitions=count_trans, initial='1')

  counter.increase() # love my counter
  states = ['waiting', 'collecting', {'name': 'counting', 'children': counter}]

  transitions = [
      ['collect', '*', 'collecting'],
      ['wait', '*', 'waiting'],
      ['count', 'collecting', 'counting']
  ]

  collector = HierarchicalMachine(states=states, transitions=transitions, initial='waiting')
  collector.collect()  # collecting
  collector.count()  # let's see what we got; counting_1
  collector.increase()  # counting_2
  collector.increase()  # counting_3
  collector.done()  # collector.state == counting_done
  collector.wait()  # collector.state == waiting
  ```

  If a `HierarchicalMachine` is passed with the `children` keyword, the initial state of this machine will be assigned to the new parent state.
  In the above example we see that entering `counting` will also enter `counting_1`.
  If this is undesired behaviour and the machine should rather halt in the parent state, the user can pass `initial` as `False` like `{'name': 'counting', 'children': counter, 'initial': False}`.

  Sometimes you want such an embedded state collection to 'return' which means after it is done it should exit and transit to one of your super states.
  To achieve this behaviour you can remap state transitions.
  In the example above we would like the counter to return if the state `done` was reached.
  This is done as follows:

  ```python
  states = ['waiting', 'collecting', {'name': 'counting', 'children': counter, 'remap': {'done': 'waiting'}}]

  ... # same as above

  collector.increase() # counting_3
  collector.done()
  collector.state
  >>> 'waiting' # be aware that 'counting_done' will be removed from the state machine
  ```

  As mentioned above, using `remap` will **copy** events and transitions since they could not be valid in the original state machine.
  If a reused state machine does not have a final state, you can of course add the transitions manually.
  If 'counter' had no 'done' state, we could just add `['done', 'counter_3', 'waiting']` to achieve the same behaviour.

  In cases where you want states and transitions to be copied by value rather than reference (for instance, if you want to keep the pre-0.8 behaviour) you can do so by creating a `NestedState` and assigning deep copies of the machine's events and states to it.

  ```python
  from transitions.extensions.nesting import NestedState
  from copy import deepcopy



  counting_state = NestedState(name="counting", initial='1')
  counting_state.states = deepcopy(counter.states)
  counting_state.events = deepcopy(counter.events)

  states = ['waiting', 'collecting', counting_state]
  ```

  For complex state machines, sharing configurations rather than instantiated machines might be more feasible.
  Especially since instantiated machines must be derived from `HierarchicalMachine`.
  Such configurations can be stored and loaded easily via JSON or YAML (see the [FAQ](examples/Frequently%20asked%20questions.ipynb)).
  `HierarchicalMachine` allows defining substates either with the keyword `children` or `states`.
  If both are present, only `children` will be considered.

  ```python
  counter_conf = {
      'name': 'counting',
      'states': ['1', '2', '3', 'done'],
      'transitions': [
          ['increase', '1', '2'],
          ['increase', '2', '3'],
          ['decrease', '3', '2'],
          ['decrease', '2', '1'],
          ['done', '3', 'done'],
          ['reset', '*', '1']
      ],
      'initial': '1'
  }

  collector_conf = {
      'name': 'collector',
      'states': ['waiting', 'collecting', counter_conf],
      'transitions': [
          ['collect', '*', 'collecting'],
          ['wait', '*', 'waiting'],
          ['count', 'collecting', 'counting']
      ],
      'initial': 'waiting'
  }

  collector = HierarchicalMachine(**collector_conf)
  collector.collect()
  collector.count()
  collector.increase()
  assert collector.is_counting_2()
  ```



  In cases where event dispatching is done in threads, one can use either `LockedMachine` or `LockedHierarchicalMachine` where **function access** (!sic) is secured with reentrant locks.
  This does not save you from corrupting your machine by tinkering with member variables of your model or state machine.

  ```python
  from transitions.extensions import LockedMachine
  from threading import Thread
  import time

  states = ['A', 'B', 'C']
  machine = LockedMachine(states=states, initial='A')


  thread = Thread(target=machine.to_B)
  thread.start()
  time.sleep(0.01) # thread requires some time to start
  machine.to_C() # synchronized access; won't execute before thread is done

  thread = Thread(target=machine.to_B)
  thread.start()
  machine.new_attrib = 42 # not synchronized! will mess with execution order
  ```

  Any python context manager can be passed in via the `machine_context` keyword argument:

  ```python
  from transitions.extensions import LockedMachine
  from threading import RLock

  states = ['A', 'B', 'C']

  lock1 = RLock()
  lock2 = RLock()

  machine = LockedMachine(states=states, initial='A', machine_context=[lock1, lock2])
  ```

  Any contexts via `machine_model` will be shared between all models registered with the `Machine`.
  Per-model contexts can be added as well:

  ```python
  lock3 = RLock()

  machine.add_model(model, model_context=lock3)
  ```

  It's important that all user-provided context managers are re-entrant since the state machine will call them multiple
  times, even in the context of a single trigger invocation.



  If you are using Python 3.7 or later, you can use `AsyncMachine` to work with asynchronous callbacks.
  You can mix synchronous and asynchronous callbacks if you like but this may have undesired side effects.
  Note that events need to be awaited and the event loop must also be handled by you.

  ```python
  from transitions.extensions.asyncio import AsyncMachine
  import asyncio
  import time


  class AsyncModel:

      def prepare_model(self):
          print("I am synchronous.")
          self.start_time = time.time()

      async def before_change(self):
          print("I am asynchronous and will block now for 100 milliseconds.")
          await asyncio.sleep(0.1)
          print("I am done waiting.")

      def sync_before_change(self):
          print("I am synchronous and will block the event loop (what I probably shouldn't)")
          time.sleep(0.1)
          print("I am done waiting synchronously.")

      def after_change(self):
          print(f"I am synchronous again. Execution took {int((time.time() - self.start_time) * 1000)} ms.")


  transition = dict(trigger="start", source="Start", dest="Done", prepare="prepare_model",
                    before=["before_change"] * 5 + ["sync_before_change"],
                    after="after_change")  # execute before function in asynchronously 5 times
  model = AsyncModel()
  machine = AsyncMachine(model, states=["Start", "Done"], transitions=[transition], initial='Start')

  asyncio.get_event_loop().run_until_complete(model.start())














  assert model.is_Done()
  ```

  So, why do you need to use Python 3.7 or later you may ask.
  Async support has been introduced earlier.
  `AsyncMachine` makes use of `contextvars` to handle running callbacks when new events arrive before a transition
  has been finished:

  ```python
  async def await_never_return():
      await asyncio.sleep(100)
      raise ValueError("That took too long!")

  async def fix():
      await m2.fix()

  m1 = AsyncMachine(states=['A', 'B', 'C'], initial='A', name="m1")
  m2 = AsyncMachine(states=['A', 'B', 'C'], initial='A', name="m2")
  m2.add_transition(trigger='go', source='A', dest='B', before=await_never_return)
  m2.add_transition(trigger='fix', source='A', dest='C')
  m1.add_transition(trigger='go', source='A', dest='B', after='go')
  m1.add_transition(trigger='go', source='B', dest='C', after=fix)
  asyncio.get_event_loop().run_until_complete(asyncio.gather(m2.go(), m1.go()))

  assert m1.state == m2.state
  ```

  This example actually illustrates two things:
  First, that 'go' called in m1's transition from `A` to be `B` is not cancelled and second, calling `m2.fix()` will
  halt the transition attempt of m2 from `A` to `B` by executing 'fix' from `A` to `C`.
  This separation would not be possible without `contextvars`.
  Note that `prepare` and `conditions` are NOT treated as ongoing transitions.
  This means that after `conditions` have been evaluated, a transition is executed even though another event already happened.
  Tasks will only be cancelled when run as a `before` callback or later.

  `AsyncMachine` features a model-special queue mode which can be used when `queued='model'` is passed to the constructor.
  With a model-specific queue, events will only be queued when they belong to the same model.
  Furthermore, a raised exception will only clear the event queue of the model that raised that exception.
  For the sake of simplicity, let's assume that every event in `asyncio.gather` below is not triggered at the same time but slightly delayed:

  ```python
  asyncio.gather(model1.event1(), model1.event2(), model2.event1())





  asyncio.gather(model1.event1(), model1.error(), model1.event3(), model2.event1(), model2.event2(), model2.event3())




  ```

  Note that queue modes must not be changed after machine construction.



  If your superheroes need some custom behaviour, you can throw in some extra functionality by decorating machine states:

  ```python
  from time import sleep
  from transitions import Machine
  from transitions.extensions.states import add_state_features, Tags, Timeout


  @add_state_features(Tags, Timeout)
  class CustomStateMachine(Machine):
      pass


  class SocialSuperhero(object):
      def __init__(self):
          self.entourage = 0

      def on_enter_waiting(self):
          self.entourage += 1


  states = [{'name': 'preparing', 'tags': ['home', 'busy']},
            {'name': 'waiting', 'timeout': 1, 'on_timeout': 'go'},
            {'name': 'away'}]  # The city needs us!

  transitions = [['done', 'preparing', 'waiting'],
                 ['join', 'waiting', 'waiting'],  # Entering Waiting again will increase our entourage
                 ['go', 'waiting', 'away']]  # Okay, let' move

  hero = SocialSuperhero()
  machine = CustomStateMachine(model=hero, states=states, transitions=transitions, initial='preparing')
  assert hero.state == 'preparing'  # Preparing for the night shift
  assert machine.get_state(hero.state).is_busy  # We are at home and busy
  hero.done()
  assert hero.state == 'waiting'  # Waiting for fellow superheroes to join us
  assert hero.entourage == 1  # It's just us so far
  sleep(0.7)  # Waiting...
  hero.join()  # Weeh, we got company
  sleep(0.5)  # Waiting...
  hero.join()  # Even more company \o/
  sleep(2)  # Waiting...
  assert hero.state == 'away'  # Impatient superhero already left the building
  assert machine.get_state(hero.state).is_home is False  # Yupp, not at home anymore
  assert hero.entourage == 3  # At least he is not alone
  ```

  Currently, transitions comes equipped with the following state features:

  - **Timeout** -- triggers an event after some time has passed

    - keyword: `timeout` (int, optional) -- if passed, an entered state will timeout after `timeout` seconds
    - keyword: `on_timeout` (string/callable, optional) -- will be called when timeout time has been reached
    - will raise an `AttributeError` when `timeout` is set but `on_timeout` is not
    - Note: A timeout is triggered in a thread. This implies several limitations (e.g. catching Exceptions raised in timeouts). Consider an event queue for more sophisticated applications.

  - **Tags** -- adds tags to states

    - keyword: `tags` (list, optional) -- assigns tags to a state
    - `State.is_<tag_name>` will return `True` when the state has been tagged with `tag_name`, else `False`

  - **Error** -- raises a `MachineError` when a state cannot be left
    - inherits from `Tags` (if you use `Error` do not use `Tags`)
    - keyword: `accepted` (bool, optional) -- marks a state as accepted
    - alternatively the keyword `tags` can be passed, containing 'accepted'
    - Note: Errors will only be raised if `auto_transitions` has been set to `False`. Otherwise every state can be exited with `to_<state>` methods.
  - **Volatile** -- initialises an object every time a state is entered
    - keyword: `volatile` (class, optional) -- every time the state is entered an object of type class will be assigned to the model. The attribute name is defined by `hook`. If omitted, an empty VolatileObject will be created instead
    - keyword: `hook` (string, default='scope') -- The model's attribute name for the temporal object.

  You can write your own `State` extensions and add them the same way. Just note that `add_state_features` expects _Mixins_. This means your extension should always call the overridden methods `__init__`, `enter` and `exit`. Your extension may inherit from _State_ but will also work without it.
  Using `@add_state_features` has a drawback which is that decorated machines cannot be pickled (more precisely, the dynamically generated `CustomState` cannot be pickled).
  This might be a reason to write a dedicated custom state class instead.
  Depending on the chosen state machine, your custom state class may need to provide certain state features. For instance, `HierarchicalMachine` requires your custom state to be an instance of `NestedState` (`State` is not sufficient). To inject your states you can either assign them to your `Machine`'s class attribute `state_cls` or override `Machine.create_state` in case you need some specific procedures done whenever a state is created:

  ```python
  from transitions import Machine, State

  class MyState(State):
      pass

  class CustomMachine(Machine):
      
      state_cls = MyState


  class VerboseMachine(Machine):

      
      
      def _create_state(self, *args, **kwargs):
          print("Creating a new state with machine '{0}'".format(self.name))
          return MyState(*args, **kwargs)
  ```

  If you want to avoid threads in your `AsyncMachine` entirely, you can replace the `Timeout` state feature with `AsyncTimeout` from the `asyncio` extension:

  ```python
  import asyncio
  from transitions.extensions.states import add_state_features
  from transitions.extensions.asyncio import AsyncTimeout, AsyncMachine

  @add_state_features(AsyncTimeout)
  class TimeoutMachine(AsyncMachine):
      pass

  states = ['A', {'name': 'B', 'timeout': 0.2, 'on_timeout': 'to_C'}, 'C']
  m = TimeoutMachine(states=states, initial='A', queued=True)  # see remark below
  asyncio.run(asyncio.wait([m.to_B(), asyncio.sleep(0.1)]))
  assert m.is_B()  # timeout shouldn't be triggered
  asyncio.run(asyncio.wait([m.to_B(), asyncio.sleep(0.3)]))
  assert m.is_C()   # now timeout should have been processed
  ```

  You should consider passing `queued=True` to the `TimeoutMachine` constructor. This will make sure that events are processed sequentially and avoid asynchronous [racing conditions](https://github.com/pytransitions/transitions/issues/459) that may appear when timeout and event happen in close proximity.



  You can have a look at the [FAQ](examples/Frequently%20asked%20questions.ipynb) for some inspiration or checkout `django-transitions`.
  It has been developed by Christian Ledermann and is also hosted on [Github](https://github.com/PrimarySite/django-transitions).
  [The documentation](https://django-transitions.readthedocs.io/en/latest/) contains some usage examples.



  First, congratulations! You reached the end of the documentation!
  If you want to try out `transitions` before you install it, you can do that in an interactive Jupyter notebook at mybinder.org.
  Just click this button 👉 [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/pytransitions/transitions/master?filepath=examples%2FPlayground.ipynb).

  For bug reports and other issues, please [open an issue](https://github.com/pytransitions/transitions) on GitHub.

  For usage questions, post on Stack Overflow, making sure to tag your question with the [`pytransitions` tag](https://stackoverflow.com/questions/tagged/pytransitions). Do not forget to have a look at the [extended examples](./examples)!

  For any other questions, solicitations, or large unrestricted monetary gifts, email [Tal Yarkoni](mailto:tyarkoni@gmail.com) (initial author) and/or [Alexander Neumann](mailto:aleneum@gmail.com) (current maintainer).


pkgId: 666a6f8ee8341eb8ff74ae9d50455ec5dd53d645112dc19501021528f6bff12e
name: python-translate
arch: src
version: 3.6.1
epoch: 0
release: 1
url: https://github.com/terryyin/google-translate-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ae21554-ff43-4faf-9fc0-547c2dd0338b
location_href: 00011382-python-translate/python-translate-3.6.1-1.src.rpm
checksum_type: sha256
summary:
  This is a simple, yet powerful command line translator with google translate behind it. You can also use it as a Python module in your code.


pkgId: c9816f586acd670ed2a45d285d9fcfa8139262e0d2441006c76edae8792b7728
name: python-translationstring
arch: src
version: 1.4
epoch: 0
release: 1
summary: Utility library for i18n relied on by various Repoze and Pyramid packages
url: https://github.com/Pylons/translationstring
rpm_license: BSD-like (http://repoze.org/license.html)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f0c8389b-714e-476d-a454-159d3fba9627
location_href: 00005331-python-translationstring/python-translationstring-1.4-1.src.rpm
checksum_type: sha256
description:
  A library used by various `Pylons Project <https://pylonsproject.org>`_ packages
  for internationalization (i18n) duties related to translation.
  This package provides a *translation string* class, a *translation string
  factory* class, translation and pluralization primitives, and a utility that
  helps `Chameleon <https://chameleon.readthedocs.io/en/latest/>`_ templates use
  translation facilities of this package.  It does not depend on `Babel
  <http://babel.pocoo.org/en/latest/>`_, but its translation and pluralization
  services are meant to work best when provided with an instance of the
  ``babel.support.Translations`` class.
  Please see https://docs.pylonsproject.org/projects/translationstring/en/latest/
  for the documentation.


pkgId: 31923915e97d6fdfa88add0d274e0ad107ac17117f1a723c2cf8fc3991147c77
name: python-tree-format
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: http://github.com/jml/tree-format
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-68537c83-a268-454b-b66b-24f786cc9c0d
location_href: 00005333-python-tree-format/python-tree-format-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Python library to generate nicely formatted trees, like the UNIX `tree`
  command.



  Produce output like this:

  ```
  foo
  ├── bar
  │   ├── a
  │   └── b
  ├── baz
  └── qux
      └── c⏎
          d
  ```

  using code like this:

  ```python
  from operator import itemgetter

  from tree_format import format_tree

  tree = (
      'foo', [
          ('bar', [
              ('a', []),
              ('b', []),
          ]),
          ('baz', []),
          ('qux', [
              ('c\nd', []),
          ]),
      ],
  )

  print format_tree(
      tree, format_node=itemgetter(0), get_children=itemgetter(1))
  ```



  This is made available under the Apache Software License, version 2.0.

  Copyright (c) 2015 - Jonathan M. Lange



  Run tests with:

  ```
  python -m testtools.run discover
  ```


pkgId: 790b3c07a6adc9d8d952cd3983d733d35eca335f94d9938c55a984a1567ddddb
name: python-treq
arch: src
version: 22.2.0
epoch: 0
release: 1
summary: High-level Twisted HTTP Client API
url: https://github.com/twisted/treq
rpm_license: MIT/X
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6355745-424e-44c9-a713-8feecbfa0fe6
location_href: 00005334-python-treq/python-treq-22.2.0-1.src.rpm
checksum_type: sha256
description:
  |pypi|_
  |calver|_
  |coverage|_
  |documentation|_
  ``treq`` is an HTTP library inspired by
  `requests <https://requests.readthedocs.io/>`_ but written on top of
  `Twisted <https://www.twistedmatrix.com>`_'s
  `Agents <https://twistedmatrix.com/documents/current/api/twisted.web.client.Agent.html>`_.
  It provides a simple, higher level API for making HTTP requests when
  using Twisted.
      >>> import treq
      >>> def done(response):
      >>> treq.get("https://github.com").addCallback(done)
      >>> from twisted.internet import reactor
      >>> reactor.run()
      200
  For more info `read the docs <https://treq.readthedocs.org>`_.


pkgId: bdec690e485b81c9e6ea4f4c97758f8d304d312b07301d7df316903ef4382602
name: python-trezor
arch: src
version: 0.13.5
epoch: 0
release: 1
summary: Python library for communicating with Trezor Hardware Wallet
url: https://github.com/trezor/trezor-firmware/tree/master/python
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-51ede92a-4af6-4584-aec4-835179da3f43
location_href: 00005335-python-trezor/python-trezor-0.13.5-1.src.rpm
checksum_type: sha256
description:
  [![repology](https://repology.org/badge/tiny-repos/python:trezor.svg)](https://repology.org/metapackage/python:trezor) [![image](https://badges.gitter.im/trezor/community.svg)](https://gitter.im/trezor/community)

  Python library and command-line client for communicating with Trezor
  Hardware Wallet.

  See <https://trezor.io> for more information.



  Python Trezor tools require Python 3.6 or higher, and libusb 1.0. The easiest
  way to install it is with `pip`. The rest of this guide assumes you have
  a working `pip`; if not, you can refer to [this
  guide](https://packaging.python.org/tutorials/installing-packages/).

  On a typical system, you already have all you need. Install `trezor` with:

  ```sh
  pip3 install trezor
  ```

  On Windows, you also need to either install [Trezor Bridge](https://suite.trezor.io/web/bridge/), or
  [libusb](https://github.com/libusb/libusb/wiki/Windows) and the appropriate
  [drivers](https://zadig.akeo.ie/).



  Current trezorlib version supports Trezor One version 1.8.0 and up, and Trezor T version
  2.1.0 and up.

  For firmware versions below 1.8.0 and 2.1.0 respectively, the only supported operation
  is "upgrade firmware".

  Trezor One with firmware _older than 1.7.0_ and bootloader _older than 1.6.0_
  (including pre-2021 fresh-out-of-the-box units) will not be recognized, unless
  you install HIDAPI support (see below).



  * **Ethereum**: To support Ethereum signing from command line, additional packages are
    needed. Install with:

    ```sh
    pip3 install trezor[ethereum]
    ```

  * **Stellar**: To support Stellar signing from command line, additional packages are
    needed. Install with:

    ```sh
    pip3 install trezor[stellar]
    ```

  * **Firmware-less Trezor One**: If you are setting up a brand new Trezor One
    manufactured before 2021 (with pre-installed bootloader older than 1.6.0), you will
    need HIDAPI support. On Linux, you will need the following packages (or their
    equivalents) as prerequisites: `python3-dev`, `cython3`, `libusb-1.0-0-dev`,
    `libudev-dev`.

    Install with:

    ```sh
    pip3 install trezor[hidapi]
    ```

  To install all three, use `pip3 install trezor[hidapi,ethereum,stellar]`.



  Check out [Repology](https://repology.org/metapackage/python:trezor) to see if your
  operating system has an up-to-date python-trezor package.



  ```sh
  pip3 install "git+https://github.com/trezor/trezor-firmware#egg=trezor&subdirectory=python"
  ```



  Install the [Poetry](https://python-poetry.org/) tool, checkout
  `trezor-firmware` from git, and enter the poetry shell:

  ```sh
  pip3 install poetry
  git clone https://github.com/trezor/trezor-firmware
  cd trezor-firmware
  poetry install
  poetry shell
  ```

  In this environment, trezorlib and the `trezorctl` tool is running from the live
  sources, so your changes are immediately effective.



  The included `trezorctl` python script can perform various tasks such as
  changing setting in the Trezor, signing transactions, retrieving account
  info and addresses. See the
  [python/docs/](https://github.com/trezor/trezor-firmware/tree/master/python/docs)
  sub folder for detailed examples and options.

  NOTE: An older version of the `trezorctl` command is [available for
  Debian Stretch](https://packages.debian.org/en/stretch/python-trezor)
  (and comes pre-installed on [Tails OS](https://tails.boum.org/)).



  You can use this python library to interact with a Trezor and use its capabilities in
  your application. See examples here in the
  [tools/](https://github.com/trezor/trezor-firmware/tree/master/python/docs/tools)
  sub folder.



  When you are asked for PIN, you have to enter scrambled PIN. Follow the
  numbers shown on Trezor display and enter the their positions using the
  numeric keyboard mapping:

  |   |   |   |
  |---|---|---|
  | 7 | 8 | 9 |
  | 4 | 5 | 6 |
  | 1 | 2 | 3 |

  Example: your PIN is **1234** and Trezor is displaying the following:

  |   |   |   |
  |---|---|---|
  | 2 | 8 | 3 |
  | 5 | 4 | 6 |
  | 7 | 9 | 1 |

  You have to enter: **3795**



  If you want to change protobuf or coin definitions, you will need to regenerate
  definitions in the `python/` subdirectory.

  First, make sure your submodules are up-to-date with:

  ```sh
  git submodule update --init --recursive
  ```

  Then, rebuild the protobuf messages by running, from the `trezor-firmware` top-level
  directory:

  ```sh
  make gen
  ```

  To get support for BTC-like coins, these steps are enough and no further
  changes to the library are necessary.




  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).


  [0.13.5]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.4...python/v0.13.5


  - Add support for model field in firmware image.  [#2701]
  - Add support for v3-style Trezor One signatures.  [#2701]


  - More structured information about signing keys for different models.  [#2701]


  - Instead of accepting a list of public keys, `FirmwareType.verify()` accepts a parameter configuring whether to use production or development keys.  [#2701]



  [0.13.4]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.3...python/v0.13.4


  - Add UnlockPath message.  [#2289]
  - Added new TOI formats - little endian full-color and even-high grayscale  [#2414]
  - Add device set-busy command to trezorctl.  [#2445]
  - Support SLIP-25 accounts in get-public-node and get-address.  [#2517]
  - Add possibility to save emulator screenshots.  [#2547]
  - Support for Cardano CIP-36 governance registration format  [#2561]


  - Remove DATA parameter from trezorctl cosi commit.
  - Remove firmware dumping capability.  [#2433]


  - Fixed issue where type declarations were not visible to consumer packages.  [#2542]


  - Refactored firmware parsing and validation to a more object oriented approach.  [#2576]



  [0.13.3]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.2...python/v0.13.3


  - Support for Cardano Babbage era transaction items  [#2354]


  - Fix Click 7.x compatibility.  [#2364]



  [0.13.2]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.1...python/v0.13.2


  - Fixed dependency error when running trezorctl without PIL.
  - Fixed dependency error when running trezorctl on Python 3.6 without rlp.
  - Fix `trezorctl --version` crash.  [#1702]



  [0.13.1]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.0...python/v0.13.1


  - New exception type `DeviceIsBusy` indicates that the device is in use by another process.  [#1026]
  - Support payment requests and GetNonce command.  [#1430]
  - Add press_info() to DebugLink.  [#1430]
  - Add support for blind EIP-712 signing for Trezor One  [#1970]
  - Add ScriptUI for trezorctl, spawned by --script option  [#2023]
  - Support T1 screenshot saving in Debuglink  [#2093]
  - Support generating Electrum-compatible message signatures in CLI.  [#2100]
  - Support Cardano Alonzo-era transaction items and --include-network-id flag  [#2114]
  - trezorctl: Bitcoin commands can detect script type from derivation path.  [#2159]
  - Add support for model R  [#2230]
  - Add firmware get-hash command.  [#2239]
  - Jump and stay in bootloader from firmware through SVC call reverse trampoline.  [#2284]


  - Unify boolean arguments/options in trezorlib commands to on/off  [#2123]
  - Rename `normalize_nfc` to `prepare_message_bytes` in tools.py  [#2126]
  - `trezorctl monero` network type arguments now accept symbolic names instead of numbers.  [#2219]


  - trezorctl will correctly report that device is in use.  [#1026]
  - Allow passing empty `message_hash` for domain-only EIP-712 hashes
    for Trezor T1 (i.e. when `primaryType`=`EIP712Domain`)  [#2036]
  - Fixed error when printing protobuf message with a missing required field.  [#2135]
  - Add compatibility with Click 8.1  [#2199]



  [0.13.0]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.4...python/v0.13.0


  - `trezorctl firmware update` shows progress bar (Model T only)
  - Enabled session management via `EndSession`  [#1227]
  - Added parameters to enable Cardano derivation when calling `init_device()`.  [#1231]
  - two new trezorctl commands - `trezorctl firmware download` and `trezorctl firmware verify`  [#1258]
  - Support no_script_type option in SignMessage.  [#1586]
  - Support for Ethereum EIP1559 transactions  [#1604]
  - Debuglink can automatically scroll through paginated views.  [#1671]
  - Support for Taproot descriptors  [#1710]
  - `trezorlib.stellar.from_envelope` was added, it includes support for the Stellar [TransactionV1](https://github.com/stellar/stellar-protocol/blob/master/core/cap-0015.md#xdr) format transaction.  [#1745]
  - Ethereum: support 64-bit chain IDs  [#1771]
  - Support for Cardano multi-sig transactions, token minting, script addresses, multi-sig keys, minting keys and native script verification  [#1772]
  - Added parameters to specify kind of Cardano derivation to all functions and `trezorctl` commands.  [#1783]
  - Support for EIP-712 in library and `trezorctl ethereum sign-typed-data`  [#1835]
  - Add script_pubkey field to TxInput message.  [#1857]
  - Full type hinting checkable with pyright  [#1893]


  - protobuf is aware of `required` fields and default values  [#379]
  - `trezorctl firmware-update` command changed to `trezorctl firmware update`  [#1258]
  - `btc.sign_tx()` accepts keyword arguments for transaction metadata  [#1266]
  - Raise `ValueError` when the txid for an input is not present in `prev_txes` during `btc.sign_tx`  [#1442]
  - `trezorlib.mappings` was refactored for easier customization  [#1449]
  - Refactor protobuf codec for better clarity  [#1541]
  - `UdpTransport.wait_until_ready` no longer sets socket to nonblocking  [#1668]
  - Cardano transaction parameters are now streamed into the device one by one instead of being sent as one large object  [#1683]
  - `trezorlib.stellar` will refuse to process transactions containing MuxedAccount  [#1838]
  - Use unified descriptors format.  [#1885]
  - Introduce Trezor models as an abstraction over USB IDs, vendor strings, and possibly protobuf mappings.  [#1967]


  - instantiating protobuf objects with positional arguments is deprecated  [#379]
  - `details` argument to `btc.sign_tx()` is deprecated. Use keyword arguments instead.  [#379]
  - values of required fields must be supplied at instantiation time. Omitting them is deprecated.  [#379]


  - dropped Python 3.5 support  [#810]
  - dropped debug-only `trezorctl debug show-text` functionality  [#1531]
  - Removed support for Lisk  [#1765]


  - fix operator precedence issue for ethereum sign-tx command  [#1867]
  - Updated `tools/build_tx.py` to work with Blockbook's API protections.  [#1896]
  - Fix PIN and passphrase entry in certain terminals on Windows  [#1959]


  - `client.init_device(derive_cardano=True)` must be used before calling Cardano functions.  [#1231]
  - The type of argument to `ui.button_request(x)` is changed from int to ButtonRequest.
    The original int value can be accessed as `x.code`  [#1671]
  - Due to transaction streaming in Cardano, it isn't possible to return the whole serialized transaction anymore. Instead the transaction hash, transaction witnesses and auxiliary data supplement are returned and the serialized transaction needs to be assembled by the client.  [#1683]
  - `trezorlib.stellar` was reworked to use stellar-sdk instead of providing local implementations  [#1745]
  - Cardano derivation now defaults to Icarus method. This will result in different keys for users with 24-word seed.  [#1783]



  [0.12.4]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.3...python/v0.12.4



  - trezorctl: fixed "Invalid value for <param>" when using Click 8 and param is not specified [#1798]


  [0.12.3]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.2...python/v0.12.3



  - `trezorctl btc get-descriptor` support [#1363]
  - `trezorctl btc reboot-to-bootloader` support [#1738]
  - distinguishing between temporary and permanent safety checks
  - trezorctl accepts PIN entered by letters (useful on laptops)
  - support for 50-digit PIN for T1



  - allowed Click 8.x as a requirement
  - replaced all references to Trezor Wallet with Trezor Suite, and modified all mentions
    of Beta Wallet



  - added missing requirement `attrs`
  - properly parse big numbers in `tools/build_tx.py` [#1257], [#1296]
  - it is now possible to set safety checks for T1



  [0.12.2]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.1...python/v0.12.2



  - `trezorlib.toif` module (moved from internal) can encode and decode TOIF image format
  - `trezorctl set homescreen` was improved and extended to support PNG images for Trezor T



  - trezorctl will correctly notify the user if the image decoding library is missing



  - fix exception in `trezorctl btc get-address`  [#1179]
  - fix exception in `trezorctl lisk sign-message`
  - fix exception in trezorctl commands that accept filenames  [#1196]
  - fix "Invalid homescreen" error when un-setting homescreen



  - removed option `--skip-vendor-header` from `trezorctl firmware-update` which did nothing  [#1210]



  [0.12.1]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.0...python/v0.12.1



  - `trezorctl set safety-checks` controls the new "safety checks" feature.  [#1126]
  - `trezorctl btc get-address` can create multisig addresses.
  - the following commands are now equivalent in trezorctl: `firmware-update`, `firmware-upgrade`,
    `update-firmware`, `upgrade-firmware`
  - support for EXTERNAL input type  [#38], [#1052]
  - support for ownership proofs
  - support for pre-authorized CoinJoin transactions  [#37]
  - support for Cardano Shelley  [#948]



  - do not allow setting auto-lock delay unless PIN is configured



  - correctly calculate hashes for very small firmwares  [f#1082]
  - unified file arguments in trezorctl
  - `TrezorClient.ping()` does not crash when device is PIN-locked



  [0.12.0]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.6...python/v0.12.0



  - `trezorlib.coins`, `trezorlib.tx_api`, and the file `coins.json`, were removed
  - `TrezorClient` argument `ui` is now mandatory. `state` argument was renamed to `session_id`.
  - UI callback `get_passphrase()` has a new argument `available_on_device`.
  - API for `cosi` module was changed
  - other changes may also introduce incompatibilities, please review the full list below



  - support for firmwares 1.9.0 and 2.3.0
  - Model T now defaults to entering passphrase on device. New trezorctl option `-P`
    enforces entering passphrase on host.
  - support for "passphrase always on device" mode on model T
  - new trezorctl command `get-session` and option `-s` allows entering passphrase once
    for multiple subsequent trezorctl operations
  - built-in functionality of UdpTransport to wait until an emulator comes up, and the
    related command `trezorctl wait-for-emulator`
  - `trezorctl debug send-bytes` can send raw messages to the device [f#116]
  - when updating firmware, user is warned that the requested version does not match their device [f#823]
  - `trezorctl list` can now show name, model and id of device



  - `trezorlib.tx_api.json_to_tx` was reduced to only support Bitcoin fields, and moved
    to `trezorlib.btc.from_json`.
  - API for `cosi` module was streamlined: `verify_m_of_n` is now `verify`, the old
    `verify` is `verify_combined`
  - internals of firmware parsing were reworked to support signing firmware headers
  - `get_default_client` respects `TREZOR_PATH` environment variable
  - UI callback `get_passphrase` has an additional argument `available_on_device`,
    indicating that the connected Trezor is capable of on-device entry
  - `Transport.write` and `read` method signatures changed to accept bytes instead of
    protobuf messages
  - trezorctl subcommands have a common `@with_client` decorator that manages exception
    handling and connecting to device



  - trezorctl does not print empty line when there is no output
  - trezorctl cleanly reports wire exceptions [f#226]



  - `trezorlib.tx_api` was removed
  - `trezorlib.coins` and coin data was removed
  - `trezorlib.ckd_public`, which was deprecated in 0.10, was now removed.
  - `btc.sign_tx` will not preload transaction data from `prev_txes`, as usage with TxApi
    is being removed
  - PIN protection and passphrase protection for `ping()` command was removed
  - compatibility no-op code from trezorlib 0.9 was removed from `trezorlib.client`
  - `trezorlib.tools.CallException` was dropped, use `trezorlib.exceptions.TrezorFailure` instead



  [0.11.6]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.5...python/v0.11.6



  - support for get-and-increase FIDO counter operation
  - support for setting wipe code
  - `trezorctl device recover` supports `--u2f-counter` option to set the FIDO counter to a custom value



  - `trezorctl` command was reworked for ease of use and maintenance. See `trezorctl --help` and `OPTIONS.rst` for details. [f#510]
  - updated EOS transaction parser to match `cleos` in `delegatebw` and `undelegatebw` actions [f#680] [f#681]
  - `RecoveryDevice` does not set fields when doing dry-run recovery [f#666]



  - fixed "expand words" functionality in `trezorctl device recover` [f#778]



  - trezorctl no longer interactively signs Bitcoin-like transactions, the only allowed
    input format is JSON. See [`docs/transaction-format.md`](docs/transaction-format.md)
    for details.
  - support for "load device by xprv" was removed from firmware and trezorlib




  [0.11.5]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.4...python/v0.11.5



  - trezorctl can dump raw protobuf bytes in debug output [f#117]
  - trezorctl shows a warning when activating Shamir Backup if the device does not support it [f#445]
  - warnings are emitted when encountering unknown value for a protobuf enum [f#363]
  - debug messages show enum value names instead of raw numbers
  - support for packed repeated encoding in the protobuf decoder
  - in `trezorctl firmware-update`, the new `--beta` switch enables downloading beta
    firmwares. By default, only stable firmware is used. [f#411], [f#420]
  - in `trezorctl firmware-update`, the new `--bitcoin-only` switch enables downloading
    Bitcoin-only firmware
  - support for FIDO2 resident credential management
  - support for SD-protect features



  - package directory structure was changed: `src` subdirectory contains sources and
    `tests` subdirectory contains tests, so that cwd is not cluttered
  - `trezorctl` script was moved into a module `trezorlib.cli.trezorctl` and is launched
    through the `entry_points` mechanism. This makes it usable on Windows
  - `pyblake2` is no longer required on Python 3.6 and up
  - input flows can only be used in with-block (only relevant for unit tests)
  - if not specified, trezorctl will set label to "SLIP-0014" in SLIP-0014 mode
  - in `clear_session` the client also forgets the passphrase state for TT [f#525]



  - trezorctl will properly check if a firmware is present on a new T1 [f#224]



  - device test suite was moved out of trezor package



  [0.11.4]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.3...python/v0.11.4



  - trezorctl support for SLIP-39 Shamir Backup
  - support for Binance Chain



  [0.11.3]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.2...python/v0.11.3



  - trezorctl can now send ERC20 tokens
  - trezorctl usb-reset will perform USB reset on devices in inconsistent state
  - set-display-rotation command added for TT firmware 2.1.1
  - EOS support [f#87]
  - Tezos: add voting support [f#41]
  - `dict_to_proto` now allows enum values as strings



  - Minimum firmware versions bumped to 1.8.0 and 2.1.0
  - Cleaner errors when UI object is not supplied
  - Generated files are now part of the source tarball again. That means that `protoc` is no longer required.



  - Ethereum commands in trezorctl now work
  - Memory debugging tools now work again



  - Tron and Ontology support removed until implementations exist in Trezor firmware



  [0.11.2]: https://github.com/trezor/python-trezor/compare/v0.11.1...v0.11.2



  - full support for bootloader 1.8.0 and relevant firmware upgrade functionality
  - trezorctl: support fully offline signing JSON-encoded transaction data
  - trezorctl: dry-run for firmware upgrade command
  - client: new convenience function `get_default_client` for simple script usage
  - Dash: support DIP-2 special inputs [#351]
  - Ethereum: add get_public_key methods



  - coins with BIP-143 fork id (BCH, BTG) won't require prev_tx [#352]
  - device recovery will restore U2F counter
  - Cardano: change `network` to `protocol_magic`
  - tests can run interactively when `INTERACT=1` environment variable is set
  - protobuf: improved `to_dict` function



  - trezorctl: interactive signing with `sign-tx` is considered deprecated



  [0.11.1]: https://github.com/trezor/python-trezor/compare/v0.11.0...v0.11.1



  - crash when entering passphrase on device with Trezor T
  - Qt widgets should only import QtCore [#349]



  [0.11.0]: https://github.com/trezor/python-trezor/compare/v0.10.2...v0.11.0



  - removed support for Python 3.3 and 3.4
  - major refactor of `TrezorClient` and UI handling. Implementers must now provide a "UI" object instead of overriding callbacks [#307], [#314]
  - protobuf classes now use a `get_fields()` method instead of `FIELDS` field [#312]
  - all methods on `TrezorClient` class are now in separate modules and take a `TrezorClient` instance as argument [#276]
  - mixin classes are also removed, you are not supposed to extend `TrezorClient` anymore
  - `TrezorClientDebugLink` was moved to `debuglink` module
  - changed signature of `trezorlib.btc.sign_tx`
  - `@field` decorator was replaced by an argument to `@expect`



  - trezorlib now has a hardcoded check preventing use of outdated firmware versions [#283]
  - Ripple support [#286]
  - Zencash support [#287]
  - Cardano support [#300]
  - Ontology support [#301]
  - Tezos support [#302]
  - Capricoin support [#325]
  - limited Monero support (can only get address/watch key, monerowallet is required for signing)
  - support for input flow in tests makes it easier to control complex UI workflows [#314]
  - `protobuf.dict_to_proto` can create a protobuf instance from a plain dict
  - support for smarter methods in trezord 2.0.25 and up
  - support for seedless setup
  - trezorctl: firmware handling is greatly improved [#304], [#308]
  - trezorctl: Bitcoin-like signing flow is more user-friendly
  - `tx_api` now supports Blockbook backend servers



  - better reporting for debuglink expected messages
  - replaced Ed25519 module with a cleaner, optimized version
  - further reorganization of transports makes them more robust when dependencies are missing
  - codebase now follows [Black](https://github.com/ambv/black) code style
  - in Qt modules, Qt5 is imported first [#315]
  - `TxApiInsight` is just `TxApi`
  - `device.reset` and `device.recover` now have reasonable defaults for all arguments
  - protobuf classes are no longer part of the source distribution and must be compiled locally [#284]
  - Stellar: addresses are always strings



  - `set_tx_api` method on `TrezorClient` is replaced by an argument for `sign_tx`
  - caching functionality of `TxApi` was moved to a separate test-support class
  - Stellar: public key methods removed
  - `EncryptMessage` and `DecryptMessage` actions are gone



  - `TrezorClient` can now detect when a HID device is removed and a different one is plugged in on the same path
  - trezorctl now works with Click 7.0 and considers "`_`" and "`-`" as same in command names [#314]
  - bash completion fixed
  - Stellar: several bugs in the XDR parser were fixed



  [0.10.2]: https://github.com/trezor/python-trezor/compare/v0.10.1...v0.10.2



  - `stellar_get_address` and `_public_key` functions support `show_display` parameter
  - trezorctl: `stellar_get_address` and `_public_key` commands for the respective functionality



  - trezorctl: `list_coins` is removed because we no longer parse the relevant protobuf field
    (and newer Trezor firmwares don't send it) [#277]



  - test support module was not included in the release, so code relying on the deprecated `ckd_public` module would fail [#280]



  [0.10.1]: https://github.com/trezor/python-trezor/compare/v0.10.0...v0.10.1



  - previous release fails to build on Windows [#274]



  [0.10.0]: https://github.com/trezor/python-trezor/compare/v0.9.1...v0.10.0



  - Lisk support [#197]
  - Stellar support [#167], [#268]
  - Wanchain support [#230]
  - support for "auto lock delay" feature
  - `TrezorClient` takes an additional argument `state` that allows reusing the previously entered passphrase [#241]
  - USB transports mention udev rules in exception messages [#245]
  - `log.enable_debug_output` function turns on wire logging, instead of having to use `TrezorClientVerbose`
  - BIP32 paths now support `123h` in addition to `123'` to indicate hardening
  - trezorctl: `-p` now supports prefix search for device path [#226]
  - trezorctl: smarter handling of firmware updates [#242], [#269]



  - reorganized transports and moved into their own `transport` submodule
  - protobuf messages and coins info is now regenerated at build time from the `trezor-common` repository [#248]
  - renamed `ed25519raw` to `_ed25519` to indicate its privateness
  - renamed `ed25519cosi` to `cosi` and expanded its API
  - protobuf messages are now logged through Python's `logging` facility instead of custom printing through `VerboseWireMixin`
  - `client.format_protobuf` is moved to `protobuf.format_message`
  - `tools.Hash` is renamed to `tools.btc_hash`
  - `coins` module `coins_txapi` is renamed to `tx_api`.
    `coins_slip44` is renamed to `slip44`.
  - build: stricter flake8 checks
  - build: split requirements to separate files
  - tests: unified finding test device, while respecting `TREZOR_PATH` env variable.
  - tests: auto-skip appropriately marked tests based on Trezor device version
  - tests: only show wire output when run with `-v`
  - tests: allow running `xfail`ed tests selectively based on `pytest.ini`
  - docs: updated README with clearer install instructions [#185]
  - docs: switched changelog to Keep a Changelog format [#94]



  - `ckd_public` is only maintained in `tests.support` submodule and considered private
  - `TrezorClient.expand_path` is moved to plain function `tools.parse_path`
  - `TrezorDevice` is deprecated in favor of `transport.enumerate_devices` and `transport.get_transport`
  - XPUB-related handling in `tools` is slated for removal



  - most Python 2 compatibility constructs are gone [#229]
  - `TrezorClientVerbose` and `VerboseWireMixin` is removed
  - specific `tx_api.TxApi*` classes removed in favor of `coins.tx_api`
  - `client.PRIME_DERIVATION_FLAG` is removed in favor of `tools.HARDENED_FLAG` and `tools.H_()`
  - hard dependency on Ethereum libraries and HIDAPI is changed into extras that need to be
    specified explicitly. Require `trezor[hidapi]` or `trezor[ethereum]` to get them.



  - WebUSB enumeration returning bad devices on Windows 10 [#223]
  - `sign_tx` operation sending empty address string [#237]
  - Wrongly formatted Ethereum signatures [#236]
  - protobuf layer would wrongly encode signed integers [#249], [#250]
  - protobuf pretty-printing broken on Python 3.4 [#256]
  - trezorctl: Matrix recovery on Windows wouldn't allow backspace [#207]
  - aes_encfs_getpass.py: fixed Python 3 bug [#169]



  [0.9.1]: https://github.com/trezor/python-trezor/compare/v0.9.0...v0.9.1



  - proper support for Trezor model T
  - support for Monacoin
  - improvements to `trezorctl`:
    - add pretty-printing of features and protobuf debug dumps (fixes [#199])
    - support `TREZOR_PATH` environment variable to preselect a Trezor device.



  - gradually dropping Python 2 compatibility (pypi package will now be marked as Python 3 only)

  [f#41]: https://github.com/trezor/trezor-firmware/pull/41
  [f#87]: https://github.com/trezor/trezor-firmware/pull/87
  [f#116]: https://github.com/trezor/trezor-firmware/pull/116
  [f#117]: https://github.com/trezor/trezor-firmware/pull/117
  [f#224]: https://github.com/trezor/trezor-firmware/pull/224
  [f#226]: https://github.com/trezor/trezor-firmware/pull/226
  [f#363]: https://github.com/trezor/trezor-firmware/pull/363
  [f#411]: https://github.com/trezor/trezor-firmware/pull/411
  [f#420]: https://github.com/trezor/trezor-firmware/pull/420
  [f#445]: https://github.com/trezor/trezor-firmware/pull/445
  [f#510]: https://github.com/trezor/trezor-firmware/pull/510
  [f#525]: https://github.com/trezor/trezor-firmware/pull/525
  [f#666]: https://github.com/trezor/trezor-firmware/pull/666
  [f#680]: https://github.com/trezor/trezor-firmware/pull/680
  [f#681]: https://github.com/trezor/trezor-firmware/pull/681
  [f#778]: https://github.com/trezor/trezor-firmware/pull/778
  [f#823]: https://github.com/trezor/trezor-firmware/pull/823
  [f#1082]: https://github.com/trezor/trezor-firmware/pull/1082
  [#37]: https://github.com/trezor/trezor-firmware/pull/37
  [#38]: https://github.com/trezor/trezor-firmware/pull/38
  [#94]: https://github.com/trezor/python-trezor/pull/94
  [#167]: https://github.com/trezor/python-trezor/pull/167
  [#169]: https://github.com/trezor/python-trezor/pull/169
  [#185]: https://github.com/trezor/python-trezor/pull/185
  [#197]: https://github.com/trezor/python-trezor/pull/197
  [#199]: https://github.com/trezor/python-trezor/pull/199
  [#207]: https://github.com/trezor/python-trezor/pull/207
  [#223]: https://github.com/trezor/python-trezor/pull/223
  [#226]: https://github.com/trezor/python-trezor/pull/226
  [#229]: https://github.com/trezor/python-trezor/pull/229
  [#230]: https://github.com/trezor/python-trezor/pull/230
  [#236]: https://github.com/trezor/python-trezor/pull/236
  [#237]: https://github.com/trezor/python-trezor/pull/237
  [#241]: https://github.com/trezor/python-trezor/pull/241
  [#242]: https://github.com/trezor/python-trezor/pull/242
  [#245]: https://github.com/trezor/python-trezor/pull/245
  [#248]: https://github.com/trezor/python-trezor/pull/248
  [#249]: https://github.com/trezor/python-trezor/pull/249
  [#250]: https://github.com/trezor/python-trezor/pull/250
  [#256]: https://github.com/trezor/python-trezor/pull/256
  [#268]: https://github.com/trezor/python-trezor/pull/268
  [#269]: https://github.com/trezor/python-trezor/pull/269
  [#274]: https://github.com/trezor/python-trezor/pull/274
  [#276]: https://github.com/trezor/python-trezor/pull/276
  [#277]: https://github.com/trezor/python-trezor/pull/277
  [#280]: https://github.com/trezor/python-trezor/pull/280
  [#283]: https://github.com/trezor/python-trezor/pull/283
  [#284]: https://github.com/trezor/python-trezor/pull/284
  [#286]: https://github.com/trezor/python-trezor/pull/286
  [#287]: https://github.com/trezor/python-trezor/pull/287
  [#300]: https://github.com/trezor/python-trezor/pull/300
  [#301]: https://github.com/trezor/python-trezor/pull/301
  [#302]: https://github.com/trezor/python-trezor/pull/302
  [#304]: https://github.com/trezor/python-trezor/pull/304
  [#307]: https://github.com/trezor/python-trezor/pull/307
  [#308]: https://github.com/trezor/python-trezor/pull/308
  [#312]: https://github.com/trezor/python-trezor/pull/312
  [#314]: https://github.com/trezor/python-trezor/pull/314
  [#315]: https://github.com/trezor/python-trezor/pull/315
  [#325]: https://github.com/trezor/python-trezor/pull/325
  [#349]: https://github.com/trezor/python-trezor/pull/349
  [#351]: https://github.com/trezor/python-trezor/pull/351
  [#352]: https://github.com/trezor/python-trezor/pull/352
  [#379]: https://github.com/trezor/trezor-firmware/pull/379
  [#810]: https://github.com/trezor/trezor-firmware/pull/810
  [#948]: https://github.com/trezor/trezor-firmware/pull/948
  [#1026]: https://github.com/trezor/trezor-firmware/pull/1026
  [#1052]: https://github.com/trezor/trezor-firmware/pull/1052
  [#1126]: https://github.com/trezor/trezor-firmware/pull/1126
  [#1179]: https://github.com/trezor/trezor-firmware/pull/1179
  [#1196]: https://github.com/trezor/trezor-firmware/pull/1196
  [#1210]: https://github.com/trezor/trezor-firmware/pull/1210
  [#1227]: https://github.com/trezor/trezor-firmware/pull/1227
  [#1231]: https://github.com/trezor/trezor-firmware/pull/1231
  [#1257]: https://github.com/trezor/trezor-firmware/pull/1257
  [#1258]: https://github.com/trezor/trezor-firmware/pull/1258
  [#1266]: https://github.com/trezor/trezor-firmware/pull/1266
  [#1296]: https://github.com/trezor/trezor-firmware/pull/1296
  [#1363]: https://github.com/trezor/trezor-firmware/pull/1363
  [#1430]: https://github.com/trezor/trezor-firmware/pull/1430
  [#1442]: https://github.com/trezor/trezor-firmware/pull/1442
  [#1449]: https://github.com/trezor/trezor-firmware/pull/1449
  [#1531]: https://github.com/trezor/trezor-firmware/pull/1531
  [#1541]: https://github.com/trezor/trezor-firmware/pull/1541
  [#1586]: https://github.com/trezor/trezor-firmware/pull/1586
  [#1604]: https://github.com/trezor/trezor-firmware/pull/1604
  [#1668]: https://github.com/trezor/trezor-firmware/pull/1668
  [#1671]: https://github.com/trezor/trezor-firmware/pull/1671
  [#1683]: https://github.com/trezor/trezor-firmware/pull/1683
  [#1702]: https://github.com/trezor/trezor-firmware/pull/1702
  [#1710]: https://github.com/trezor/trezor-firmware/pull/1710
  [#1738]: https://github.com/trezor/trezor-firmware/pull/1738
  [#1745]: https://github.com/trezor/trezor-firmware/pull/1745
  [#1765]: https://github.com/trezor/trezor-firmware/pull/1765
  [#1771]: https://github.com/trezor/trezor-firmware/pull/1771
  [#1772]: https://github.com/trezor/trezor-firmware/pull/1772
  [#1783]: https://github.com/trezor/trezor-firmware/pull/1783
  [#1798]: https://github.com/trezor/trezor-firmware/pull/1798
  [#1835]: https://github.com/trezor/trezor-firmware/pull/1835
  [#1838]: https://github.com/trezor/trezor-firmware/pull/1838
  [#1857]: https://github.com/trezor/trezor-firmware/pull/1857
  [#1867]: https://github.com/trezor/trezor-firmware/pull/1867
  [#1885]: https://github.com/trezor/trezor-firmware/pull/1885
  [#1893]: https://github.com/trezor/trezor-firmware/pull/1893
  [#1896]: https://github.com/trezor/trezor-firmware/pull/1896
  [#1959]: https://github.com/trezor/trezor-firmware/pull/1959
  [#1967]: https://github.com/trezor/trezor-firmware/pull/1967
  [#1970]: https://github.com/trezor/trezor-firmware/pull/1970
  [#2023]: https://github.com/trezor/trezor-firmware/pull/2023
  [#2036]: https://github.com/trezor/trezor-firmware/pull/2036
  [#2093]: https://github.com/trezor/trezor-firmware/pull/2093
  [#2100]: https://github.com/trezor/trezor-firmware/pull/2100
  [#2114]: https://github.com/trezor/trezor-firmware/pull/2114
  [#2123]: https://github.com/trezor/trezor-firmware/pull/2123
  [#2126]: https://github.com/trezor/trezor-firmware/pull/2126
  [#2135]: https://github.com/trezor/trezor-firmware/pull/2135
  [#2159]: https://github.com/trezor/trezor-firmware/pull/2159
  [#2199]: https://github.com/trezor/trezor-firmware/pull/2199
  [#2219]: https://github.com/trezor/trezor-firmware/pull/2219
  [#2230]: https://github.com/trezor/trezor-firmware/pull/2230
  [#2239]: https://github.com/trezor/trezor-firmware/pull/2239
  [#2284]: https://github.com/trezor/trezor-firmware/pull/2284
  [#2289]: https://github.com/trezor/trezor-firmware/pull/2289
  [#2354]: https://github.com/trezor/trezor-firmware/pull/2354
  [#2364]: https://github.com/trezor/trezor-firmware/pull/2364
  [#2414]: https://github.com/trezor/trezor-firmware/pull/2414
  [#2433]: https://github.com/trezor/trezor-firmware/pull/2433
  [#2445]: https://github.com/trezor/trezor-firmware/pull/2445
  [#2517]: https://github.com/trezor/trezor-firmware/pull/2517
  [#2542]: https://github.com/trezor/trezor-firmware/pull/2542
  [#2547]: https://github.com/trezor/trezor-firmware/pull/2547
  [#2561]: https://github.com/trezor/trezor-firmware/pull/2561
  [#2576]: https://github.com/trezor/trezor-firmware/pull/2576
  [#2701]: https://github.com/trezor/trezor-firmware/pull/2701


pkgId: cdae9064352258eff5c2369cd10903afc9bea7d87074aebbd21a74939c9d3457
name: python-tribool
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: Three-valued logic data type.
url: http://www.grantjenks.com/docs/tribool/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a807b0a-db73-4018-b21f-230071bb2287
location_href: 00010939-python-tribool/python-tribool-0.7.3-1.src.rpm
checksum_type: sha256
description:
  `Tribool <http://www.grantjenks.com/docs/tribool/>`_ is an Apache2 licensed
  Python module that implements three-valued logic.
  Suppose for a moment that you're attempting to store a value across a network
  connection. You begin with a simple protocol in which the server stores the
  received value and then sends an acknowledgement to the client.  In this
  design, the client experiences a delay between when the request is sent and the
  acknowledgement is received. In that delay, it is impossible for the client to
  know whether the value has been committed on the server.  In such cases, it's
  useful to describe the commit state of the server from the client's perspective
  as True, False, or Indeterminate.
  Another example occurs in database systems. Consider a record that contains
  a boolean field. Such a field may only be either True or False. But we want
  to support the notion of committing a partial record in the case that the
  record is large or the client does not have all relevant information. In this
  scenario, we wish to commit neither True nor False as the value is currently
  Unknown.
  The Python Tribool module was designed for these cases by describing a logical
  data type that supports three values: True, False, and Indeterminate. The third
  value is best thought of as a state being either True or False. Given these
  three values it's possible to define truth tables over the logical operators
  `and`, `or` and `not` and to define equality and inequality relationships.


pkgId: d2df148948fac9e9697f57d405d6d83bab1d3b773adbe51a6ea95cbb80dde3ab
name: python-trino
arch: src
version: 0.322.0
epoch: 0
release: 1
summary: Client for the Trino distributed SQL Engine
url: https://github.com/trinodb/trino-python-client
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-31f56502-47d2-4443-96a2-d74f08c909e2
location_href: 00010418-python-trino/python-trino-0.322.0-1.src.rpm
checksum_type: sha256
description:
  Client for Trino (https://trino.io), a distributed SQL engine for
  interactive and batch big data processing. Provides a low-level client and
  a DBAPI 2.0 implementation.


pkgId: da1c1762bb5165197dfd96fc51f8d1d9f08eac42e12c719f91a63cabfae72673
name: python-trio
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: A friendly Python library for async concurrency and I/O
url: https://github.com/python-trio/trio
rpm_license: MIT OR Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a23751c-7d14-4358-b57f-fc77a97a244b
location_href: 00005339-python-trio/python-trio-0.22.0-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://raw.githubusercontent.com/python-trio/trio/9b0bec646a31e0d0f67b8b6ecc6939726faf3e17/logo/logo-with-background.svg
     :width: 200px
     :align: right

  The Trio project's goal is to produce a production-quality, `permissively
  licensed <https://github.com/python-trio/trio/blob/master/LICENSE>`__,
  async/await-native I/O library for Python. Like all async libraries,
  its main purpose is to help you write programs that do **multiple
  things at the same time** with **parallelized I/O**. A web spider that
  wants to fetch lots of pages in parallel, a web server that needs to
  juggle lots of downloads and websocket connections at the same time, a
  process supervisor monitoring multiple subprocesses... that sort of
  thing. Compared to other libraries, Trio attempts to distinguish
  itself with an obsessive focus on **usability** and
  **correctness**. Concurrency is complicated; we try to make it *easy*
  to get things *right*.

  Trio was built from the ground up to take advantage of the `latest
  Python features <https://www.python.org/dev/peps/pep-0492/>`__, and
  draws inspiration from `many sources
  <https://github.com/python-trio/trio/wiki/Reading-list>`__, in
  particular Dave Beazley's `Curio <https://curio.readthedocs.io/>`__.
  The resulting design is radically simpler than older competitors like
  `asyncio <https://docs.python.org/3/library/asyncio.html>`__ and
  `Twisted <https://twistedmatrix.com/>`__, yet just as capable. Trio is
  the Python I/O library I always wanted; I find it makes building
  I/O-oriented programs easier, less error-prone, and just plain more
  fun. `Perhaps you'll find the same
  <https://github.com/python-trio/trio/wiki/Testimonials>`__.

  This project is young and still somewhat experimental: the overall
  design is solid and the existing features are fully tested and
  documented, but you may encounter missing functionality or rough
  edges. We *do* encourage you do use it, but you should `read and
  subscribe to issue #1
  <https://github.com/python-trio/trio/issues/1>`__ to get warning and a
  chance to give feedback about any compatibility-breaking changes.

  Vital statistics:

  * Supported environments: Linux, macOS, or Windows running some kind of Python
    3.7-or-better (either CPython or PyPy3 is fine). \*BSD and illumos likely
    work too, but are not tested.

  * Install: ``python3 -m pip install -U trio`` (or on Windows, maybe
    ``py -3 -m pip install -U trio``). No compiler needed.

  * Tutorial and reference manual: https://trio.readthedocs.io

  * Bug tracker and source code: https://github.com/python-trio/trio

  * Real-time chat: https://gitter.im/python-trio/general

  * Discussion forum: https://trio.discourse.group

  * License: MIT or Apache 2, your choice

  * Contributor guide: https://trio.readthedocs.io/en/latest/contributing.html

  * Code of conduct: Contributors are requested to follow our `code of
    conduct
    <https://trio.readthedocs.io/en/latest/code-of-conduct.html>`_
    in all project spaces.


pkgId: 693fda827d5b0ff8be03c961cdbfb217b27b36aca4a656305ce3b0d6d9ad5b57
name: python-trio-websocket
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: WebSocket library for Trio
url: https://github.com/HyperionGray/trio-websocket
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f8cc131-bfa9-4e39-9998-24212094cd0b
location_href: 00009261-python-trio-websocket/python-trio-websocket-0.10.2-1.src.rpm
checksum_type: sha256
description:
  This library implements both server and client aspects of the [the WebSocket
  protocol](https://tools.ietf.org/html/rfc6455), striving for safety,
  correctness, and ergonomics. It is based on the [wsproto
  project](https://wsproto.readthedocs.io/en/latest/), which is a
  [Sans-IO](https://sans-io.readthedocs.io/) state machine that implements the
  majority of the WebSocket protocol, including framing, codecs, and events. This
  library handles I/O using [the Trio
  framework](https://trio.readthedocs.io/en/latest/). This library passes the
  [Autobahn Test Suite](https://github.com/crossbario/autobahn-testsuite).

  This README contains a brief introduction to the project. Full documentation [is
  available here](https://trio-websocket.readthedocs.io).

  [![PyPI](https://img.shields.io/pypi/v/trio-websocket.svg?style=flat-square)](https://pypi.org/project/trio-websocket/)
  ![Python Versions](https://img.shields.io/pypi/pyversions/trio-websocket.svg?style=flat-square)
  [![Build Status](https://img.shields.io/github/actions/workflow/status/HyperionGray/trio-websocket/ci.yml)](https://github.com/HyperionGray/trio-websocket/actions/workflows/ci.yml)
  [![Read the Docs](https://img.shields.io/readthedocs/trio-websocket.svg)](https://trio-websocket.readthedocs.io)



  If you happen to only need a server, using Quart via the [quart-trio](https://github.com/pgjones/quart-trio)
  extension may suffice.  While trio-websocket is more flexible, Quart covers
  both HTTP and WebSocket within a single framework, and serving both from the
  same port is straightforward.  There has yet to be a performance comparison.



  This library requires Python 3.7 or greater. To install from PyPI:

      pip install trio-websocket



  This example demonstrates how to open a WebSocket URL:

  ```python
  import trio
  from sys import stderr
  from trio_websocket import open_websocket_url


  async def main():
      try:
          async with open_websocket_url('wss://echo.websocket.org') as ws:
              await ws.send_message('hello world!')
              message = await ws.get_message()
              print('Received message: %s' % message)
      except OSError as ose:
          print('Connection attempt failed: %s' % ose, file=stderr)

  trio.run(main)
  ```

  The WebSocket context manager connects automatically before entering the block
  and disconnects automatically before exiting the block. The full API offers a
  lot of flexibility and additional options.



  A WebSocket server requires a bind address, a port, and a coroutine to handle
  incoming connections. This example demonstrates an "echo server" that replies to
  each incoming message with an identical outgoing message.

  ```python
  import trio
  from trio_websocket import serve_websocket, ConnectionClosed

  async def echo_server(request):
      ws = await request.accept()
      while True:
          try:
              message = await ws.get_message()
              await ws.send_message(message)
          except ConnectionClosed:
              break

  async def main():
      await serve_websocket(echo_server, '127.0.0.1', 8000, ssl_context=None)

  trio.run(main)
  ```

  The server's handler ``echo_server(…)`` receives a connection request object.
  This object can be used to inspect the client's request and modify the
  handshake, then it can be exchanged for an actual WebSocket object ``ws``.
  Again, the full API offers a lot of flexibility and additional options.


pkgId: c80ea7f40dae2ebd79b97b0260b595d8406e00ac61d5e56ba8ed681a0d7531f2
name: python-tsfresh
arch: src
version: 0.20.0
epoch: 0
release: 1
summary: tsfresh extracts relevant characteristics from time series
url: https://github.com/blue-yonder/tsfresh
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b8aba16-82ba-41bb-8348-5dd77fb42212
location_href: 00010517-python-tsfresh/python-tsfresh-0.20.0-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/tsfresh/badge/?version=latest)](https://tsfresh.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://github.com/blue-yonder/tsfresh/workflows/Test%20Default%20Branch/badge.svg)](https://github.com/blue-yonder/tsfresh/actions)
  [![codecov](https://codecov.io/gh/blue-yonder/tsfresh/branch/main/graph/badge.svg)](https://codecov.io/gh/blue-yonder/tsfresh)
  [![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/blue-yonder/tsfresh/blob/main/LICENSE.txt)
  [![py36 status](https://img.shields.io/badge/python3.6.10-supported-green.svg)](https://github.com/blue-yonder/tsfresh/issues/8)
  [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/blue-yonder/tsfresh/main?filepath=notebooks)
  [![Downloads](https://pepy.tech/badge/tsfresh)](https://pepy.tech/project/tsfresh)
  This repository contains the *TSFRESH* python package. The abbreviation stands for
  *"Time Series Feature extraction based on scalable hypothesis tests"*.
  The package provides systematic time-series feature extraction by combining established algorithms from statistics, time-series analysis, signal processing, and nonlinear dynamics with a robust feature selection algorithm. In this context, the term *time-series* is interpreted in the broadest possible sense, such that any types of sampled data or even event sequences can be characterised.

  Data Scientists often spend most of their time either cleaning data or building features.
  While we cannot change the first thing, the second can be automated.
  *TSFRESH* frees your time spent on building features by extracting them automatically.
  Hence, you have more time to study the newest deep learning paper, read hacker news or build better models.

  *TSFRESH* automatically extracts 100s of features from time series.
  Those features describe basic characteristics of the time series such as the number of peaks, the average or maximal value or more complex features such as the time reversal symmetry statistic.
  ![The features extracted from a exemplary time series](docs/images/introduction_ts_exa_features.png)
  The set of features can then be used to construct statistical or machine learning models on the time series to be used for example in regression or
  classification tasks.

  Time series often contain noise, redundancies or irrelevant information.
  As a result most of the extracted features will not be useful for the machine learning task at hand.
  To avoid extracting irrelevant features, the *TSFRESH* package has a built-in filtering procedure.
  This filtering procedure evaluates the explaining power and importance of each characteristic for the regression or classification tasks at hand.
  It is based on the well developed theory of hypothesis testing and uses a multiple test procedure.
  As a result the filtering process mathematically controls the percentage of irrelevant extracted features.
  The  *TSFRESH* package is described in the following open access paper:
  * Christ, M., Braun, N., Neuffer, J., and Kempa-Liehr A.W. (2018).
     _Time Series FeatuRe Extraction on basis of Scalable Hypothesis tests (tsfresh -- A Python package)._
     Neurocomputing 307, p. 72-77, [doi: 10.1016/j.neucom.2018.03.067](https://doi.org/10.1016/j.neucom.2018.03.067).
  The FRESH algorithm is described in the following whitepaper:
  * Christ, M., Kempa-Liehr, A.W., and Feindt, M. (2017).
      _Distributed and parallel time series feature extraction for industrial big data applications._
      ArXiv e-print 1610.07717,  [https://arxiv.org/abs/1610.07717](https://arxiv.org/abs/1610.07717).
  Systematic time-series feature extraction even works for unsupervised problems:
  * Teh, H.Y., Wang, K.I-K., Kempa-Liehr, A.W. (2021).
      _Expect the Unexpected: Unsupervised feature selection for automated sensor anomaly detection._
      IEEE Sensors Journal 15.16, p. 18033-18046, [doi: 10.1109/JSEN.2021.3084970](https://doi.org/10.1109/JSEN.2021.3084970).
  Due to the fact that tsfresh basically provides time-series feature extraction for free, you can now concentrate on engineering new time-series,
  like e.g. differences of signals from synchronous measurements, which provide even better time-series features:
  * Kempa-Liehr, A.W., Oram, J., Wong, A., Finch, M., Besier, T. (2020).
      _Feature engineering workflow for activity recognition from synchronized inertial measurement units._
      In: Pattern Recognition. ACPR 2019. Ed. by M. Cree et al. Vol. 1180. Communications in Computer and Information Science (CCIS).
      Singapore: Springer, p. 223–231. [doi: 10.1007/978-981-15-3651-9_20](https://doi.org/10.1007/978-981-15-3651-9_20).
  * Simmons, S., Jarvis, L., Dempsey, D., Kempa-Liehr, A.W. (2021).
      _Data Mining on Extremely Long Time-Series._
      In: 2021 International Conference on Data Mining Workshops (ICDMW). Ed. by B. Xue et al.
      Los Alamitos: IEEE, p. 1057-1066. [doi: 10.1109/ICDMW53433.2021.00137](https://doi.org/10.1109/ICDMW53433.2021.00137).
  Systematic time-series features engineering allows to work with time-series samples of different lengths, because every time-series is projected
  into a well-defined feature space. This approach allows the design of robust machine learning algorithms in applications with missing data.
  * Kennedy, A., Gemma, N., Rattenbury, N., Kempa-Liehr, A.W. (2021).
      _Modelling the projected separation of microlensing events using systematic time-series feature engineering._
      Astronomy and Computing 35.100460, p. 1–14, [doi: 10.1016/j.ascom.2021.100460](https://doi.org/10.1016/j.ascom.2021.100460)
  Is your time-series classification problem imbalanced? There is a good chance that undersampling of time-series feature matrices
  might solve your problem:
  * Dempsey, D.E., Cronin, S.J., Mei, S., Kempa-Liehr, A.W. (2020).
      _Automatic precursor recognition and real-time forecasting of sudden explosive volcanic eruptions at Whakaari, New Zealand_.
      Nature Communications 11.3562, p. 1-8, [doi: 10.1038/s41467-020-17375-2](https://doi.org/10.1038/s41467-020-17375-2).
  Natural language processing of written texts is an example of applying systematic time-series feature engineering to event sequences,
  which is described in the following open access paper:
  * Tang, Y., Blincoe, K., Kempa-Liehr, A.W. (2020).
      _Enriching Feature Engineering for Short Text Samples by Language Time Series Analysis._
      EPJ Data Science 9.26, p. 1–59. [doi: 10.1140/epjds/s13688-020-00244-9](https://doi.org/10.1140/epjds/s13688-020-00244-9)

  *TSFRESH* has several selling points, for example
  1. it is field tested
  2. it is unit tested
  3. the filtering process is statistically/mathematically correct
  4. it has a comprehensive documentation
  5. it is compatible with sklearn, pandas and numpy
  6. it allows anyone to easily add their favorite features
  7. it both runs on your local machine or even on a cluster

  If you are interested in the technical workings, go to see our comprehensive Read-The-Docs documentation at [http://tsfresh.readthedocs.io](http://tsfresh.readthedocs.io).
  The algorithm, especially the filtering part are also described in the paper mentioned above.
  We appreciate any contributions, if you are interested in helping us to make *TSFRESH* the biggest archive of feature extraction methods in python, just head over to our [How-To-Contribute](http://tsfresh.readthedocs.io/en/latest/text/how_to_contribute.html) instructions.
  If you want to try out `tsfresh` quickly or if you want to integrate it into your workflow, we also have a docker image available:
      docker pull nbraun/tsfresh

  If you need to reproduce or update time-series features, which were computed with the `matrixprofile` feature calculators, you need to create a Python 3.8 environment:
      conda create --name tsfresh__py_3.8 python=3.8
      conda activate tsfresh__py_3.8
      pip install tsfresh[matrixprofile]

  The research and development of *TSFRESH* was funded in part by the German Federal Ministry of Education and Research under grant number 01IS14004 (project iPRODICT).


pkgId: 688de46ccd020816218437debcadbe9a3f78edf3012fc605cb632984bda5c1bf
name: python-ttkwidgets
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: A collection of widgets for Tkinter's ttk extensions by various authors
url: https://www.github.com/RedFantom/ttkwidgets
rpm_license: AGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0d6220f6-5c5a-4657-92c4-e18fcc633f1e
location_href: 00012587-python-ttkwidgets/python-ttkwidgets-0.13.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/TkinterEP/ttkwidgets.svg?branch=master)](https://travis-ci.org/TkinterEP/ttkwidgets)
  [![Build status](https://ci.appveyor.com/api/projects/status/eegux50s3kmb5w9g/branch/master?svg=true)](https://ci.appveyor.com/project/RedFantom/ttkwidgets-pq6y3)
  [![codecov](https://codecov.io/gh/TkinterEP/ttkwidgets/branch/master/graph/badge.svg)](https://codecov.io/gh/TkinterEP/ttkwidgets)
  [![PyPI version](https://badge.fury.io/py/ttkwidgets.svg)](https://badge.fury.io/py/ttkwidgets)
  [![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](http://www.gnu.org/licenses/gpl-3.0)
  [![Documentation Status](https://readthedocs.org/projects/ttkwidgets/badge/?version=latest)](https://ttkwidgets.readthedocs.io/en/latest/)

  A collection of widgets for Tkinter's ttk extensions by various authors.


      ttkwidgets: A collection of widgets for Tkinter's ttk extensions by various authors
      Copyright (c) 2008-2022 The ttkwidgets authors
      See AUTHORS.md for more details

      This program is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.

      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU General Public License for more details.

      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.


  - With pip:

          pip install ttkwidgets

  - Ubuntu: ttkwidgets is available in the PPA [ppa:j-4321-i/ttkwidgets](https://launchpad.net/~j-4321-i/+archive/ubuntu/ttkwidgets).

          sudo add-apt-repository ppa:j-4321-i/ttkwidgets
          sudo apt-get update
          sudo apt-get install python(3)-ttkwidgets

  - Archlinux: ttkwidgets is available in [AUR](https://aur.archlinux.org/packages/python-ttkwidgets).


  Online documentation is available here: https://ttkwidgets.readthedocs.io/en/latest/


  If you have created a widget that you think is worth adding, then feel free to fork the repository and create a Pull
  Request when you've added the widget to your copy of the repository. You will be credited for your work, and you can add
  headers to your files. You will also be added to the [AUTHORS.md](AUTHORS.md) file.


  If you find any bugs or have any ideas, feel free to open an issue here in the repository, and it will be looked at.


pkgId: e7fda47451c3134b9e26318b9beecd8acea0a88f24e28c782d896f26b11724f5
name: python-tvb-data
arch: src
version: 2.0
epoch: 0
release: 1
summary: A package with data for TVB
url: http://www.thevirtualbrain.org
rpm_license: GPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5d9e1066-1d95-42d4-abf2-3df384e06cb2
location_href: 00005344-python-tvb-data/python-tvb-data-2.0-1.src.rpm
checksum_type: sha256
description:
  Various demonstration datasets for use with The Virtual Brain are provided here.
  Here you will find:
  * compatible file/folder structures that can be uploaded thorugh the web interface of TVB; and
  * the default datasets used when working in ``console`` or `library` mode.
  This package should be treated as a regular Python module.
  Possibly what you want to do after cloning it locally from GitHub (https://github.com/the-virtual-brain/tvb-data) is::
      cd tvb-data/
      python setup.py develop
  to have it linked into your current Python environment.
  `tvb-data` also is shared on Pypi, but it has fewer files, due to size restrictions there.
  To work with this package from pypi, run::
      pip install tvb-data


pkgId: 5b1d3edc89c2f734bf6e9a3befbbe104e539b2520ddcd051ece78165b6ad383c
name: python-tw2.core
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: The runtime components for ToscaWidgets 2, a web widget toolkit.
url: http://toscawidgets.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-48c6bb4c-102e-4a58-9d64-517759df61b9
location_href: 00005346-python-tw2-core/python-tw2.core-2.3.0-1.src.rpm
checksum_type: sha256
description:
  +--------------+------------------+---------------------+
  | Branch       | Build Status     | Test Coverage       |
  +==============+==================+=====================+
  | **master**   | |travis-master|  | |coveralls-master|  |
  +--------------+------------------+---------------------+
  | **develop**  | |travis-develop| | |coveralls-develop| |
  +--------------+------------------+---------------------+


pkgId: 9f65789cd1e256586297fa6bc8f3b1cab5def50c303c188955c3110b26ed06d4
name: python-tweepy
arch: src
version: 4.13.0
epoch: 0
release: 1
summary: Twitter library for Python
url: https://www.tweepy.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94b28043-7c53-4d31-9346-1939c30519e3
location_href: 00009892-python-tweepy/python-tweepy-4.13.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version](https://img.shields.io/pypi/v/tweepy?label=PyPI)](https://pypi.org/project/tweepy/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/tweepy?label=Python)](https://pypi.org/project/tweepy/)
  [![DOI](https://zenodo.org/badge/244025.svg)](https://zenodo.org/badge/latestdoi/244025)
  [![Twitter API v1.1](https://img.shields.io/endpoint?url=https%3A%2F%2Ftwbadges.glitch.me%2Fbadges%2Fstandard)](https://developer.twitter.com/en/docs/twitter-api/v1)
  [![Twitter API Premium v1.1](https://img.shields.io/endpoint?url=https%3A%2F%2Ftwbadges.glitch.me%2Fbadges%2Fpremium)](https://developer.twitter.com/en/docs/twitter-api/premium)
  [![Twitter API v2](https://img.shields.io/endpoint?url=https%3A%2F%2Ftwbadges.glitch.me%2Fbadges%2Fv2)](https://developer.twitter.com/en/docs/twitter-api)
  [![Documentation Status](https://readthedocs.org/projects/tweepy/badge/?version=latest)](https://tweepy.readthedocs.io/en/latest/)
  [![Test Status](https://github.com/tweepy/tweepy/workflows/Test/badge.svg)](https://github.com/tweepy/tweepy/actions?query=workflow%3ATest)
  [![Coverage Status](https://img.shields.io/coveralls/tweepy/tweepy/master.svg?style=flat)](https://coveralls.io/github/tweepy/tweepy?branch=master)
  [![Discord Server](https://discord.com/api/guilds/432685901596852224/embed.png)](https://discord.gg/bJvqnhg)


pkgId: 46fa68cede41ee82177517ccb8834436486f103cd938df604c7d8f7262d7915d
name: python-twilio
arch: src
version: 7.16.5
epoch: 0
release: 1
summary: Twilio API client and TwiML generator
url: https://github.com/twilio/twilio-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d47bcf49-0fe4-458b-86de-10b2cd4ce2fe
location_href: 00005349-python-twilio/python-twilio-7.16.5-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/twilio/twilio-python/actions/workflows/test-and-deploy.yml/badge.svg)](https://github.com/twilio/twilio-python/actions/workflows/test-and-deploy.yml)
  [![PyPI](https://img.shields.io/pypi/v/twilio.svg)](https://pypi.python.org/pypi/twilio)
  [![PyPI](https://img.shields.io/pypi/pyversions/twilio.svg)](https://pypi.python.org/pypi/twilio)
  [![Learn OSS Contribution in TwilioQuest](https://img.shields.io/static/v1?label=TwilioQuest&message=Learn%20to%20contribute%21&color=F22F46&labelColor=1f243c&style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAASFBMVEUAAAAZGRkcHBwjIyMoKCgAAABgYGBoaGiAgICMjIyzs7PJycnMzMzNzc3UoBfd3d3m5ubqrhfrMEDu7u739/f4vSb/3AD///9tbdyEAAAABXRSTlMAAAAAAMJrBrEAAAKoSURBVHgB7ZrRcuI6EESdyxXGYoNFvMD//+l2bSszRgyUYpFAsXOeiJGmj4NkuWx1Qeh+Ekl9DgEXOBwOx+Px5xyQhDykfgq4wG63MxxaR4ddIkg6Ul3g84vCIcjPBA5gmUMeXESrlukuoK33+33uID8TWeLAdOWsKpJYzwVMB7bOzYSGOciyUlXSn0/ABXTosJ1M1SbypZ4O4MbZuIDMU02PMbauhhHMHXbmebmALIiEbbbbbUrpF1gwE9kFfRNAJaP+FQEXCCTGyJ4ngDrjOFo3jEL5JdqjF/pueR4cCeCGgAtwmuRS6gDwaRiGvu+DMFwSBLTE3+jF8JyuV1okPZ+AC4hDFhCHyHQjdjPHUKFDlHSJkHQXMB3KpSwXNGJPcwwTdZiXlRN0gSp0zpWxNtM0beYE0nRH6QIbO7rawwXaBYz0j78gxjokDuv12gVeUuBD0MDi0OQCLvDaAho4juP1Q/jkAncXqIcCfd+7gAu4QLMACCLxpRsSuQh0igu0C9Svhi7weAGZg50L3IE3cai4IfkNZAC8dfdhsUD3CgKBVC9JE5ABAFzg4QL/taYPAAWrHdYcgfLaIgAXWJ7OV38n1LEF8tt2TH29E+QAoDoO5Ve/LtCQDmKM9kPbvCEBApK+IXzbcSJ0cIGF6e8gpcRhUDogWZ8JnaWjPXc/fNnBBUKRngiHgTUSivSzDRDgHZQOLvBQgf8rRt+VdBUUhwkU6VpJ+xcOwQUqZr+mR0kvBUgv6cB4+37hQAkXqE8PwGisGhJtN4xAHMzrsgvI7rccXqSvKh6jltGlrOHA3Xk1At3LC4QiPdX9/0ndHpGVvTjR4bZA1ypAKgVcwE5vx74ulwIugDt8e/X7JgfkucBMIAr26ndnB4UCLnDOqvteQsHlgX9N4A+c4cW3DXSPbwAAAABJRU5ErkJggg==)](https://twil.io/learn-open-source)



  The documentation for the Twilio API can be found [here][apidocs].

  The Python library documentation can be found [here][libdocs].



  `twilio-python` uses a modified version of [Semantic Versioning](https://semver.org) for all changes. [See this document](VERSIONS.md) for details.



  Please consult the [official migration guide](https://www.twilio.com/docs/libraries/python/migration-guide) for information on upgrading your application using twilio-python 5.x to 6.x



  This library supports the following Python implementations:

  * Python 3.6
  * Python 3.7
  * Python 3.8
  * Python 3.9
  * Python 3.10
  * Python 3.11



  Install from PyPi using [pip](https://pip.pypa.io/en/latest/), a
  package manager for Python.

      pip install twilio

  If pip install fails on Windows, check the path length of the directory. If it is greater 260 characters then enable [Long Paths](https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation) or choose other shorter location.

  Don't have pip installed? Try installing it, by running this from the command
  line:

      $ curl https://bootstrap.pypa.io/get-pip.py | python

  Or, you can [download the source code
  (ZIP)](https://github.com/twilio/twilio-python/zipball/main "twilio-python
  source code") for `twilio-python`, and then run:

      python setup.py install

  You may need to run the above commands with `sudo`.



  Getting started with the Twilio API couldn't be easier. Create a
  `Client` and you're ready to go.



  The `Twilio` needs your Twilio credentials. You can either pass these
  directly to the constructor (see the code below) or via environment variables.

  ```python
  from twilio.rest import Client

  account = "ACXXXXXXXXXXXXXXXXX"
  token = "YYYYYYYYYYYYYYYYYY"
  client = Client(account, token)
  ```

  Alternatively, a `Client` constructor without these parameters will
  look for `TWILIO_ACCOUNT_SID` and `TWILIO_AUTH_TOKEN` variables inside the
  current environment.

  We suggest storing your credentials as environment variables. Why? You'll never
  have to worry about committing your credentials and accidentally posting them
  somewhere public.


  ```python
  from twilio.rest import Client
  client = Client()
  ```



  To take advantage of Twilio's [Global Infrastructure](https://www.twilio.com/docs/global-infrastructure), specify the target Region and/or Edge for the client:

  ```python
  from twilio.rest import Client

  client = Client(region='au1', edge='sydney')
  ```
  A `Client` constructor  without these parameters will also look for `TWILIO_REGION` and `TWILIO_EDGE` variables inside the current environment.

  Alternatively, you may specify the edge and/or region after constructing the Twilio client:

  ```python
  from twilio.rest import Client

  client = Client()
  client.region = 'au1'
  client.edge = 'sydney'
  ```

  This will result in the `hostname` transforming from `api.twilio.com` to `api.sydney.au1.twilio.com`.



  ```python
  from twilio.rest import Client

  account = "ACXXXXXXXXXXXXXXXXX"
  token = "YYYYYYYYYYYYYYYYYY"
  client = Client(account, token)

  call = client.calls.create(to="9991231234",
                             from_="9991231234",
                             url="http://twimlets.com/holdmusic?Bucket=com.twilio.music.ambient")
  print(call.sid)
  ```



  ```python
  from twilio.rest import Client

  account = "ACXXXXXXXXXXXXXXXXX"
  token = "YYYYYYYYYYYYYYYYYY"
  client = Client(account, token)

  message = client.messages.create(to="+12316851234", from_="+15555555555",
                                   body="Hello there!")
  ```



  Log the API request and response data to the console:

  ```python
  import logging

  client = Client(account, token)
  logging.basicConfig()
  client.http_client.logger.setLevel(logging.INFO)
  ```

  Log the API request and response data to a file:

  ```python
  import logging

  client = Client(account, token)
  logging.basicConfig(filename='./log.txt')
  client.http_client.logger.setLevel(logging.INFO)
  ```



  ```python
  from twilio.rest import Client
  from twilio.base.exceptions import TwilioRestException

  account = "ACXXXXXXXXXXXXXXXXX"
  token = "YYYYYYYYYYYYYYYYYY"
  client = Client(account, token)

  try:
    message = client.messages.create(to="+12316851234", from_="+15555555555",
                                     body="Hello there!")
  except TwilioRestException as e:
    print(e)
  ```

  For more descriptive exception types, please see the [Twilio documentation](https://www.twilio.com/docs/libraries/python/usage-guide#exceptions).



  To control phone calls, your application needs to output [TwiML][twiml].

  Use `twilio.twiml.Response` to easily create such responses.

  ```python
  from twilio.twiml.voice_response import VoiceResponse

  r = VoiceResponse()
  r.say("Welcome to twilio!")
  print(str(r))
  ```

  ```xml
  <?xml version="1.0" encoding="utf-8"?>
  <Response><Say>Welcome to twilio!</Say></Response>
  ```



  To use a custom HTTP client with this helper library, please see the [Twilio documentation](https://www.twilio.com/docs/libraries/python/custom-http-clients-python).



  The `Dockerfile` present in this repository and its respective `twilio/twilio-python` Docker image are currently used by Twilio for testing purposes only.



  If you need help installing or using the library, please check the [Twilio Support Help Center](https://support.twilio.com) first, and [file a support ticket](https://twilio.com/help/contact) if you don't find an answer to your question.

  If you've instead found a bug in the library or would like new features added, go ahead and open issues or pull requests against this repo!

  [apidocs]: https://www.twilio.com/docs/api
  [twiml]: https://www.twilio.com/docs/api/twiml
  [libdocs]: https://twilio.github.io/twilio-python


pkgId: abfc4534add5000612076150d2cf0fba2e0b864a1f415d271074b771c75d96d6
name: python-twilio
arch: src
version: 8.0.0
epoch: 0
release: 1
summary: Twilio API client and TwiML generator
url: https://github.com/twilio/twilio-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d0f3d962-7773-49f1-b69c-0c8adf592a57
location_href: 00008673-python-twilio/python-twilio-8.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/twilio/twilio-python/actions/workflows/test-and-deploy.yml/badge.svg)](https://github.com/twilio/twilio-python/actions/workflows/test-and-deploy.yml)
  [![PyPI](https://img.shields.io/pypi/v/twilio.svg)](https://pypi.python.org/pypi/twilio)
  [![PyPI](https://img.shields.io/pypi/pyversions/twilio.svg)](https://pypi.python.org/pypi/twilio)
  [![Learn OSS Contribution in TwilioQuest](https://img.shields.io/static/v1?label=TwilioQuest&message=Learn%20to%20contribute%21&color=F22F46&labelColor=1f243c&style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAASFBMVEUAAAAZGRkcHBwjIyMoKCgAAABgYGBoaGiAgICMjIyzs7PJycnMzMzNzc3UoBfd3d3m5ubqrhfrMEDu7u739/f4vSb/3AD///9tbdyEAAAABXRSTlMAAAAAAMJrBrEAAAKoSURBVHgB7ZrRcuI6EESdyxXGYoNFvMD//+l2bSszRgyUYpFAsXOeiJGmj4NkuWx1Qeh+Ekl9DgEXOBwOx+Px5xyQhDykfgq4wG63MxxaR4ddIkg6Ul3g84vCIcjPBA5gmUMeXESrlukuoK33+33uID8TWeLAdOWsKpJYzwVMB7bOzYSGOciyUlXSn0/ABXTosJ1M1SbypZ4O4MbZuIDMU02PMbauhhHMHXbmebmALIiEbbbbbUrpF1gwE9kFfRNAJaP+FQEXCCTGyJ4ngDrjOFo3jEL5JdqjF/pueR4cCeCGgAtwmuRS6gDwaRiGvu+DMFwSBLTE3+jF8JyuV1okPZ+AC4hDFhCHyHQjdjPHUKFDlHSJkHQXMB3KpSwXNGJPcwwTdZiXlRN0gSp0zpWxNtM0beYE0nRH6QIbO7rawwXaBYz0j78gxjokDuv12gVeUuBD0MDi0OQCLvDaAho4juP1Q/jkAncXqIcCfd+7gAu4QLMACCLxpRsSuQh0igu0C9Svhi7weAGZg50L3IE3cai4IfkNZAC8dfdhsUD3CgKBVC9JE5ABAFzg4QL/taYPAAWrHdYcgfLaIgAXWJ7OV38n1LEF8tt2TH29E+QAoDoO5Ve/LtCQDmKM9kPbvCEBApK+IXzbcSJ0cIGF6e8gpcRhUDogWZ8JnaWjPXc/fNnBBUKRngiHgTUSivSzDRDgHZQOLvBQgf8rRt+VdBUUhwkU6VpJ+xcOwQUqZr+mR0kvBUgv6cB4+37hQAkXqE8PwGisGhJtN4xAHMzrsgvI7rccXqSvKh6jltGlrOHA3Xk1At3LC4QiPdX9/0ndHpGVvTjR4bZA1ypAKgVcwE5vx74ulwIugDt8e/X7JgfkucBMIAr26ndnB4UCLnDOqvteQsHlgX9N4A+c4cW3DXSPbwAAAABJRU5ErkJggg==)](https://twil.io/learn-open-source)



  The documentation for the Twilio API can be found [here][apidocs].

  The Python library documentation can be found [here][libdocs].



  `twilio-python` uses a modified version of [Semantic Versioning](https://semver.org) for all changes. [See this document](VERSIONS.md) for details.



  Please consult the [official migration guide](https://www.twilio.com/docs/libraries/python/migration-guide) for information on upgrading your application using twilio-python 5.x to 6.x



  This library supports the following Python implementations:

  * Python 3.7
  * Python 3.8
  * Python 3.9
  * Python 3.10
  * Python 3.11



  Install from PyPi using [pip](https://pip.pypa.io/en/latest/), a
  package manager for Python.

      pip install twilio

  If pip install fails on Windows, check the path length of the directory. If it is greater 260 characters then enable [Long Paths](https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation) or choose other shorter location.

  Don't have pip installed? Try installing it, by running this from the command
  line:

      $ curl https://bootstrap.pypa.io/get-pip.py | python

  Or, you can [download the source code
  (ZIP)](https://github.com/twilio/twilio-python/zipball/main "twilio-python
  source code") for `twilio-python`, and then run:

      python setup.py install

  You may need to run the above commands with `sudo`.



  Getting started with the Twilio API couldn't be easier. Create a
  `Client` and you're ready to go.



  The `Twilio` client needs your Twilio credentials. You can either pass these
  directly to the constructor (see the code below) or via environment variables.

  Authenticating with Account SID and Auth Token:
  ```python
  from twilio.rest import Client

  account_sid = "ACXXXXXXXXXXXXXXXXX"
  auth_token = "YYYYYYYYYYYYYYYYYY"
  client = Client(account_sid, auth_token)
  ```

  Authenticating with API Key and API Secret:
  ```python
  from twilio.rest import Client

  api_key = "XXXXXXXXXXXXXXXXX"
  api_secret = "YYYYYYYYYYYYYYYYYY"
  account_sid = "ACXXXXXXXXXXXXXXXXX"
  client = Client(api_key, api_secret, account_sid)
  ```

  Alternatively, a `Client` constructor without these parameters will
  look for `TWILIO_ACCOUNT_SID` and `TWILIO_AUTH_TOKEN` variables inside the
  current environment.

  We suggest storing your credentials as environment variables. Why? You'll never
  have to worry about committing your credentials and accidentally posting them
  somewhere public.


  ```python
  from twilio.rest import Client
  client = Client()
  ```



  To take advantage of Twilio's [Global Infrastructure](https://www.twilio.com/docs/global-infrastructure), specify the target Region and/or Edge for the client:

  ```python
  from twilio.rest import Client

  client = Client(region='au1', edge='sydney')
  ```
  A `Client` constructor  without these parameters will also look for `TWILIO_REGION` and `TWILIO_EDGE` variables inside the current environment.

  Alternatively, you may specify the edge and/or region after constructing the Twilio client:

  ```python
  from twilio.rest import Client

  client = Client()
  client.region = 'au1'
  client.edge = 'sydney'
  ```

  This will result in the `hostname` transforming from `api.twilio.com` to `api.sydney.au1.twilio.com`.



  ```python
  from twilio.rest import Client

  username = "ACXXXXXXXXXXXXXXXXX"
  password = "YYYYYYYYYYYYYYYYYY"
  client = Client(username, password)

  call = client.calls.create(to="9991231234",
                             from_="9991231234",
                             url="http://twimlets.com/holdmusic?Bucket=com.twilio.music.ambient")
  print(call.sid)
  ```



  ```python
  from twilio.rest import Client

  username = "ACXXXXXXXXXXXXXXXXX"
  password = "YYYYYYYYYYYYYYYYYY"
  client = Client(username, password)

  message = client.messages.create(to="+12316851234", from_="+15555555555",
                                   body="Hello there!")
  ```



  By default, the Twilio Client will make synchronous requests to the Twilio API. To allow for asynchronous, non-blocking requests, we've included an optional asynchronous HTTP client. When used with the Client and the accompanying `*_async` methods, requests made to the Twilio API will be performed asynchronously.

  ```python
  from twilio.http.async_http_client import AsyncTwilioHttpClient
  from twilio.rest import Client

  async def main():
      username = "ACXXXXXXXXXXXXXXXXX"
      password = "YYYYYYYYYYYYYYYYYY"
      http_client = AsyncTwilioHttpClient()
      client = Client(username, password, http_client=http_client)

      message = await client.messages.create_async(to="+12316851234", from_="+15555555555",
                                                   body="Hello there!")

  asyncio.run(main())
  ```



  Log the API request and response data to the console:

  ```python
  import logging

  client = Client(username, password)
  logging.basicConfig()
  client.http_client.logger.setLevel(logging.INFO)
  ```

  Log the API request and response data to a file:

  ```python
  import logging

  client = Client(username, password)
  logging.basicConfig(filename='./log.txt')
  client.http_client.logger.setLevel(logging.INFO)
  ```



  ```python
  from twilio.rest import Client
  from twilio.base.exceptions import TwilioRestException

  username = "ACXXXXXXXXXXXXXXXXX"
  password = "YYYYYYYYYYYYYYYYYY"
  client = Client(username, password)

  try:
    message = client.messages.create(to="+12316851234", from_="+15555555555",
                                     body="Hello there!")
  except TwilioRestException as e:
    print(e)
  ```

  For more descriptive exception types, please see the [Twilio documentation](https://www.twilio.com/docs/libraries/python/usage-guide#exceptions).



  To control phone calls, your application needs to output [TwiML][twiml].

  Use `twilio.twiml.Response` to easily create such responses.

  ```python
  from twilio.twiml.voice_response import VoiceResponse

  r = VoiceResponse()
  r.say("Welcome to twilio!")
  print(str(r))
  ```

  ```xml
  <?xml version="1.0" encoding="utf-8"?>
  <Response><Say>Welcome to twilio!</Say></Response>
  ```



  To use a custom HTTP client with this helper library, please see the [Twilio documentation](https://www.twilio.com/docs/libraries/python/custom-http-clients-python).



  The `Dockerfile` present in this repository and its respective `twilio/twilio-python` Docker image are currently used by Twilio for testing purposes only.



  If you need help installing or using the library, please check the [Twilio Support Help Center](https://support.twilio.com) first, and [file a support ticket](https://twilio.com/help/contact) if you don't find an answer to your question.

  If you've instead found a bug in the library or would like new features added, go ahead and open issues or pull requests against this repo!

  [apidocs]: https://www.twilio.com/docs/api
  [twiml]: https://www.twilio.com/docs/api/twiml
  [libdocs]: https://twilio.github.io/twilio-python


pkgId: 450fd60a4239d3464e45c57318dbe3e88c796fef9858698f9c841a328fad12dc
name: python-twitter
arch: src
version: 1.19.6
epoch: 0
release: 1
summary: An API and command-line toolset for Twitter (twitter.com)
url: https://mike.verdone.ca/twitter/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e4d0108a-1b42-4688-9064-6a362c4dadef
location_href: 00005352-python-twitter/python-twitter-1.19.6-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/python-twitter-tools/twitter/workflows/Tests/badge.svg)](https://github.com/python-twitter-tools/twitter/actions)
  [![Coverage Status](https://coveralls.io/repos/github/python-twitter-tools/twitter/badge.svg?branch=master)](https://coveralls.io/github/python-twitter-tools/twitter?branch=master)
  The Minimalist Twitter API for Python is a Python API for Twitter,
  everyone's favorite Web 2.0 Facebook-style status updater for people
  on the go.
  Also included is a Twitter command-line tool for getting your friends'
  tweets and setting your own tweet from the safety and security of your
  favorite shell and an IRC bot that can announce Twitter updates to an
  IRC channel.
  For more information:
   * install the [package](https://pypi.org/project/twitter/) `pip install twitter`
   * import the `twitter` package and run `help()` on it
   * run `twitter -h` for command-line tool help


pkgId: 6607cf7c18b3cad7cdba007886d8fe886655e70fc513e9c8fcdce6676c16fc31
name: python-twython
arch: src
version: 3.9.1
epoch: 0
release: 1
url: https://github.com/ryanmcgrath/twython/tree/master
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f7cd5af1-445e-4480-be11-32dc6a56e50f
location_href: 00011335-python-twython/python-twython-3.9.1-1.src.rpm
checksum_type: sha256
summary:
  Actively maintained, pure Python wrapper for the Twitter API. Supports both normal and streaming Twitter APIs

description:
  **Function definitions (i.e. get_home_timeline()) can be found by reading over twython/endpoints.py**
  Create a Twython instance with your application keys and the users OAuth tokens
  ```python
  from twython import Twython
  twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
  ```

  ```python
  twitter.get_home_timeline()
  ```

  This method makes use of dynamic arguments, [read more about them](https://twython.readthedocs.io/en/latest/usage/starting_out.html#dynamic-function-arguments).
  ```python
  twitter.update_status(status='See how easy using Twython is!')
  ```

  - [Advanced Twython Usage](https://twython.readthedocs.io/en/latest/usage/advanced_usage.html)
  - [Streaming with Twython](https://twython.readthedocs.io/en/latest/usage/streaming_api.html)

  My hope is that Twython is so simple that you'd never *have* to ask any questions, but if you feel the need to contact me for this (or other) reasons, you can hit me up at ryan@venodesigns.net.
  Or if I'm to busy to answer, feel free to ping mikeh@ydekproductions.com as well.
  Follow us on Twitter:
  - [@ryanmcgrath](https://twitter.com/ryanmcgrath)
  - [@mikehelmick](https://twitter.com/mikehelmick)

  Twython is useful, but ultimately only as useful as the people using it (say that ten times fast!). If you'd like to help, write example code, contribute patches, document things on the wiki, tweet about it. Your help is always appreciated!


  - Bump release with latest patches from GitHub.
  - Fix Direct Messages with patches from @manuelcortez.

  - Fixes for cursoring API endpoints
  - Improve `html_for_tweet()` parsing
  - Documentation cleanup
  - Documentation for cursor's `return_pages` keyword argument
  - Update links to Twitter API in documentation
  - Added `create_metadata` endpoint
  - Raise error for when cursor is not provided a callable

  - Improve replacing of entities with links in `html_for_tweet()`
  - Update classifiers for PyPI

  - Added support for "symbols" in `Twython.html_for_tweet()`
  - Added support for extended tweets in `Twython.html_for_tweet()`
  - You can now check progress of video uploads to Twitter when using `Twython.upload_video()`

  - Added `upload_video` endpoint
  - Fix quoted status checks in `html_for_tweet`
  - Fix `html_for_tweet` method response when hashtag/mention is a substring of another

  - Added support for muting users
  - Fix typos in documentation
  - Updated documentation examples
  - Added dynamic filtering to streamer

  - PEP8'd some code
  - Added `lookup_status` function to `endpoints.py`
  - Added keyword argument to `cursor` to return full pages rather than individual results
  - `cursor` now uses while loop rather than recursion
  - Fixed issue where Twython was unnecessarily disabling compression
  - Using `responses` to mock API calls in tests
  - Fixed some typos in  documentation
  - Added `retry_after` attribute to `TwythonRateLimitError`
  - Added `upload_media` method to `Twython` in favor of `update_with_media`
  - Deprecating `update_with_media` per Twitter API 1.1 (https://dev.twitter.com/rest/reference/post/statuses/update_with_media)
  - Unpin `requests` and `requests-oauthlib` in `requirements.txt`

  - Fixed Changelog (HISTORY.rst)

  - Update `requests` version to 2.1.0.
  - Fixed: Streaming issue where `Exceptions` in handlers or `on_success` which subclass `ValueError` would previously be caught and reported as a JSON decoding problem, and `on_error()` would be called (with status_code=200)
  - Fixed issue where XML was returned when bad tokens were passed to `get_authorized_tokens`
  - Fixed import for `setup` causing installation to fail on some devices (eg. Nokia N9/MeeGo)

  - Added ``html_for_tweet`` static method. This method accepts a tweet object returned from a Twitter API call and will return a string with urls, mentions and hashtags in the tweet replaced with HTML.
  - Pass ``client_args`` to the streaming ``__init__``, much like in core Twython (you can pass headers, timeout, hooks, proxies, etc.).
  - Streamer has new parameter ``handlers`` which accepts a list of strings related to functions that are apart of the Streaming class and start with "on\_". i.e. ['delete'] is passed, when 'delete' is received from a stream response; ``on_delete`` will be called.
  - When an actual request error happens and a ``RequestException`` is raised, it is caught and a ``TwythonError`` is raised instead for convenience.
  - Added "cursor"-like functionality. Endpoints with the attribute ``iter_mode`` will be able to be passed to ``Twython.cursor`` and returned as a generator.
  - ``Twython.search_gen`` has been deprecated. Please use ``twitter.cursor(twitter.search, q='your_query')`` instead, where ``twitter`` is your ``Twython`` instance.
  - Added methods ``get_list_memberships``, ``get_twitter_configuration``, ``get_supported_languages``, ``get_privacy_policy``, ``get_tos``
  - Added ``auth_endpoint`` parameter to ``Twython.__init__`` for cases when the right parameters weren't being shown during the authentication step.
  - Fixed streaming issue where results wouldn't be returned for streams that weren't so active (See https://github.com/ryanmcgrath/twython/issues/202#issuecomment-19915708)
  - Streaming API now uses ``_transparent_params`` so when passed ``True`` or ``False`` or an array, etc. Twython formats it to meet Twitter parameter standards (i.e. ['ryanmcgrath', 'mikehelmick', 'twitterapi'] would convert to string 'ryanmcgrath,mikehelmick,twitterapi')

  - Changed ``twython/twython.py`` to ``twython/api.py`` in attempt to make structure look a little neater
  - Removed all camelCase function access (anything like ``getHomeTimeline`` is now ``get_home_timeline``)
  - Removed ``shorten_url``. With the ``requests`` library, shortening a URL on your own is simple enough
  - ``twitter_token``, ``twitter_secret`` and ``callback_url`` are no longer passed to ``Twython.__init__``
      - ``twitter_token`` and ``twitter_secret`` have been replaced with ``app_key`` and ``app_secret`` respectively
      - ``callback_url`` is now passed through ``Twython.get_authentication_tokens``
  - Update ``test_twython.py`` docstrings per http://www.python.org/dev/peps/pep-0257/
  - Removed ``get_list_memberships``, method is Twitter API 1.0 deprecated
  - Developers can now pass an array as a parameter to Twitter API methods and they will be automatically joined by a comma and converted to a string
  - ``endpoints.py`` now contains ``EndpointsMixin`` (rather than the previous ``api_table`` dict) for Twython, which enables Twython to use functions declared in the Mixin.
  - Added OAuth 2 authentication (Application Only) for when you want to make read-only calls to Twitter without having to go through the whole user authentication ritual (see docs for usage)
  - Added ``obtain_access_token`` to obtain an OAuth 2 Application Only read-only access token
  - ``construct_api_url`` now accepts keyword arguments like other Twython methods (e.g. instead of passing ``{'q': 'twitter', 'result_type': 'recent'}``, pass ``q='twitter', result_type='recent'``)
  - Pass ``client_args`` to the Twython ``__init__`` to manipulate request variables. ``client_args`` accepts a dictionary of keywords and values that accepted by ``requests`` (`Session API <http://docs.python-requests.org/en/latest/api/#sessionapi>`_) [ex. headers, proxies, verify(SSL verification)] and the "request" section directly below it.
  - Added ``get_application_rate_limit_status`` API method for returning the current rate limits for the specified source
  - Added ``invalidate_token`` API method which allows registed apps to revoke an access token presenting its client credentials
  - ``get_lastfunction_header`` now accepts a ``default_return_value`` parameter. This means that if you pass a second value (ex. ``Twython.get_lastfunction_header('x-rate-limit-remaining', 0)``) and the value is not found, it returns your default value

  - More test coverage!
  - Fix ``search_gen``
  - Fixed ``get_lastfunction_header`` to actually do what its docstring says, returns ``None`` if header is not found
  - Updated some internal API code, ``__init__`` didn't need to have ``self.auth`` and ``self.headers`` because they were never used anywhere else but the ``__init__``
  - Added ``disconnect`` method to ``TwythonStreamer``, allowing users to disconnect as they desire
  - Updated ``TwythonStreamError`` docstring, also allow importing it from ``twython``
  - No longer raise ``TwythonStreamError`` when stream line can't be decoded. Instead, sends signal to ``TwythonStreamer.on_error``
  - Allow for (int, long, float) params to be passed to Twython Twitter API functions in Python 2, and (int, float) in Python 3

  - Added ``get_retweeters_ids`` method
  - Fixed ``TwythonDeprecationWarning`` on camelCase functions if the camelCase was the same as the PEP8 function (i.e. ``Twython.retweet`` did not change)
  - Fixed error message bubbling when error message returned from Twitter was not an array (i.e. if you try to retweet something twice, the error is not found at index 0)
  - Added "transparent" parameters for making requests, meaning users can pass bool values (True, False) to Twython methods and we convert your params in the background to satisfy the Twitter API. Also, file objects can now be passed seamlessly (see examples in README and in /examples dir for details)
  - Callback URL is optional in ``get_authentication_tokens`` to accomedate those using OOB authorization (non web clients)
  - Not part of the python package, but tests are now available along with Travis CI hooks
  - Added ``__repr__`` definition for Twython, when calling only returning <Twython: APP_KEY>
  - Cleaned up ``Twython.construct_api_url``, uses "transparent" parameters (see 4th bullet in this version for explaination)
  - Update ``requests`` and ``requests-oauthlib`` requirements, fixing posting files AND post data together, making authenticated requests in general in Python 3.3

  - "PEP8" all the functions. Switch functions from camelCase() to underscore_funcs(). (i.e. ``updateStatus()`` is now ``update_status()``)

  - Fixed streaming issue #144, added ``TwythonStreamer`` to aid users in a friendly streaming experience (streaming examples in ``examples`` and README's have been updated as well)
  - ``Twython`` now requires ``requests-oauthlib`` 0.3.1, fixes #154 (unable to upload media when sending POST data with the file)

  - Added a ``HISTORY.rst`` to start tracking history of changes
  - Updated ``twitter_endpoints.py`` to ``endpoints.py`` for cleanliness
  - Removed twython3k directory, no longer needed
  - Added ``compat.py`` for compatability with Python 2.6 and greater
  - Added some ascii art, moved description of Twython and ``__author__`` to ``__init__.py``
  - Added ``version.py`` to store the current Twython version, instead of repeating it twice -- it also had to go into it's own file because of dependencies of ``requests`` and ``requests-oauthlib``, install would fail because those libraries weren't installed yet (on fresh install of Twython)
  - Removed ``find_packages()`` from ``setup.py``, only one package (we can just define it)
  - added quick publish method for Ryan and I: ``python setup.py publish`` is faster to type and easier to remember than ``python setup.py sdist upload``
  - Removed ``base_url`` from ``endpoints.py`` because we're just repeating it in ``Twython.__init__``
  - ``Twython.get_authentication_tokens()`` now takes ``callback_url`` argument rather than passing the ``callback_url`` through ``Twython.__init__``, ``callback_url`` is only used in the ``get_authentication_tokens`` method and nowhere else (kept in init though for backwards compatability)
  - Updated README to better reflect current Twython codebase
  - Added ``warnings.simplefilter('default')`` line in ``twython.py`` for Python 2.7 and greater to display Deprecation Warnings in console
  - Added Deprecation Warnings for usage of ``twitter_token``, ``twitter_secret`` and ``callback_url`` in ``Twython.__init__``
  - Headers now always include the User-Agent as Twython vXX unless User-Agent is overwritten
  - Removed senseless TwythonError thrown if method is not GET or POST, who cares -- if the user passes something other than GET or POST just let Twitter return the error that they messed up
  - Removed conversion to unicode of (int, bool) params passed to a requests. ``requests`` isn't greedy about variables that can't be converted to unicode anymore
  - Removed `bulkUserLookup` (please use `lookupUser` instead), removed `getProfileImageUrl` (will be completely removed from Twitter API on May 7th, 2013)
  - Updated shortenUrl to actually work for those using it, but it is being deprecated since `requests` makes it easy for developers to implement their own url shortening in their app (see https://github.com/ryanmcgrath/twython/issues/184)
  - Twython Deprecation Warnings will now be seen in shell when using Python 2.7 and greater
  - Twython now takes ``ssl_verify`` parameter, defaults True. Set False if you're having development server issues
  - Removed internal ``_media_update`` function, we could have always just used ``self.post``

  - Fixed issue where Twython Exceptions were not being logged correctly

  - Fixed ``AttributeError`` when trying to decode the JSON response via ``Response.json()``

  - Removed ``simplejson`` dependency
  - Fixed ``destroyDirectMessage``, ``createBlock``, ``destroyBlock`` endpoints in ``twitter_endpoints.py``
  - Added ``getProfileBannerSizes`` method to ``twitter_endpoints.py``
  - Made oauth_verifier argument required in ``get_authorized_tokens``
  - Update ``updateProfileBannerImage`` to use v1.1 endpoint

  - New ``showOwnedLists`` method

  - Added missing slash to ``getMentionsTimeline`` in ``twitter_endpoints.py``

  - Updated ``twitter_endpoints.py`` to better reflect order of API endpoints on the Twitter API v1.1 docs site


pkgId: 3f6c70a867851dadf451cb25bb6204fb11d4863d4e9664c067b481585135ecd9
name: python-txredisapi
arch: src
version: 1.4.9
epoch: 0
release: 1
summary: non-blocking redis client for python
url: http://github.com/IlyaSkriblovsky/txredisapi
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-027f75b5-619f-4c3b-9575-1cf671756f73
location_href: 00008678-python-txredisapi/python-txredisapi-1.4.9-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://secure.travis-ci.org/IlyaSkriblovsky/txredisapi.png)](http://travis-ci.org/IlyaSkriblovsky/txredisapi)
  *For the latest source code, see <http://github.com/IlyaSkriblovsky/txredisapi>*
  ``txredisapi`` is a non-blocking client driver for the [redis](http://redis.io)
  database, written in Python. It uses [Twisted](http://twistedmatrix.com) for
  the asynchronous communication with redis.
  It started as a fork of the original
  [redis protocol for twisted](http://pypi.python.org/pypi/txredis/), and evolved
  into a more robust, reliable, and complete solution for applications like web
  servers. These types of applications often need a fault-tolerant pool of
  connections with multiple redis servers, making it possible to easily develop
  and maintain distributed systems.
  Most of the [redis commands](http://redis.io/commands) are supported, as well
  as other features such as silent reconnection, connection pools, and automatic
  sharding.
  This driver is distributed as part of the [cyclone](http://cyclone.io) web
  framework.

  See [CHANGELOG.md](CHANGELOG.md)

  - Connection Pools
  - Lazy Connections
  - Automatic Sharding
  - Automatic Reconnection
  - Connection using Redis Sentinel
  - Publish/Subscribe (PubSub)
  - Transactions
  - Unix Socket Connections


pkgId: 512c48aa0deb8c300a8e164edb6012e62a9cf2f360d817631095adead51385ef
name: python-txtorcon
arch: src
version: 23.0.0
epoch: 0
release: 1
url: https://github.com/meejah/txtorcon
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ec7b4866-d9bb-42a7-8215-7081c30ad3a8
location_href: 00005355-python-txtorcon/python-txtorcon-23.0.0-1.src.rpm
checksum_type: sha256
summary:
  Twisted-based Tor controller client, with state-tracking and     configuration abstractions.     https://txtorcon.readthedocs.org     https://github.com/meejah/txtorcon

description:
  - **docs**: https://txtorcon.readthedocs.org or http://fjblvrw2jrxnhtg67qpbzi45r7ofojaoo3orzykesly2j3c2m3htapid.onion/
  - **code**: https://github.com/meejah/txtorcon
  - ``torsocks git clone git://fjblvrw2jrxnhtg67qpbzi45r7ofojaoo3orzykesly2j3c2m3htapid.onion/txtorcon.git``
  - MIT-licensed;
  - Python 3.5+, PyPy 5.0.0+;
  - depends on
    `Twisted`_,
    `Automat <https://github.com/glyph/automat>`_


pkgId: fc4fe8909b2752dcbd63f19ada11096fc9bed4950ef0009f19901117ab57c377
name: python-typed-ast
arch: src
version: 1.5.4
epoch: 0
release: 1
summary: a fork of Python 2 and 3 ast modules with type comment support
url: https://github.com/python/typed_ast
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a037064-3123-4daa-b4c3-8236831320d9
location_href: 00005358-python-typed_ast/python-typed-ast-1.5.4-1.src.rpm
checksum_type: sha256
description:
  `typed_ast` is a Python 3 package that provides a Python 2.7 and Python 3
  parser similar to the standard `ast` library.  Unlike `ast` below Python 3.8,
  the parsers in
  `typed_ast` include PEP 484 type comments and are independent of the version of
  Python under which they are run.  The `typed_ast` parsers produce the standard
  Python AST (plus type comments), and are both fast and correct, as they are
  based on the CPython 2.7 and 3.7 parsers.

  **Note:** The `ast` module of Python 3.8+ supports all features of `typed_ast`.
  `typed_ast` does not support parsing code that uses syntax introduced in
  Python 3.8 onwards.
  We recommend using `ast` on Python 3.8 or above.


pkgId: 332cacaabf6d33e092e119c201e1aa81be3a9e668a2b7351b9eab609b045bf9f
name: python-typeguard
arch: src
version: 2.13.3
epoch: 0
release: 1
summary: Run-time type checker for Python
url: https://pypi.org/project/typeguard/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e8335be-18bb-4963-8203-dd347dfc79cc
location_href: 00005360-python-typeguard/python-typeguard-2.13.3-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://travis-ci.com/agronholm/typeguard.svg?branch=master
    :target: https://travis-ci.com/agronholm/typeguard
    :alt: Build Status
  .. image:: https://coveralls.io/repos/agronholm/typeguard/badge.svg?branch=master&service=github
    :target: https://coveralls.io/github/agronholm/typeguard?branch=master
    :alt: Code Coverage
  .. image:: https://readthedocs.org/projects/typeguard/badge/?version=latest
    :target: https://typeguard.readthedocs.io/en/latest/?badge=latest

  This library provides run-time type checking for functions defined with
  `PEP 484 <https://www.python.org/dev/peps/pep-0484/>`_ argument (and return) type annotations.

  Four principal ways to do type checking are provided, each with its pros and cons:



     * debugger friendly (except when running with the pydev debugger with the C extension installed)
     * does not work reliably with dynamically defined type hints (e.g. in nested functions)


     * automatically type checks yields and sends of returned generators (regular and async)
     * adds an extra frame to the call stack for every call to a decorated function


     * emits warnings instead of raising ``TypeError``
     * requires very few modifications to the code
     * multiple TypeCheckers can be stacked/nested
     * does not work reliably with dynamically defined type hints (e.g. in nested functions)
     * may cause problems with badly behaving debuggers or profilers
     * cannot distinguish between an exception being raised and a ``None`` being returned


     * automatically annotates classes and functions with ``@typechecked`` on import
     * no code changes required in target modules
     * requires imports of modules you need to check to be deferred until after the import hook has
       been installed
     * may clash with other import hooks

  See the documentation_ for further instructions.

  .. _documentation: https://typeguard.readthedocs.io/en/latest/


pkgId: f9df2e32a6f3ae995c24dc93efd882a14f41dee19523de6fda4dca4af081a6d3
name: python-typepy
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: typepy is a Python library for variable type checker/validator/converter at a run time.
url: https://github.com/thombashi/typepy
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-29a834c1-2dd6-470e-ae89-de4306067cec
location_href: 00010681-python-typepy/python-typepy-1.3.0-1.src.rpm
checksum_type: sha256
description:
  `typepy <https://github.com/thombashi/typepy>`__ is a Python library for variable type checker/validator/converter at a run time.


pkgId: 6aed329a695f8052240e357a32e57940bf6814487c8dce8ab52fbf465ed4b72a
name: python-types-Markdown
arch: src
version: 3.4.2.7
epoch: 0
release: 1
summary: Typing stubs for Markdown
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c27c0051-59a6-4606-bee7-9ce431c31f76
location_href: 00011311-python-types-markdown/python-types-Markdown-3.4.2.7-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `Markdown` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `Markdown`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/Markdown. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `fe9eb630eedfc588c57cee51807c505c072c1348`.


pkgId: 6ad679d4bc6649ee2eae1637a7931bd29ee867fdda6e6156a39f53b82f2a0d24
name: python-types-PyYAML
arch: src
version: 6.0.12.9
epoch: 0
release: 1
summary: Typing stubs for PyYAML
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a5a33d3c-a4ab-4a57-a872-b98a55178f7d
location_href: 00009512-python-types-pyyaml/python-types-PyYAML-6.0.12.9-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `PyYAML` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `PyYAML`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/PyYAML. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: 01b9b0dec8f3f4f0a45f6a03a10e1228f7d6a773724cf2a93e5e2ef457adc592
name: python-types-Pygments
arch: src
version: 2.14.0.7
epoch: 0
release: 1
summary: Typing stubs for Pygments
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-15eaab63-9ade-4271-96a8-80ac0dcaeadc
location_href: 00011035-python-types-pygments/python-types-Pygments-2.14.0.7-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `Pygments` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `Pygments`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/Pygments. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: 811817565bdf33a3e2cf71e7d78df5b6f7cf9687d15d23dce1a32a7cba5184b5
name: python-types-Werkzeug
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: Typing stubs for Werkzeug
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c5ce8d88-4179-4c89-829d-d82055dd957a
location_href: 00010990-python-types-werkzeug/python-types-Werkzeug-1.0.9-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `Werkzeug` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `Werkzeug`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/Werkzeug. All fixes for
  types and metadata should be contributed there.

  *Note:* The `Werkzeug` package includes type annotations or type stubs
  since version 2.0. Please uninstall the `types-Werkzeug`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `a5bc1e037fa9fb541d81de92ad27fa8543c65be4`.


pkgId: df7249c1a4adbfbebab6c4c5fbb4eb634effa2170e86a7e514b57a4898a1b2e4
name: python-types-aiofiles
arch: src
version: 23.1.0.1
epoch: 0
release: 1
summary: Typing stubs for aiofiles
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-14f2e739-963f-4e55-ad9e-da4c6624a82e
location_href: 00010776-python-types-aiofiles/python-types-aiofiles-23.1.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `aiofiles` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `aiofiles`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/aiofiles. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: fba7b7a53ae5275d1db428a93182ce6142adbf4d8b89f364dadee38d07ac2ae0
name: python-types-bleach
arch: src
version: 6.0.0.2
epoch: 0
release: 1
summary: Typing stubs for bleach
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dfe4bbe9-ade8-441c-a507-a8eae13c7347
location_href: 00012585-python-types-bleach/python-types-bleach-6.0.0.2-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `bleach` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `bleach`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/bleach. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: f50e20eafe2c7ac8cc30f0743cd6c52528954d54fe6647e09ebc14669ee70bd7
name: python-types-boto
arch: src
version: 2.49.18.7
epoch: 0
release: 1
summary: Typing stubs for boto
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f36c942-500d-4735-bf7c-bc296725e7e5
location_href: 00013065-python-types-boto/python-types-boto-2.49.18.7-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `boto` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `boto`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/boto. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: e84ce532dca41984051dfedab427b4449676b980da98630b191907874f9dfb34
name: python-types-cachetools
arch: src
version: 5.3.0.5
epoch: 0
release: 1
summary: Typing stubs for cachetools
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddc93e2e-11fd-4dbf-8dc6-cc74df6283bd
location_href: 00010576-python-types-cachetools/python-types-cachetools-5.3.0.5-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `cachetools` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `cachetools`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/cachetools. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: 56ebc4266d0ad7523644123252db88087b25f5785414bd2138514c6013de0103
name: python-types-click
arch: src
version: 7.1.8
epoch: 0
release: 1
summary: Typing stubs for click
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cb6f2fe5-12b0-433d-afe6-60bc56c27c23
location_href: 00010629-python-types-click/python-types-click-7.1.8-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `click` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `click`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/click. All fixes for
  types and metadata should be contributed there.

  *Note:* The `click` package includes type annotations or type stubs
  since version 8.0. Please uninstall the `types-click`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `2445eddb4b67fdaa58ec7c2113ff1542021a6206`.


pkgId: 7dd1bfd838b54816fae32950ab6951e0348326a7598a83b0c1e26817d0f87659
name: python-types-croniter
arch: src
version: 1.3.2.8
epoch: 0
release: 1
summary: Typing stubs for croniter
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb62e9f9-85cf-4baf-8bcb-eadb24989425
location_href: 00013701-python-types-croniter/python-types-croniter-1.3.2.8-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `croniter` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `croniter`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/croniter. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `02b8f77630c8dbb60a4d00c362d01519e9639591`.


pkgId: ac3e48607e992b456df26cfbeb6138c0a0f3ab6c7d26838311d5d1e89079bbb0
name: python-types-cryptography
arch: src
version: 3.3.23.2
epoch: 0
release: 1
summary: Typing stubs for cryptography
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-edb45f21-cd85-4925-b057-414bb4468e10
location_href: 00010376-python-types-cryptography/python-types-cryptography-3.3.23.2-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `cryptography` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `cryptography`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/cryptography. All fixes for
  types and metadata should be contributed there.

  *Note:* The `cryptography` package includes type annotations or type stubs
  since version 3.4.4. Please uninstall the `types-cryptography`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `c0e9038f0d71a38efc672ac5ef11aae0292c0a96`.


pkgId: 008a6c171c93a58b173b91e8b61c2d597c8bd0b51d8b059b61c2e65985f478c6
name: python-types-dataclasses
arch: src
version: 0.6.6
epoch: 0
release: 1
summary: Typing stubs for dataclasses
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ed17e346-cd72-4aff-bc0e-834f39adf6a3
location_href: 00009633-python-types-dataclasses/python-types-dataclasses-0.6.6-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `dataclasses` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `dataclasses`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/dataclasses. All fixes for
  types and metadata should be contributed there.

  *Note:* `types-dataclasses` is unmaintained and won't be updated.


  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `ec7ab6d4d6147adf01565d3b2bb2ae4d750f6b1e`.


pkgId: bf4cb7a30b122a27b049e43939772d23504a11a3dd137229dbc32af22fec6b67
name: python-types-dateparser
arch: src
version: 1.1.4.9
epoch: 0
release: 1
summary: Typing stubs for dateparser
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc9da260-bff3-4510-97a6-717fb6d68ce1
location_href: 00013584-python-types-dateparser/python-types-dateparser-1.1.4.9-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `dateparser` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `dateparser`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/dateparser. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: 1636a0723e4afe70255129c36f8b783d23b5953f50b647dcbfc95232b9127ce4
name: python-types-decorator
arch: src
version: 5.1.8.3
epoch: 0
release: 1
summary: Typing stubs for decorator
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f973639c-960f-4659-bbb7-eef2d2fb0bdd
location_href: 00010674-python-types-decorator/python-types-decorator-5.1.8.3-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `decorator` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `decorator`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/decorator. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `880c0da4045cd5ff2c29b73429629adf27e49d50`.


pkgId: 3d6304f1ce0d21cacf1c6ed503a73e09f8f783fc100718e59bd51aef671b9f94
name: python-types-docutils
arch: src
version: 0.19.1.7
epoch: 0
release: 1
summary: Typing stubs for docutils
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0c26e52b-33a9-4acf-8332-a75a6b78f7c8
location_href: 00010813-python-types-docutils/python-types-docutils-0.19.1.7-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `docutils` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `docutils`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/docutils. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: 2b9606630ebf9d547166dbc454c09c475282338fd1d39b19ad8c3d42c11c5a51
name: python-types-enum34
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: Typing stubs for enum34
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb221b74-6257-4c4f-9a1f-8d5c9107485a
location_href: 00010350-python-types-enum34/python-types-enum34-1.1.8-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `enum34` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `enum34`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/enum34. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `aea52b35d1f5a9306f66e1b98314f4ecbe0ffa7a`.


pkgId: 8fe75c4a5482f04192ef219f8e1956890de18f596328257179a55ec9b0055b1a
name: python-types-filelock
arch: src
version: 3.2.7
epoch: 0
release: 1
summary: Typing stubs for filelock
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b12a2878-eff7-4964-b4f6-13c26331616f
location_href: 00011900-python-types-filelock/python-types-filelock-3.2.7-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `filelock` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `filelock`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/filelock. All fixes for
  types and metadata should be contributed there.

  *Note:* The `filelock` package includes type annotations or type stubs
  since version 3.3.0. Please uninstall the `types-filelock`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `81fd55a885e678559471710f249c7e27d02ec212`.


pkgId: 0f2f2b600d8bf1590d0772082a5d70b0bb88889e329b2ac4f0b22969559b77d2
name: python-types-freezegun
arch: src
version: 1.1.10
epoch: 0
release: 1
summary: Typing stubs for freezegun
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-28e68992-36c5-4af2-8464-a34121add92f
location_href: 00011169-python-types-freezegun/python-types-freezegun-1.1.10-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `freezegun` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `freezegun`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/freezegun. All fixes for
  types and metadata should be contributed there.

  *Note:* The `freezegun` package includes type annotations or type stubs
  since version 1.2.1. Please uninstall the `types-freezegun`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `81fd55a885e678559471710f249c7e27d02ec212`.


pkgId: f8c47c07431883aa1e896f3dd821847ca039ffbd0e680b7245497ffd1945e77a
name: python-types-frozendict
arch: src
version: 2.0.9
epoch: 0
release: 1
summary: Typing stubs for frozendict
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ad04d957-ecc1-429c-99f3-ea561d75d427
location_href: 00011594-python-types-frozendict/python-types-frozendict-2.0.9-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `frozendict` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `frozendict`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/frozendict. All fixes for
  types and metadata should be contributed there.

  *Note:* The `frozendict` package includes type annotations or type stubs
  since version 2.2.0. Please uninstall the `types-frozendict`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `81fd55a885e678559471710f249c7e27d02ec212`.


pkgId: 67832a7f95daa3bc249c3065b6126e5f37c4ec86e1c0632a18df7c0d77a1f9d4
name: python-types-futures
arch: src
version: 3.3.8
epoch: 0
release: 1
summary: Typing stubs for futures
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dca5c9fe-abbd-42ea-b48b-c11055714307
location_href: 00009743-python-types-futures/python-types-futures-3.3.8-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `futures` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `futures`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/futures. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `0e185f40877a614c5ddd87815707cf8153296872`.


pkgId: 9d6e317bb88430fccfc9875bd6d7bafe1e22f9c2b9578d3076301d18b4045376
name: python-types-ipaddress
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Typing stubs for ipaddress
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6cb5ae8a-0fec-46f0-948e-5054a3c0774a
location_href: 00010332-python-types-ipaddress/python-types-ipaddress-1.0.8-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `ipaddress` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `ipaddress`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/ipaddress. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `45a2dad83cc372cd066a91fc04ab44297b714e69`.


pkgId: 51b6ca36f8d8f1e99707d5eb8e60f04aab6db610af9ff86b76e939865526163b
name: python-types-maxminddb
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Typing stubs for maxminddb
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-305ff1ac-aae3-4d7f-b288-76a2b58e0054
location_href: 00013857-python-types-maxminddb/python-types-maxminddb-1.5.0-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `maxminddb` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `maxminddb`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/maxminddb. All fixes for
  types and metadata should be contributed there.

  *Note:* The `maxminddb` package includes type annotations or type stubs
  since version 2.0.2. Please uninstall the `types-maxminddb`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `8ea6d6f33176d23bf29fb4213bd0c48e4013a721`.


pkgId: ca814fe9db135c21d0bb5f5f872b54b365b969ede05995efd83cfd25ec81da1e
name: python-types-mock
arch: src
version: 5.0.0.6
epoch: 0
release: 1
summary: Typing stubs for mock
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1364980-39cf-46f5-84c3-3720cb9682a4
location_href: 00010264-python-types-mock/python-types-mock-5.0.0.6-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `mock` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `mock`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/mock. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: 2e59385297172bb31a50ff57f66a346d52fcf9b096ec628759b6e626bf474a2c
name: python-types-orjson
arch: src
version: 3.6.2
epoch: 0
release: 1
summary: Typing stubs for orjson
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eae8bb1e-25a3-4693-a0df-65b8a1def5c0
location_href: 00010487-python-types-orjson/python-types-orjson-3.6.2-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `orjson` package.
  It can be used by type-checking tools like mypy, PyCharm, pytype etc. to check code
  that uses `orjson`. The source for this package can be found at
  https://github.com/python/typeshed/tree/master/stubs/orjson. All fixes for
  types and metadata should be contributed there.

  *Note:* The `orjson` package includes type annotations or type stubs
  since version 3.6.1. Please uninstall the `types-orjson`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/master/README.md for more details.
  This package was generated from typeshed commit `032e6ee90cbb938259a2aa2183966502de19108e`.


pkgId: ba893e28c02ba9a784bbd5c32118ce079a4a70f025f2061179e0d7ad496a87e3
name: python-types-paramiko
arch: src
version: 3.0.0.7
epoch: 0
release: 1
summary: Typing stubs for paramiko
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5e9bc157-2892-4773-a2a3-c2fc944ff7b8
location_href: 00010954-python-types-paramiko/python-types-paramiko-3.0.0.7-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `paramiko` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `paramiko`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/paramiko. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `60939b00afede13feeec3cee6f6dfe6eb2df1593`.


pkgId: 11aa31955eb24b975d5e6a3189d4a65af7c2f81fd29789f056de90d9e7759262
name: python-types-protobuf
arch: src
version: 4.22.0.2
epoch: 0
release: 1
summary: Typing stubs for protobuf
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f50acaa2-4a08-478b-b737-38907d03ea5e
location_href: 00009740-python-types-protobuf/python-types-protobuf-4.22.0.2-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `protobuf` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `protobuf`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/protobuf. All fixes for
  types and metadata should be contributed there.

  Generated with aid from mypy-protobuf v3.4.0

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `60939b00afede13feeec3cee6f6dfe6eb2df1593`.


pkgId: 01499e7814ea8319a9753300d7b20896c888bd74f7ea282a25f304d733b05b7a
name: python-types-pyOpenSSL
arch: src
version: 23.1.0.1
epoch: 0
release: 1
summary: Typing stubs for pyOpenSSL
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-84c5fc4f-427c-408c-9725-ee31f8bae4c4
location_href: 00013871-python-types-pyopenssl/python-types-pyOpenSSL-23.1.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `pyOpenSSL` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `pyOpenSSL`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/pyOpenSSL. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6fd7e36e80e0448d9199d62d582c659c147be149`.


pkgId: 03af8e88dcc5389c0d4142a14e8e77d6c1cf336b7930e9a35a91a5610815f3db
name: python-types-python-dateutil
arch: src
version: 2.8.19.12
epoch: 0
release: 1
summary: Typing stubs for python-dateutil
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02fcbed1-ceb5-41f9-b554-13df209ce3a5
location_href: 00009616-python-types-python-dateutil/python-types-python-dateutil-2.8.19.12-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `python-dateutil` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `python-dateutil`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/python-dateutil. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `60939b00afede13feeec3cee6f6dfe6eb2df1593`.


pkgId: 96e9a4db125a9bec88279e1c78f3860f351c9a117b11343cb6027fbe247714e0
name: python-types-pytz
arch: src
version: 2023.3.0.0
epoch: 0
release: 1
summary: Typing stubs for pytz
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b19a323f-bfe1-43d3-b82b-af07fae7803d
location_href: 00009611-python-types-pytz/python-types-pytz-2023.3.0.0-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `pytz` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `pytz`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/pytz. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6f3e568cecbde108354cad3230efd7f0b8e07b3a`.


pkgId: 2311e2efd5ba1ab7e70b66a4df0923cb8b74d09a4eec8ee0845e319073f8e850
name: python-types-redis
arch: src
version: 4.5.4.1
epoch: 0
release: 1
summary: Typing stubs for redis
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a8bee4d-7829-45d6-ab12-55e43f34cccc
location_href: 00010034-python-types-redis/python-types-redis-4.5.4.1-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `redis` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `redis`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/redis. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `ff3b558fb3c74d49c957a2a400d32d7319ba9dca`.


pkgId: 452dd428ce3fd6e52ea4afd4cb89a6ecab0b77fac3549b16f611d08ad5e4296a
name: python-types-requests
arch: src
version: 2.28.11.17
epoch: 0
release: 1
summary: Typing stubs for requests
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-be965be6-ab6d-4906-9eb5-d75c611cf824
location_href: 00009409-python-types-requests/python-types-requests-2.28.11.17-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `requests` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `requests`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/requests. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6b485a882325829dcbb6dd1d59c5e54b0bcfece1`.


pkgId: 8b81fe5a1e83edd456a117c494af8b25afd742dee75b487e9f67e4d6147959f4
name: python-types-setuptools
arch: src
version: 67.6.0.7
epoch: 0
release: 1
summary: Typing stubs for setuptools
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3fc7d28e-0058-4e04-b5a9-3217c5d19712
location_href: 00009799-python-types-setuptools/python-types-setuptools-67.6.0.7-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `setuptools` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `setuptools`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/setuptools. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `60939b00afede13feeec3cee6f6dfe6eb2df1593`.


pkgId: b562a87394fd14b330b0b253fc4b190da877e69a72662da4a8a6f89bbbc66619
name: python-types-simplejson
arch: src
version: 3.18.0.3
epoch: 0
release: 1
summary: Typing stubs for simplejson
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cdaf6fd8-c5c1-4f54-a905-51bdec188723
location_href: 00010302-python-types-simplejson/python-types-simplejson-3.18.0.3-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `simplejson` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `simplejson`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/simplejson. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `ed915c5cde48329e3d1e597e60c4baee27b7854a`.


pkgId: 8137d840511c047ada69d208c3ba67a1b802dc86cf73f1c639d23af63f61692d
name: python-types-six
arch: src
version: 1.16.21.8
epoch: 0
release: 1
summary: Typing stubs for six
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e94269de-96b2-4a72-9269-49e0c16b3d7a
location_href: 00009855-python-types-six/python-types-six-1.16.21.8-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `six` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `six`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/six. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6b485a882325829dcbb6dd1d59c5e54b0bcfece1`.


pkgId: c01ce44ead0a6137cf842ccf469ed0caa27b545ebcb7a5f525952211176c925c
name: python-types-tabulate
arch: src
version: 0.9.0.2
epoch: 0
release: 1
summary: Typing stubs for tabulate
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ac97c671-c761-450b-bd73-a30bb1d99062
location_href: 00010225-python-types-tabulate/python-types-tabulate-0.9.0.2-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `tabulate` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `tabulate`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/tabulate. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6b485a882325829dcbb6dd1d59c5e54b0bcfece1`.


pkgId: b95e51f91e8854aa653e4edfd1826f57df34185e3d0f5f871d563fcec1b53c56
name: python-types-termcolor
arch: src
version: 1.1.6.2
epoch: 0
release: 1
summary: Typing stubs for termcolor
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1506a859-1189-44f0-8450-63f229e7cb78
location_href: 00010604-python-types-termcolor/python-types-termcolor-1.1.6.2-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `termcolor` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `termcolor`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/termcolor. All fixes for
  types and metadata should be contributed there.

  *Note:* The `termcolor` package includes type annotations or type stubs
  since version 2.0.0. Please uninstall the `types-termcolor`
  package if you use this or a newer version.


  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `72456da2a3546044508828dc9075fa25cbdb3645`.


pkgId: 8d31c4d221154823bdbdf645ff17a4e965fbd6695c35cd1999fe808bb3f68b45
name: python-types-toml
arch: src
version: 0.10.8.6
epoch: 0
release: 1
summary: Typing stubs for toml
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e08d50f-19a9-463e-9dcf-c55f11e86ac1
location_href: 00010483-python-types-toml/python-types-toml-0.10.8.6-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `toml` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `toml`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/toml. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `6b485a882325829dcbb6dd1d59c5e54b0bcfece1`.


pkgId: 8a41a557ae0d6e706a0d5837aaa9f7fc31363fe42646bbe91c52bfac7ce75aa8
name: python-types-ujson
arch: src
version: 5.7.0.1
epoch: 0
release: 1
summary: Typing stubs for ujson
url: https://github.com/python/typeshed
rpm_license: Apache-2.0 license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b721c01-79da-424c-bf21-3d54e59d4ed5
location_href: 00010421-python-types-ujson/python-types-ujson-5.7.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a PEP 561 type stub package for the `ujson` package. It
  can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  PyCharm, etc. to check code that uses
  `ujson`. The source for this package can be found at
  https://github.com/python/typeshed/tree/main/stubs/ujson. All fixes for
  types and metadata should be contributed there.

  See https://github.com/python/typeshed/blob/main/README.md for more details.
  This package was generated from typeshed commit `880c0da4045cd5ff2c29b73429629adf27e49d50`.


pkgId: 52eabd3a8298a45eb10b86ca83b1eac073f04514d7370229e1f07080856d95f3
name: python-typing
arch: src
version: 3.10.0.0
epoch: 0
release: 1
summary: Type Hints for Python
url: https://docs.python.org/3/library/typing.html
rpm_license: PSF
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-30107f94-6f1e-4459-8f54-d2c877042099
location_href: 00009116-python-typing/python-typing-3.10.0.0-1.src.rpm
checksum_type: sha256
description:
  Typing -- Type Hints for Python

  This is a backport of the standard library typing module to Python
  versions older than 3.5.  (See note below for newer versions.)

  Typing defines a standard notation for Python function and variable
  type annotations. The notation can be used for documenting code in a
  concise, standard format, and it has been designed to also be used by
  static and runtime type checkers, static analyzers, IDEs and other
  tools.

  NOTE: in Python 3.5 and later, the typing module lives in the stdlib,
  and installing this package has NO EFFECT, because stdlib takes higher
  precedence than the installation directory. To get a newer version of
  the typing module in Python 3.5 or later, you have to upgrade to a
  newer Python (bugfix) version.  For example, typing in Python 3.6.0 is
  missing the definition of 'Type' -- upgrading to 3.6.2 will fix this.

  Also note that most improvements to the typing module in Python 3.7
  will not be included in this package, since Python 3.7 has some
  built-in support that is not present in older versions (See PEP 560.)

  For package maintainers, it is preferred to use
  ``typing;python_version<"3.5"`` if your package requires it to support
  earlier Python versions. This will avoid shadowing the stdlib typing
  module when your package is installed via ``pip install -t .`` on
  Python 3.5 or later.


pkgId: 8e95cb079da99a1620b70ab18b5951deb0e6073a22688e8368440f38cb31d5c3
name: python-typing-compat
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Python typing compatibility library
url: https://github.com/rossmacarthur/typing-compat
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b53d5883-af47-4183-b555-1d8f170141b3
location_href: 00010406-python-typing-compat/python-typing-compat-0.1.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">typing-compat</h1>
  <div align="center">
    <strong>Python typing compatibility library</a></strong>
  </div>
  <br />
  <div align="center">
    <a href="https://github.com/rossmacarthur/typing-compat/actions?query=workflow%3Abuild">
      <img src="https://github.com/rossmacarthur/typing-compat/workflows/build/badge.svg?branch=master" alt="Build status" />
    </a>
    <a href="https://github.com/psf/black">
      <img src="https://img.shields.io/badge/code%20style-black-101010.svg" alt="Code style: black" />
    </a>
  </div>
  <br />

  In Python >=3.8 the `typing.get_origin` and `typing.get_args` functions are
  provided. This library aims to bring the identical behaviour of these functions
  to other versions of Python.



  ```bash
  pip install typing-compat
  ```



  ```python
  >>> from typing import List, Tuple, TypeVar
  >>> from typing_compat import get_args, get_origin
  >>> T = TypeVar('T')

  >>> tp = List[Tuple[T, T]][int]

  >>> get_args(tp)
  (typing.Tuple[int, int],)

  >>> get_origin(tp)
  <class 'list'>

  ```



  This library is licensed under either of

  - Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
    https://www.apache.org/licenses/LICENSE-2.0)
  - MIT License ([LICENSE-MIT](LICENSE-MIT) or
    https://opensource.org/licenses/MIT)

  at your option.


pkgId: 1288eda89bc4f44224271d81a5276d03ad42f1d93e74edcc02c236b2dd4720b7
name: python-typing-inspect
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Runtime inspection utilities for typing module.
url: https://github.com/ilevkivskyi/typing_inspect
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1bfc6c36-a76f-42c1-8a4c-5f4217c61a57
location_href: 00005361-python-typing-inspect/python-typing-inspect-0.8.0-1.src.rpm
checksum_type: sha256
description:
  The "typing_inspect" module defines experimental API for runtime
  inspection of types defined in the standard "typing" module.


pkgId: 38de348b1d4abfe417b9ef12816531b093ec9df8413850ca3ca9c81dfd779e57
name: python-tzwhere
arch: src
version: 3.0.3
epoch: 0
release: 1
summary: Python library to look up timezone from lat / long offline
url: https://github.com/pegler/pytzwhere
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd95f434-e431-40ed-a82e-97f466fd8318
location_href: 00010040-python-tzwhere/python-tzwhere-3.0.3-1.src.rpm
checksum_type: sha256
description:
  pytzwhere is a Python library to lookup the timezone for a given lat/lng entirely offline.
  Version 3.0 fixes how `pytzwhere` deals with [holes](https://github.com/pegler/pytzwhere/issues/34) in timezones. It is recommended that you use version 3.0.
  It is a port from https://github.com/mattbornski/tzwhere with a few improvements. The underlying timezone data is based on work done by [Eric Muller](http://efele.net/maps/tz/world/)
  If used as a library, basic usage is as follows:
      >>> from tzwhere import tzwhere
      >>> tz = tzwhere.tzwhere()
      >>> print tz.tzNameAt(35.29, -89.66)
      America/Chicago
  The polygons used for building the timezones are based on VMAP0. Sometimes points are outside a VMAP0 polygon, but are clearly within a certain timezone (see also this [discussion](https://github.com/mattbornski/tzwhere/issues/8)). As a solution you can search for the closest timezone within a user defined radius.
  Dependencies:
    * `numpy` (optional)
    * `shapely`


pkgId: 088bfdf23d4d6562a68ee6db135c394b57a0c174d3cced1f80c0adab68b1368e
name: python-ufoLib2
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: ufoLib2 is a UFO font processing library.
url: https://github.com/fonttools/ufoLib2
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e4256c19-ecc7-4bfc-ba2b-b0b5c1295b33
location_href: 00005366-python-ufoLib2/python-ufoLib2-0.14.0-1.src.rpm
checksum_type: sha256
description:
  ufoLib2 is meant to be a thin representation of the Unified Font Object (UFO) version 3 data model, intended for programmatic manipulation and fast batch processing of UFOs.

  It resembles the defcon library, but does without notifications, the layout engine and other support classes. Where useful and possible, ufoLib2 tries to be API-compatible with defcon.

  It does not replace `fontTools.ufoLib` but builds on it. The eventual goal is to merge it into `fontTools.ufoLib.objects`.

  Documentation: https://ufolib2.readthedocs.io/en/latest/


pkgId: cfe4189c476d54fcb5d056a3a21b357a73317a79868a865a6ab54e79126beebc
name: python-ujson
arch: src
version: 5.7.0
epoch: 0
release: 1
summary: Ultra fast JSON encoder and decoder for Python
url: https://github.com/ultrajson/ultrajson
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e0ec21e-efdb-45b3-82be-e4344673e243
location_href: 00005368-python-ujson/python-ujson-5.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/ujson.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/ujson)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/ujson.svg?logo=python&logoColor=FFE873)](https://pypi.org/project/ujson)
  [![PyPI downloads](https://img.shields.io/pypi/dm/ujson.svg)](https://pypistats.org/packages/ujson)
  [![GitHub Actions status](https://github.com/ultrajson/ultrajson/workflows/Test/badge.svg)](https://github.com/ultrajson/ultrajson/actions)
  [![codecov](https://codecov.io/gh/ultrajson/ultrajson/branch/main/graph/badge.svg)](https://codecov.io/gh/ultrajson/ultrajson)
  [![DOI](https://zenodo.org/badge/1418941.svg)](https://zenodo.org/badge/latestdoi/1418941)
  [![Code style: Black](https://img.shields.io/badge/code%20style-Black-000000.svg)](https://github.com/psf/black)

  UltraJSON is an ultra fast JSON encoder and decoder written in pure C with bindings for
  Python 3.7+.

  Install with pip:

  ```sh
  python -m pip install ujson
  ```



  May be used as a drop in replacement for most other JSON parsers for Python:

  ```pycon
  >>> import ujson
  >>> ujson.dumps([{"key": "value"}, 81, True])
  '[{"key":"value"},81,true]'
  >>> ujson.loads("""[{"key": "value"}, 81, true]""")
  [{'key': 'value'}, 81, True]
  ```





  Used to enable special encoding of "unsafe" HTML characters into safer Unicode
  sequences. Default is `False`:

  ```pycon
  >>> ujson.dumps("<script>John&Doe", encode_html_chars=True)
  '"\\u003cscript\\u003eJohn\\u0026Doe"'
  ```



  Limits output to ASCII and escapes all extended characters above 127. Default is `True`.
  If your end format supports UTF-8, setting this option to false is highly recommended to
  save space:

  ```pycon
  >>> ujson.dumps("åäö")
  '"\\u00e5\\u00e4\\u00f6"'
  >>> ujson.dumps("åäö", ensure_ascii=False)
  '"åäö"'
  ```



  Controls whether forward slashes (`/`) are escaped. Default is `True`:

  ```pycon
  >>> ujson.dumps("http://esn.me")
  '"http:\\/\\/esn.me"'
  >>> ujson.dumps("http://esn.me", escape_forward_slashes=False)
  '"http://esn.me"'
  ```



  Controls whether indentation ("pretty output") is enabled. Default is `0` (disabled):

  ```pycon
  >>> ujson.dumps({"foo": "bar"})
  '{"foo":"bar"}'
  >>> print(ujson.dumps({"foo": "bar"}, indent=4))
  {
      "foo":"bar"
  }
  ```



  *UltraJSON* calls/sec compared to other popular JSON parsers with performance gain
  specified below each.



  Linux 5.0.0-1032-azure x86_64 #34-Ubuntu SMP Mon Feb 10 19:37:25 UTC 2020



  - CPython 3.8.2 (default, Feb 28 2020, 14:28:43) [GCC 7.4.0]
  - nujson    : 1.35.2
  - orjson    : 2.6.1
  - simplejson: 3.17.0
  - ujson     : 2.0.2

  |                                                                               | ujson      | nujson     | orjson     | simplejson | json       |
  |-------------------------------------------------------------------------------|-----------:|-----------:|-----------:|-----------:|-----------:|
  | Array with 256 doubles                                                        |            |            |            |            |            |
  | encode                                                                        |     22,082 |      4,282 |     76,975 |      5,328 |      5,436 |
  | decode                                                                        |     24,127 |     34,349 |     29,059 |     14,174 |     13,822 |
  | Array with 256 UTF-8 strings                                                  |            |            |            |            |            |
  | encode                                                                        |      3,557 |      2,528 |     24,300 |      3,061 |      2,068 |
  | decode                                                                        |      2,030 |      2,490 |        931 |        406 |        358 |
  | Array with 256 strings                                                        |            |            |            |            |            |
  | encode                                                                        |     39,041 |     31,769 |     76,403 |     16,615 |     16,910 |
  | decode                                                                        |     25,185 |     24,287 |     34,437 |     32,388 |     27,999 |
  | Medium complex object                                                         |            |            |            |            |            |
  | encode                                                                        |     10,382 |     11,427 |     32,995 |      3,959 |      5,275 |
  | decode                                                                        |      9,785 |      9,796 |     11,515 |      5,898 |      7,200 |
  | Array with 256 True values                                                    |            |            |            |            |            |
  | encode                                                                        |    114,341 |    101,039 |    344,256 |     62,382 |     72,872 |
  | decode                                                                        |    149,367 |    151,615 |    181,123 |    114,597 |    130,392 |
  | Array with 256 dict{string, int} pairs                                        |            |            |            |            |            |
  | encode                                                                        |     13,715 |     14,420 |     51,942 |      3,271 |      6,584 |
  | decode                                                                        |     12,670 |     11,788 |     12,176 |      6,743 |      8,278 |
  | Dict with 256 arrays with 256 dict{string, int} pairs                         |            |            |            |            |            |
  | encode                                                                        |         50 |         54 |        216 |         10 |         23 |
  | decode                                                                        |         32 |         32 |         30 |         20 |         23 |
  | Dict with 256 arrays with 256 dict{string, int} pairs, outputting sorted keys |            |            |            |            |            |
  | encode                                                                        |         46 |         41 |            |          8 |         24 |
  | Complex object                                                                |            |            |            |            |            |
  | encode                                                                        |        533 |        582 |            |        408 |        431 |
  | decode                                                                        |        466 |        454 |            |        154 |        164 |



  For those with particular needs, such as Linux distribution packagers, several
  build options are provided in the form of environment variables.





  By default, debugging symbols are stripped on Linux platforms. Setting this
  environment variable with a value of `1` or `True` disables this behavior.



  These two environment variables are typically used together, something like:

  ```sh
  export UJSON_BUILD_DC_INCLUDES='/usr/include/double-conversion'
  export UJSON_BUILD_DC_LIBS='-ldouble-conversion'
  ```

  Users planning to link against an external shared library should be aware of
  the ABI-compatibility requirements this introduces when upgrading system
  libraries or copying compiled wheels to other machines.



  One or more directories, delimited by `os.pathsep` (same as the `PATH`
  environment variable), in which to look for `double-conversion` header files;
  the default is to use the bundled copy.



  Compiler flags needed to link the `double-conversion` library; the default
  is to use the bundled copy.


pkgId: 1666af7ff3534c98b267494d4c1a9ddb97cf53ca8852c10e3e37ffb7cb3a2c06
name: python-ujson-debuginfo
arch: x86_64
version: 5.7.0
epoch: 0
release: 1
summary: Debug information for package python-ujson
url: https://github.com/ultrajson/ultrajson
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-8e0ec21e-efdb-45b3-82be-e4344673e243
rpm_sourcerpm: python-ujson-5.7.0-1.src.rpm
location_href: 00005368-python-ujson/python-ujson-debuginfo-5.7.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-ujson.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: a531bf791bb1f53c771bdb440ff95431a9d6444ecd588913543ffa0a508bb0b9
name: python-ujson-debugsource
arch: x86_64
version: 5.7.0
epoch: 0
release: 1
summary: Debug sources for package python-ujson
url: https://github.com/ultrajson/ultrajson
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-8e0ec21e-efdb-45b3-82be-e4344673e243
rpm_sourcerpm: python-ujson-5.7.0-1.src.rpm
location_href: 00005368-python-ujson/python-ujson-debugsource-5.7.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-ujson.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 29c8d33669608cdee69f9f357a4d28c77db94a897f37820f3d15ebb672a016c5
name: python-ulid-py
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Universally Unique Lexicographically Sortable Identifier
url: https://github.com/ahawker/ulid
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49095f9b-2896-4191-9922-152c60212ae1
location_href: 00011167-python-ulid-py/python-ulid-py-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/ahawker/ulid.svg?branch=master)](https://travis-ci.org/ahawker/ulid)
  [![Build Status](https://ci.appveyor.com/api/projects/status/fy0hufnb8h6gwk4d/branch/master?svg=true)](https://ci.appveyor.com/project/ahawker/ulid/branch/master)
  [![codecov](https://codecov.io/gh/ahawker/ulid/branch/master/graph/badge.svg)](https://codecov.io/gh/ahawker/ulid)
  [![Code Climate](https://codeclimate.com/github/ahawker/ulid/badges/gpa.svg)](https://codeclimate.com/github/ahawker/ulid)
  [![Issue Count](https://codeclimate.com/github/ahawker/ulid/badges/issue_count.svg)](https://codeclimate.com/github/ahawker/ulid)

  [![PyPI Version](https://badge.fury.io/py/ulid-py.svg)](https://badge.fury.io/py/ulid-py)
  [![PyPI Versions](https://img.shields.io/pypi/pyversions/ulid-py.svg)](https://pypi.python.org/pypi/ulid-py)

  [![Updates](https://pyup.io/repos/github/ahawker/ulid/shield.svg)](https://pyup.io/repos/github/ahawker/ulid/)

  [![Documentation Status](https://readthedocs.org/projects/ulid/badge/?version=latest)](http://ulid.readthedocs.io/en/latest/?badge=latest)

  [Universally Unique Lexicographically Sortable Identifier](https://github.com/alizain/ulid) in [Python 3](https://www.python.org/).



  This project is actively maintained.



  To install ulid from [pip](https://pypi.python.org/pypi/pip):
  ```bash
      $ pip install ulid-py
  ```

  To install ulid from source:
  ```bash
      $ git clone git@github.com:ahawker/ulid.git
      $ cd ulid && python setup.py install
  ```



  Create a brand new ULID.

  The timestamp value (48-bits) is from [time.time()](https://docs.python.org/3/library/time.html?highlight=time.time#time.time) with millisecond precision.

  The randomness value (80-bits) is from [os.urandom()](https://docs.python.org/3/library/os.html?highlight=os.urandom#os.urandom).

  ```python
  >>> import ulid
  >>> ulid.new()
  <ULID('01BJQE4QTHMFP0S5J153XCFSP9')>
  ```

  Create a new ULID from an existing 128-bit value, such as a [UUID](https://docs.python.org/3/library/uuid.html).

  Supports ULID values as `int`, `bytes`, `str`, and `UUID` types.

  ```python
  >>> import ulid, uuid
  >>> value = uuid.uuid4()
  >>> value
  UUID('0983d0a2-ff15-4d83-8f37-7dd945b5aa39')
  >>> ulid.from_uuid(value)
  <ULID('09GF8A5ZRN9P1RYDVXV52VBAHS')>
  ```

  Create a new ULID from an existing timestamp value, such as a [datetime](https://docs.python.org/3/library/datetime.html#module-datetime) object.

  Supports timestamp values as `int`, `float`, `str`, `bytes`, `bytearray`, `memoryview`, `datetime`, `Timestamp`, and `ULID` types.

  ```python
  >>> import datetime, ulid
  >>> ulid.from_timestamp(datetime.datetime(1999, 1, 1))
  <ULID('00TM9HX0008S220A3PWSFVNFEH')>
  ```

  Create a new ULID from an existing randomness value.

  Supports randomness values as `int`, `float`, `str`, `bytes`, `bytearray`, `memoryview`, `Randomness`, and `ULID` types.

  ```python
  >>> import os, ulid
  >>> randomness = os.urandom(10)
  >>> ulid.from_randomness(randomness)
  >>> <ULID('01BJQHX2XEDK0VN0GMYWT9JN8S')>
  ```

  For cases when you don't necessarily control the data type (input from external system), you can use the `parse` method
  which will attempt to make the correct determination for you. Please note that this will be slightly slower than creating
  the instance from the respective `from_*` method as it needs to make a number of type/conditional checks.

  Supports values as `int`, `float`, `str`, `bytes`, `bytearray`, `memoryview`, `uuid.UUID`, and `ULID` types.

  ```python
  >>> import ulid
  >>> value = db.model.get_id()  ## Unsure about datatype -- Could be int, UUID, or string?
  >>> ulid.parse(value)
  >>> <ULID('0K0EDFETFM8SH912DBBD4ABXSZ')>
  ```

  Once you have a ULID object, there are a number of ways to interact with it.

  The `timestamp` method will give you a snapshot view of the first 48-bits of the ULID while the `randomness` method
  will give you a snapshot of the last 80-bits.

  ```python
  >>> import ulid
  >>> u = ulid.new()
  >>> u
  <ULID('01BJQM7SC7D5VVTG3J68ABFQ3N')>
  >>> u.timestamp()
  <Timestamp('01BJQM7SC7')>
  >>> u.randomness()
  <Randomness('D5VVTG3J68ABFQ3N')>
  ```

  The `ULID`, `Timestamp`, and `Randomness` classes all derive from the same base class, a `MemoryView`.

  A `MemoryView` provides the `bin`, `bytes`, `hex`, `int`, `oct`, and `str`, methods for changing any values representation.

  ```python
  >>> import ulid
  >>> u = ulid.new()
  >>> u
  <ULID('01BJQMF54D093DXEAWZ6JYRPAQ')>
  >>> u.timestamp()
  <Timestamp('01BJQMF54D')>
  >>> u.timestamp().int
  1497589322893
  >>> u.timestamp().bytes
  b'\x01\\\xafG\x94\x8d'
  >>> u.timestamp().datetime
  datetime.datetime(2017, 6, 16, 5, 2, 2, 893000)
  >>> u.randomness().bytes
  b'\x02F\xde\xb9\\\xf9\xa5\xecYW'
  >>> u.bytes[6:] == u.randomness().bytes
  True
  >>> u.str
  '01BJQMF54D093DXEAWZ6JYRPAQ'
  >>> u.int
  1810474399624548315999517391436142935
  >>> u.bin
  '0b1010111001010111101000111100101001000110100000010010001101101111010111001010111001111100110100101111011000101100101010111'
  >>> u.hex
  '0x15caf47948d0246deb95cf9a5ec5957'
  >>> u.oct
  '0o12712750745106402215572712717464573054527'
  ```

  A `MemoryView` also provides rich comparison functionality.

  ```python
  >>> import datetime, time, ulid
  >>> u1 = ulid.new()
  >>> time.sleep(5)
  >>> u2 = ulid.new()
  >>> u1 < u2
  True
  >>> u3 = ulid.from_timestamp(datetime.datetime(2039, 1, 1))
  >>> u1 < u2 < u3
  True
  >>> [u.timestamp().datetime for u in sorted([u2, u3, u1])]
  [datetime.datetime(2017, 6, 16, 5, 7, 14, 847000), datetime.datetime(2017, 6, 16, 5, 7, 26, 775000), datetime.datetime(2039, 1, 1, 8, 0)]
  ```



  * Collection of benchmarks to track performance.
  * Backport to Python 2.7?
  * See [Github Issues](https://github.com/ahawker/ulid/issues) for more!



  A fast implementation in pure python of the spec with binary format support.



  If you would like to contribute, simply fork the repository, push your changes and send a pull request.
  Pull requests will be brought into the `master` branch via a rebase and fast-forward merge with the goal of having a linear branch history with no merge commits.



  [Apache 2.0](LICENSE)



  UUID can be suboptimal for many uses-cases because:

  * It isn't the most character efficient way of encoding 128 bits of randomness
  * UUID v1/v2 is impractical in many environments, as it requires access to a unique, stable MAC address
  * UUID v3/v5 requires a unique seed and produces randomly distributed IDs, which can cause fragmentation in many data structures
  * UUID v4 provides no other information than randomness which can cause fragmentation in many data structures

  ULID provides:

  * 128-bit compatibility with UUID
  * 1.21e+24 unique ULIDs per millisecond
  * Lexicographically sortable!
  * Canonically encoded as a 26 character string, as opposed to the 36 character UUID
  * Uses Crockford's base32 for better efficiency and readability (5 bits per character)
  * Case insensitive
  * No special characters (URL safe)



  Below is the current specification of ULID as implemented in this repository.

  The binary format is implemented.

  ```
   01AN4Z07BY      79KA1307SR9X4MV3

  |----------|    |----------------|
   Timestamp          Randomness
    10chars            16chars
     48bits             80bits
  ```



  **Timestamp**
  * 48 bit integer
  * UNIX-time in milliseconds
  * Won't run out of space till the year 10895 AD.

  **Randomness**
  * 80 bits
  * Cryptographically secure source of randomness, if possible



  The left-most character must be sorted first, and the right-most character sorted last (lexical order).
  The default ASCII character set must be used. Within the same millisecond, sort order is not guaranteed



  Crockford's Base32 is used as shown. This alphabet excludes the letters I, L, O, and U to avoid confusion and abuse.

  ```
  0123456789ABCDEFGHJKMNPQRSTVWXYZ
  ```



  The components are encoded as 16 octets. Each component is encoded with the Most Significant Byte first (network byte order).

  ```
  0                   1                   2                   3
   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  |                      32_bit_uint_time_high                    |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  |     16_bit_uint_time_low      |       16_bit_uint_random      |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  |                       32_bit_uint_random                      |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  |                       32_bit_uint_random                      |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  ```



  ```
  ttttttttttrrrrrrrrrrrrrrrr

  where
  t is Timestamp
  r is Randomness
  ```



  * [Original Implementation (Javascript)](https://github.com/alizain/ulid)
  * [ulid (python)](https://github.com/mdipierro/ulid)


pkgId: 8af872eabd20063a74e44ef6b51b3f1af5701f3b8b14018140d214ec3a2e2f2a
name: python-uncertainties
arch: src
version: 3.1.7
epoch: 0
release: 1
url: http://uncertainties-python-package.readthedocs.io/
rpm_license: Revised BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-41837c45-1f6c-48ca-914d-20b70efdd009
location_href: 00011056-python-uncertainties/python-uncertainties-3.1.7-1.src.rpm
checksum_type: sha256
summary:
  Transparent calculations with uncertainties on the quantities involved (aka error propagation); fast calculation of derivatives

description:
  ``uncertainties`` allows **calculations** such as (2 +/- 0.1)*2 = 4 +/-
  0.2 to be **performed transparently**.  Much more complex mathematical
  expressions involving numbers with uncertainties can also be evaluated
  directly.
  The ``uncertainties`` package **takes the pain and complexity out**
  of uncertainty calculations.
  **Detailed information** about this package can be found on its `main
  website`_.


pkgId: 80452acd64273b509311eae1f1f7018cc53453c3bca3795b0bc5ab4c42cd8ccb
name: python-uncompyle6
arch: src
version: 3.9.0
epoch: 0
release: 1
summary: Python cross-version byte-code decompiler
url: https://github.com/rocky/python-uncompyle6/
rpm_license: GPL3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6cf865c7-5c0a-48e5-a5dc-4d74c98d027a
location_href: 00012123-python-uncompyle6/python-uncompyle6-3.9.0-1.src.rpm
checksum_type: sha256
description:
  A native Python cross-version decompiler and fragment decompiler.
  The successor to decompyle, uncompyle, and uncompyle2.


pkgId: 44671c94c6a8d54bad67cc82aba8963c9f7fa67c8308c8bd0eef71613bee5afd
name: python-undetected-chromedriver
arch: src
version: 3.4.6
epoch: 0
release: 1
url: https://github.com/ultrafunkamsterdam/undetected-chromedriver
rpm_license: GPL-3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-259307e1-af4d-472f-8b97-40734dfbbd8b
location_href: 00010643-python-undetected-chromedriver/python-undetected-chromedriver-3.4.6-1.src.rpm
checksum_type: sha256
summary:
  ('Selenium.webdriver.Chrome replacement with compatiblity for Brave, and other Chromium based browsers.', 'Not triggered by CloudFlare/Imperva/hCaptcha and such.', 'NOTE: results may vary due to many factors. No guarantees are given, except for ongoing efforts in understanding detection algorithms.')

description:
  https://github.com/ultrafunkamsterdam/undetected-chromedriver


  Optimized Selenium Chromedriver patch which does not trigger anti-bot services like Distill Network / Imperva / DataDome / Botprotect.io
  Automatically downloads the driver binary and patches it.

  * Tested until current chrome beta versions
  * Works also on Brave Browser and many other Chromium based browsers, some tweaking
  * Python 3.6++**

  - - -

  I will be putting limits on the issue tracker. It has beeen abused too long.
  any good news?
  Yes, i've opened [Undetected-Discussions](https://github.com/ultrafunkamsterdam/undetected-chromedriver/discussions) which i think will help us better in the long run.
  - - -


  - What a week. Had the recent advancedments in Automation-Detection algorithms pwned (so i thought) with 3.4.0, but apparently, for some OS-es this caused an error when    interacting with elements. Had to revert back using a different method, fix bugs, and now eventually was still able to stick to the initial idea (+ fixing bugs)
  - Update to chrome 110 caused another surprise, this time for HEADLESS users.
  - although headless is unsupported officially, i did patch it!
  - happy to announce IT IS NOW UNDETECTED AS WELL (but still unsupported ;))
  - special thanks here to [@mdmintz](https://github.com/mdmintz) and [@abdulzain6](https://github.com/abdulzain6)
  - also special thanks to [@sebdelsol](https://github.com/sebdelsol) for his help troughout the issues section completely voluntarily, you must be crazy :)


  **Big update! be careful as it -potentially- could break your code.**

  * rewritten the anti-detection mechanism instead of removing and renaming variables, we just keep them, but prevent them from being injected in the first place. This will keep us safe from detection at least for the near future.

  * rewritten the file naming, to prevent ending up with 1000 of {randomstring}_chromedriver.exe 's instead it is just called undetected_chromedriver.exe

  * cleanup removed compat,v2 files and tests folder






  * added an example containing some typical webdriver code, answers to commonly asked questions, pitfalls + showcasing some tricks to ditch
    the need for multithreading.



  * added WebElement.click_safe() method, which you can try in case you get detected after clicking a link. This is not guaranteed t o work.

  * added WebElement.children(self, tag=None, recursive=False)
    to easily get/find child nodes. example:
      ```
      body = driver.find_element('tag name', 'body')

      
      images = body.children()[6].children('img', True)
      srcs = list(map(lambda _:_.attrs.get('src'), images))
      ```

  * added example.py where i can point people at when asking silly questions
    (no, its actually quite cool, everyone should see it)
  * added support for lambda platform
  * added support for x86_32
  * added support for systems reporting as linux2
  * some refactoring





  - use_subprocess now defaults to True. too many people don't understand multiprocessing and __name__ == '__main__, and after testing, it
    seems not to make a difference anymore in chrome 104+

  - added no_sandbox, which defaults to True, and this without the annoying "you are using unsecure command line ..." bar.

  - update [Docker image](https://hub.docker.com/r/ultrafunk/undetected-chromedriver). you can now vnc or rdp into your container to see the
    actual browser window
    [![demo](https://i.imgur.com/51Ang6R.gif)](https://i.imgur.com/W7vriN9.mp4)

  - of course, "regular" mode works as well
    [![demo](https://i.imgur.com/2qSNyuK.gif)](https://i.imgur.com/2qSNyuK.mp4)



  **this version `might` break your code, test before update!**

  - **added new anti-detection logic!**

  - v2 has become the main module, so no need for references to v2 anymore. this mean you can now simply use:
    ```python
    import undetected_chromedriver as uc
    driver = uc.Chrome()
    driver.get('https://nowsecure.nl')
    ```
    for backwards compatibility, v2 is not removed, but aliassed to the main module.

  - Fixed "welcome screen" nagging on non-windows OS-es. For those nagfetishists who ❤ welcome screens and feeding google with even more data,
    use Chrome(suppress_welcome=False).

  - replaced `executable_path` in constructor in favor of `browser_executable_path`
    which should not be used unless you are the edge case (yep, you are) who can't add your custom chrome installation folder to your PATH
    environment variable, or have an army of different browsers/versions and automatic lookup returns the wrong browser

  - "v1" (?) moved to _compat for now.

  - fixed dependency versions

  - ChromeOptions custom handling removed, so it is compatible with `webdriver.chromium.options.ChromiumOptions`.

  - removed Chrome.get() fu and restored back to "almost" original:
      - no `with` statements needed anymore, although it will still work for the sake of backward-compatibility.
      - no sleeps, stop-start-sessions, delays, or async cdp black magic!
      - this will solve a lot of other "issues" as well.

  - test success to date: 100%

  - just to mention it another time, since some people have hard time reading:
    **headless is still WIP. Raising issues is needless**



  - change process creation behavior to be fully detached
  - changed .get(url) method to always use the contextmanager
  - changed .get(url) method to use cdp under the hood.

    ... the `with` statement is not necessary anymore ..

  - todo: work towards asyncification and selenium 4



  Whenever you encounter the daunted

  ```from session not created: This version of ChromeDriver only supports Chrome version 96 # or what ever version```

  the solution is simple:

   ```python
      import undetected_chromedriver as uc
      driver = uc.Chrome( version_main = 95 )
   ```

  **July 2021: Currently busy implementing selenium 4 for undetected-chromedriver**

  **newsflash: https://github.com/ultrafunkamsterdam/undetected-chromedriver/pull/255**



  ```
  pip install undetected-chromedriver
  ```



  To prevent unnecessary hair-pulling and issue-raising, please mind the **[important note at the end of this document](#important-note) .**

  <br>



  Literally, this is all you have to do. Settings are included and your browser executable is found automagically. This is also the snippet i
  recommend using in case you experience an issue.

  ```python
  import undetected_chromedriver as uc


  driver = uc.Chrome()
  driver.get( 'https://nowsecure.nl' )  # my own test test site with max anti-bot protection
  ```



  Literally, this is all you have to do. If a specified folder does not exist, a NEW profile is created. Data dirs which are specified like
  this will not be autoremoved on exit.

  ```python
  import undetected_chromedriver as uc


  options = uc.ChromeOptions()


  options.user_data_dir = "c:\\temp\\profile"


  driver = uc.Chrome(
      options = options , version_main = 94
      )  # version_main allows to specify your chrome version instead of following chrome global version

  driver.get( 'https://nowsecure.nl' )  # my own test test site with max anti-bot protection

  ```



  Literally, this is all you have to do. You can now listen and subscribe to the low level devtools-protocol. I just recently found out that
  is also on planning for future release of the official chromedriver. However i implemented my own for now. Since i needed it myself for
  investigation.

  ```python

  import undetected_chromedriver as uc
  from pprint import pformat

  driver = uc.Chrome(enable_cdp_events=True)

  def mylousyprintfunction(eventdata):
      print(pformat(eventdata))


  driver.add_cdp_listener("Network.dataReceived", mylousyprintfunction)
  driver.get('https://nowsecure.nl')  # known url using cloudflare's "under attack mode"


  def mylousyprintfunction(message):
      print(pformat(message))






  driver.add_cdp_listener('Network.requestWillBeSent', mylousyprintfunction)
  driver.add_cdp_listener('Network.dataReceived', mylousyprintfunction)






  driver.get('https://nowsecure.nl')


  {'method': 'Network.requestWillBeSent',
   'params': {'documentURL': 'https://nowsecure.nl/',
              'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'hasUserGesture': False,
              'initiator': {'type': 'other'},
              'loaderId': '449906A5C736D819123288133F2797E6',
              'request': {'headers': {'Upgrade-Insecure-Requests': '1',
                                      'User-Agent': 'Mozilla/5.0 (Windows NT '
                                                    '10.0; Win64; x64) '
                                                    'AppleWebKit/537.36 (KHTML, '
                                                    'like Gecko) '
                                                    'Chrome/90.0.4430.212 '
                                                    'Safari/537.36',
                                      'sec-ch-ua': '" Not A;Brand";v="99", '
                                                   '"Chromium";v="90", "Google '
                                                   'Chrome";v="90"',
                                      'sec-ch-ua-mobile': '?0'},
                          'initialPriority': 'VeryHigh',
                          'method': 'GET',
                          'mixedContentType': 'none',
                          'referrerPolicy': 'strict-origin-when-cross-origin',
                          'url': 'https://nowsecure.nl/'},
              'requestId': '449906A5C736D819123288133F2797E6',
              'timestamp': 190010.996717,
              'type': 'Document',
              'wallTime': 1621835932.112026}}
  {'method': 'Network.requestWillBeSentExtraInfo',
   'params': {'associatedCookies': [],
              'headers': {':authority': 'nowsecure.nl',
                          ':method': 'GET',
                          ':path': '/',
                          ':scheme': 'https',
                          'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
                          'accept-encoding': 'gzip, deflate, br',
                          'accept-language': 'en-US,en;q=0.9',
                          'sec-ch-ua': '" Not A;Brand";v="99", '
                                       '"Chromium";v="90", "Google '
                                       'Chrome";v="90"',
                          'sec-ch-ua-mobile': '?0',
                          'sec-fetch-dest': 'document',
                          'sec-fetch-mode': 'navigate',
                          'sec-fetch-site': 'none',
                          'sec-fetch-user': '?1',
                          'upgrade-insecure-requests': '1',
                          'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; '
                                        'x64) AppleWebKit/537.36 (KHTML, like '
                                        'Gecko) Chrome/90.0.4430.212 '
                                        'Safari/537.36'},
              'requestId': '449906A5C736D819123288133F2797E6'}}
  {'method': 'Network.responseReceivedExtraInfo',
   'params': {'blockedCookies': [],
              'headers': {'alt-svc': 'h3-27=":443"; ma=86400, h3-28=":443"; '
                                     'ma=86400, h3-29=":443"; ma=86400',
                          'cache-control': 'private, max-age=0, no-store, '
                                           'no-cache, must-revalidate, '
                                           'post-check=0, pre-check=0',
                          'cf-ray': '65444b779ae6546f-LHR',
                          'cf-request-id': '0a3e8d7eba0000546ffd3fa000000001',
                          'content-type': 'text/html; charset=UTF-8',
                          'date': 'Mon, 24 May 2021 05:58:53 GMT',
                          'expect-ct': 'max-age=604800, '
                                       'report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"',
                          'expires': 'Thu, 01 Jan 1970 00:00:01 GMT',
                          'nel': '{"report_to":"cf-nel","max_age":604800}',
                          'permissions-policy': 'accelerometer=(),autoplay=(),camera=(),clipboard-read=(),clipboard-write=(),fullscreen=(),geolocation=(),gyroscope=(),hid=(),interest-cohort=(),magnetometer=(),microphone=(),payment=(),publickey-credentials-get=(),screen-wake-lock=(),serial=(),sync-xhr=(),usb=()',
                          'report-to': '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report?s=CAfobYlmWImQ90e%2B4BFBhpPYL%2FyGyBvkcWAj%2B%2FVOLoEq0NVrD5jU9m5pi%2BKI%2BOAnINLPXOCoX2psLphA5Z38aZzWNr3eW%2BDTIK%2FQidc%3D"}],"group":"cf-nel","max_age":604800}',
                          'server': 'cloudflare',
                          'vary': 'Accept-Encoding',
                          'x-frame-options': 'SAMEORIGIN'},
              'requestId': '449906A5C736D819123288133F2797E6',
              'resourceIPAddressSpace': 'Public'}}
  {'method': 'Network.responseReceived',
   'params': {'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'loaderId': '449906A5C736D819123288133F2797E6',
              'requestId': '449906A5C736D819123288133F2797E6',
              'response': {'connectionId': 158,
                           'connectionReused': False,
                           'encodedDataLength': 851,
                           'fromDiskCache': False,
                           'fromPrefetchCache': False,
                           'fromServiceWorker': False,
                           'headers': {'alt-svc': 'h3-27=":443"; ma=86400, '
                                                  'h3-28=":443"; ma=86400, '
                                                  'h3-29=":443"; ma=86400',
                                       'cache-control': 'private, max-age=0, '
                                                        'no-store, no-cache, '
                                                        'must-revalidate, '
                                                        'post-check=0, '
                                                        'pre-check=0',
                                       'cf-ray': '65444b779ae6546f-LHR',
                                       'cf-request-id': '0a3e8d7eba0000546ffd3fa000000001',
                                       'content-type': 'text/html; charset=UTF-8',
                                       'date': 'Mon, 24 May 2021 05:58:53 GMT',
                                       'expect-ct': 'max-age=604800, '
                                                    'report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"',
                                       'expires': 'Thu, 01 Jan 1970 00:00:01 GMT',
                                       'nel': '{"report_to":"cf-nel","max_age":604800}',
                                       'permissions-policy': 'accelerometer=(),autoplay=(),camera=(),clipboard-read=(),clipboard-write=(),fullscreen=(),geolocation=(),gyroscope=(),hid=(),interest-cohort=(),magnetometer=(),microphone=(),payment=(),publickey-credentials-get=(),screen-wake-lock=(),serial=(),sync-xhr=(),usb=()',
                                       'report-to': '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report?s=CAfobYlmWImQ90e%2B4BFBhpPYL%2FyGyBvkcWAj%2B%2FVOLoEq0NVrD5jU9m5pi%2BKI%2BOAnINLPXOCoX2psLphA5Z38aZzWNr3eW%2BDTIK%2FQidc%3D"}],"group":"cf-nel","max_age":604800}',
                                       'server': 'cloudflare',
                                       'vary': 'Accept-Encoding',
                                       'x-frame-options': 'SAMEORIGIN'},
                           'mimeType': 'text/html',
                           'protocol': 'h2',
                           'remoteIPAddress': '104.21.5.197',
                           'remotePort': 443,
                           'requestHeaders': {':authority': 'nowsecure.nl',
                                              ':method': 'GET',
                                              ':path': '/',
                                              ':scheme': 'https',
                                              'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
                                              'accept-encoding': 'gzip, deflate, '
                                                                 'br',
                                              'accept-language': 'en-US,en;q=0.9',
                                              'sec-ch-ua': '" Not '
                                                           'A;Brand";v="99", '
                                                           '"Chromium";v="90", '
                                                           '"Google '
                                                           'Chrome";v="90"',
                                              'sec-ch-ua-mobile': '?0',
                                              'sec-fetch-dest': 'document',
                                              'sec-fetch-mode': 'navigate',
                                              'sec-fetch-site': 'none',
                                              'sec-fetch-user': '?1',
                                              'upgrade-insecure-requests': '1',
                                              'user-agent': 'Mozilla/5.0 '
                                                            '(Windows NT 10.0; '
                                                            'Win64; x64) '
                                                            'AppleWebKit/537.36 '
                                                            '(KHTML, like Gecko) '
                                                            'Chrome/90.0.4430.212 '
                                                            'Safari/537.36'},
                           'responseTime': 1621835932177.923,
                           'securityDetails': {'certificateId': 0,
                                               'certificateTransparencyCompliance': 'compliant',
                                               'cipher': 'AES_128_GCM',
                                               'issuer': 'Cloudflare Inc ECC '
                                                         'CA-3',
                                               'keyExchange': '',
                                               'keyExchangeGroup': 'X25519',
                                               'protocol': 'TLS 1.3',
                                               'sanList': ['sni.cloudflaressl.com',
                                                           '*.nowsecure.nl',
                                                           'nowsecure.nl'],
                                               'signedCertificateTimestampList': [{'hashAlgorithm': 'SHA-256',
                                                                                   'logDescription': 'Google '
                                                                                                     "'Argon2021' "
                                                                                                     'log',
                                                                                   'logId': 'F65C942FD1773022145418083094568EE34D131933BFDF0C2F200BCC4EF164E3',
                                                                                   'origin': 'Embedded '
                                                                                             'in '
                                                                                             'certificate',
                                                                                   'signatureAlgorithm': 'ECDSA',
                                                                                   'signatureData': '30450221008A25458182A6E7F608FE1492086762A367381E94137952FFD621BA2E60F7E2F702203BCDEBCE1C544DECF0A113DE12B33E299319E6240426F38F08DFC04EF2E42825',
                                                                                   'status': 'Verified',
                                                                                   'timestamp': 1598706372839.0},
                                                                                  {'hashAlgorithm': 'SHA-256',
                                                                                   'logDescription': 'DigiCert '
                                                                                                     'Yeti2021 '
                                                                                                     'Log',
                                                                                   'logId': '5CDC4392FEE6AB4544B15E9AD456E61037FBD5FA47DCA17394B25EE6F6C70ECA',
                                                                                   'origin': 'Embedded '
                                                                                             'in '
                                                                                             'certificate',
                                                                                   'signatureAlgorithm': 'ECDSA',
                                                                                   'signatureData': '3046022100A95A49C7435DBFC73406AC409062C27269E6E69F443A2213F3A085E3BCBD234A022100DEA878296F8A1DB43546DC1865A4C5AD2B90664A243AE0A3A6D4925802EE68A8',
                                                                                   'status': 'Verified',
                                                                                   'timestamp': 1598706372823.0}],
                                               'subjectName': 'sni.cloudflaressl.com',
                                               'validFrom': 1598659200,
                                               'validTo': 1630238400},
                           'securityState': 'secure',
                           'status': 503,
                           'statusText': '',
                           'timing': {'connectEnd': 40.414,
                                      'connectStart': 0,
                                      'dnsEnd': 0,
                                      'dnsStart': 0,
                                      'proxyEnd': -1,
                                      'proxyStart': -1,
                                      'pushEnd': 0,
                                      'pushStart': 0,
                                      'receiveHeadersEnd': 60.361,
                                      'requestTime': 190011.002239,
                                      'sendEnd': 41.348,
                                      'sendStart': 41.19,
                                      'sslEnd': 40.405,
                                      'sslStart': 10.853,
                                      'workerFetchStart': -1,
                                      'workerReady': -1,
                                      'workerRespondWithSettled': -1,
                                      'workerStart': -1},
                           'url': 'https://nowsecure.nl/'},
              'timestamp': 190011.06449,
              'type': 'Document'}}
  {'method': 'Page.frameStartedLoading',
   'params': {'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700'}}
  {'method': 'Page.frameNavigated',
   'params': {'frame': {'adFrameType': 'none',
                        'crossOriginIsolatedContextType': 'NotIsolated',
                        'domainAndRegistry': 'nowsecure.nl',
                        'gatedAPIFeatures': ['SharedArrayBuffers',
                                             'SharedArrayBuffersTransferAllowed'],
                        'id': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
                        'loaderId': '449906A5C736D819123288133F2797E6',
                        'mimeType': 'text/html',
                        'secureContextType': 'Secure',
                        'securityOrigin': 'https://nowsecure.nl',
                        'url': 'https://nowsecure.nl/'}}}
  {'method': 'Network.dataReceived',
   'params': {'dataLength': 9835,
              'encodedDataLength': 0,
              'requestId': '449906A5C736D819123288133F2797E6',
              'timestamp': 190011.093343}}
  {'method': 'Network.loadingFinished',
   'params': {'encodedDataLength': 10713,
              'requestId': '449906A5C736D819123288133F2797E6',
              'shouldReportCorbBlocking': False,
              'timestamp': 190011.064011}}
  {'method': 'Network.requestWillBeSent',
   'params': {'documentURL': 'https://nowsecure.nl/',
              'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'hasUserGesture': False,
              'initiator': {'stack': {'callFrames': [{'columnNumber': 51,
                                                      'functionName': '',
                                                      'lineNumber': 114,
                                                      'scriptId': '8',
                                                      'url': 'https://nowsecure.nl/'},
                                                     {'columnNumber': 9,
                                                      'functionName': '',
                                                      'lineNumber': 115,
                                                      'scriptId': '8',
                                                      'url': 'https://nowsecure.nl/'}]},
                            'type': 'script'},
              'loaderId': '449906A5C736D819123288133F2797E6',
              'request': {'headers': {'Referer': 'https://nowsecure.nl/',
                                      'User-Agent': 'Mozilla/5.0 (Windows NT '
                                                    '10.0; Win64; x64) '
                                                    'AppleWebKit/537.36 (KHTML, '
                                                    'like Gecko) '
                                                    'Chrome/90.0.4430.212 '
                                                    'Safari/537.36',
                                      'sec-ch-ua': '" Not A;Brand";v="99", '
                                                   '"Chromium";v="90", "Google '
                                                   'Chrome";v="90"',
                                      'sec-ch-ua-mobile': '?0'},
                          'initialPriority': 'Low',
                          'method': 'GET',
                          'mixedContentType': 'none',
                          'referrerPolicy': 'strict-origin-when-cross-origin',
                          'url': 'https://nowsecure.nl/cdn-cgi/challenge-platform/h/b/orchestrate/jsch/v1?ray=65444b779ae6546f'},
              'requestId': '17180.2',
              'timestamp': 190011.106133,
              'type': 'Script',
              'wallTime': 1621835932.221325}}
  {'method': 'Network.requestWillBeSent',
   'params': {'documentURL': 'https://nowsecure.nl/',
              'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'hasUserGesture': False,
              'initiator': {'columnNumber': 13,
                            'lineNumber': 117,
                            'type': 'parser',
                            'url': 'https://nowsecure.nl/'},
              'loaderId': '449906A5C736D819123288133F2797E6',
              'request': {'headers': {'Referer': 'https://nowsecure.nl/',
                                      'User-Agent': 'Mozilla/5.0 (Windows NT '
                                                    '10.0; Win64; x64) '
                                                    'AppleWebKit/537.36 (KHTML, '
                                                    'like Gecko) '
                                                    'Chrome/90.0.4430.212 '
                                                    'Safari/537.36',
                                      'sec-ch-ua': '" Not A;Brand";v="99", '
                                                   '"Chromium";v="90", "Google '
                                                   'Chrome";v="90"',
                                      'sec-ch-ua-mobile': '?0'},
                          'initialPriority': 'Low',
                          'method': 'GET',
                          'mixedContentType': 'none',
                          'referrerPolicy': 'strict-origin-when-cross-origin',
                          'url': 'https://nowsecure.nl/cdn-cgi/images/trace/jschal/js/transparent.gif?ray=65444b779ae6546f'},
              'requestId': '17180.3',
              'timestamp': 190011.106911,
              'type': 'Image',
              'wallTime': 1621835932.222102}}
  {'method': 'Network.requestWillBeSent',
   'params': {'documentURL': 'https://nowsecure.nl/',
              'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'hasUserGesture': False,
              'initiator': {'type': 'parser', 'url': 'https://nowsecure.nl/'},
              'loaderId': '449906A5C736D819123288133F2797E6',
              'request': {'headers': {'Referer': 'https://nowsecure.nl/',
                                      'User-Agent': 'Mozilla/5.0 (Windows NT '
                                                    '10.0; Win64; x64) '
                                                    'AppleWebKit/537.36 (KHTML, '
                                                    'like Gecko) '
                                                    'Chrome/90.0.4430.212 '
                                                    'Safari/537.36',
                                      'sec-ch-ua': '" Not A;Brand";v="99", '
                                                   '"Chromium";v="90", "Google '
                                                   'Chrome";v="90"',
                                      'sec-ch-ua-mobile': '?0'},
                          'initialPriority': 'Low',
                          'method': 'GET',
                          'mixedContentType': 'none',
                          'referrerPolicy': 'strict-origin-when-cross-origin',
                          'url': 'https://nowsecure.nl/cdn-cgi/images/trace/jschal/nojs/transparent.gif?ray=65444b779ae6546f'},
              'requestId': '17180.4',
              'timestamp': 190011.109527,
              'type': 'Image',
              'wallTime': 1621835932.224719}}
  {'method': 'Page.domContentEventFired', 'params': {'timestamp': 190011.110345}}
  {'method': 'Network.requestWillBeSentExtraInfo',
   'params': {'associatedCookies': [],
              'clientSecurityState': {'initiatorIPAddressSpace': 'Public',
                                      'initiatorIsSecureContext': True,
                                      'privateNetworkRequestPolicy': 'WarnFromInsecureToMorePrivate'},
              'headers': {':authority': 'nowsecure.nl',
                          ':method': 'GET',
                          ':path': '/cdn-cgi/images/trace/jschal/js/transparent.gif?ray=65444b779ae6546f',
                          ':scheme': 'https',
                          'accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
                          'accept-encoding': 'gzip, deflate, br',
                          'accept-language': 'en-US,en;q=0.9',
                          'referer': 'https://nowsecure.nl/',
                          'sec-ch-ua': '" Not A;Brand";v="99", '
                                       '"Chromium";v="90", "Google '
                                       'Chrome";v="90"',
                          'sec-ch-ua-mobile': '?0',
                          'sec-fetch-dest': 'image',
                          'sec-fetch-mode': 'no-cors',
                          'sec-fetch-site': 'same-origin',
                          'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; '
                                        'x64) AppleWebKit/537.36 (KHTML, like '
                                        'Gecko) Chrome/90.0.4430.212 '
                                        'Safari/537.36'},
              'requestId': '17180.3'}}
  {'method': 'Network.requestWillBeSentExtraInfo',
   'params': {'associatedCookies': [],
              'clientSecurityState': {'initiatorIPAddressSpace': 'Public',
                                      'initiatorIsSecureContext': True,
                                      'privateNetworkRequestPolicy': 'WarnFromInsecureToMorePrivate'},
              'headers': {':authority': 'nowsecure.nl',
                          ':method': 'GET',
                          ':path': '/cdn-cgi/challenge-platform/h/b/orchestrate/jsch/v1?ray=65444b779ae6546f',
                          ':scheme': 'https',
                          'accept': '*/*',
                          'accept-encoding': 'gzip, deflate, br',
                          'accept-language': 'en-US,en;q=0.9',
                          'referer': 'https://nowsecure.nl/',
                          'sec-ch-ua': '" Not A;Brand";v="99", '
                                       '"Chromium";v="90", "Google '
                                       'Chrome";v="90"',
                          'sec-ch-ua-mobile': '?0',
                          'sec-fetch-dest': 'script',
                          'sec-fetch-mode': 'no-cors',
                          'sec-fetch-site': 'same-origin',
                          'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; '
                                        'x64) AppleWebKit/537.36 (KHTML, like '
                                        'Gecko) Chrome/90.0.4430.212 '
                                        'Safari/537.36'},
              'requestId': '17180.2'}}
  {'method': 'Network.requestWillBeSentExtraInfo',
   'params': {'associatedCookies': [],
              'clientSecurityState': {'initiatorIPAddressSpace': 'Public',
                                      'initiatorIsSecureContext': True,
                                      'privateNetworkRequestPolicy': 'WarnFromInsecureToMorePrivate'},
              'headers': {':authority': 'nowsecure.nl',
                          ':method': 'GET',
                          ':path': '/cdn-cgi/images/trace/jschal/nojs/transparent.gif?ray=65444b779ae6546f',
                          ':scheme': 'https',
                          'accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
                          'accept-encoding': 'gzip, deflate, br',
                          'accept-language': 'en-US,en;q=0.9',
                          'referer': 'https://nowsecure.nl/',
                          'sec-ch-ua': '" Not A;Brand";v="99", '
                                       '"Chromium";v="90", "Google '
                                       'Chrome";v="90"',
                          'sec-ch-ua-mobile': '?0',
                          'sec-fetch-dest': 'image',
                          'sec-fetch-mode': 'no-cors',
                          'sec-fetch-site': 'same-origin',
                          'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; '
                                        'x64) AppleWebKit/537.36 (KHTML, like '
                                        'Gecko) Chrome/90.0.4430.212 '
                                        'Safari/537.36'},
              'requestId': '17180.4'}}
  {'method': 'Network.responseReceivedExtraInfo',
   'params': {'blockedCookies': [],
              'headers': {'accept-ranges': 'bytes',
                          'cache-control': 'max-age=7200\npublic',
                          'cf-ray': '65444b781d1de604-LHR',
                          'content-length': '42',
                          'content-type': 'image/gif',
                          'date': 'Mon, 24 May 2021 05:58:53 GMT',
                          'etag': '"60a4d856-2a"',
                          'expires': 'Mon, 24 May 2021 07:58:53 GMT',
                          'last-modified': 'Wed, 19 May 2021 09:20:22 GMT',
                          'server': 'cloudflare',
                          'vary': 'Accept-Encoding',
                          'x-content-type-options': 'nosniff',
                          'x-frame-options': 'DENY'},
              'requestId': '17180.3',
              'resourceIPAddressSpace': 'Public'}}
  {'method': 'Network.responseReceivedExtraInfo',
   'params': {'blockedCookies': [],
              'headers': {'accept-ranges': 'bytes',
                          'cache-control': 'max-age=7200\npublic',
                          'cf-ray': '65444b781d1fe604-LHR',
                          'content-length': '42',
                          'content-type': 'image/gif',
                          'date': 'Mon, 24 May 2021 05:58:53 GMT',
                          'etag': '"60a4d856-2a"',
                          'expires': 'Mon, 24 May 2021 07:58:53 GMT',
                          'last-modified': 'Wed, 19 May 2021 09:20:22 GMT',
                          'server': 'cloudflare',
                          'vary': 'Accept-Encoding',
                          'x-content-type-options': 'nosniff',
                          'x-frame-options': 'DENY'},
              'requestId': '17180.4',
              'resourceIPAddressSpace': 'Public'}}
  {'method': 'Network.resourceChangedPriority',
   'params': {'newPriority': 'High',
              'requestId': '17180.4',
              'timestamp': 190011.171057}}
  {'method': 'Network.responseReceived',
   'params': {'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'loaderId': '449906A5C736D819123288133F2797E6',
              'requestId': '17180.3',
              'response': {'connectionId': 0,
                           'connectionReused': False,
                           'encodedDataLength': 214,
                           'fromDiskCache': False,
                           'fromPrefetchCache': False,
                           'fromServiceWorker': False,
                           'headers': {'accept-ranges': 'bytes',
                                       'cache-control': 'max-age=7200\npublic',
                                       'cf-ray': '65444b781d1de604-LHR',
                                       'content-length': '42',
                                       'content-type': 'image/gif',
                                       'date': 'Mon, 24 May 2021 05:58:53 GMT',
                                       'etag': '"60a4d856-2a"',
                                       'expires': 'Mon, 24 May 2021 07:58:53 GMT',
                                       'last-modified': 'Wed, 19 May 2021 '
                                                        '09:20:22 GMT',
                                       'server': 'cloudflare',
                                       'vary': 'Accept-Encoding',
                                       'x-content-type-options': 'nosniff',
                                       'x-frame-options': 'DENY'},
                           'mimeType': 'image/gif',
                           'protocol': 'h3-29',
                           'remoteIPAddress': '104.21.5.197',
                           'remotePort': 443,
                           'requestHeaders': {':authority': 'nowsecure.nl',
                                              ':method': 'GET',
                                              ':path': '/cdn-cgi/images/trace/jschal/js/transparent.gif?ray=65444b779ae6546f',
                                              ':scheme': 'https',
                                              'accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
                                              'accept-encoding': 'gzip, deflate, '
                                                                 'br',
                                              'accept-language': 'en-US,en;q=0.9',
                                              'referer': 'https://nowsecure.nl/',
                                              'sec-ch-ua': '" Not '
                                                           'A;Brand";v="99", '
                                                           '"Chromium";v="90", '
                                                           '"Google '
                                                           'Chrome";v="90"',
                                              'sec-ch-ua-mobile': '?0',
                                              'sec-fetch-dest': 'image',
                                              'sec-fetch-mode': 'no-cors',
                                              'sec-fetch-site': 'same-origin',
                                              'user-agent': 'Mozilla/5.0 '
                                                            '(Windows NT 10.0; '
                                                            'Win64; x64) '
                                                            'AppleWebKit/537.36 '
                                                            '(KHTML, like Gecko) '
                                                            'Chrome/90.0.4430.212 '
                                                            'Safari/537.36'},
                           'responseTime': 1621835932265.169,
                           'securityDetails': {'certificateId': 0,
                                               'certificateTransparencyCompliance': 'compliant',
                                               'cipher': 'AES_128_GCM',
                                               'issuer': 'Cloudflare Inc ECC '
                                                         'CA-3',
                                               'keyExchange': '',
                                               'keyExchangeGroup': 'X25519',
                                               'protocol': 'QUIC',
                                               'sanList': ['sni.cloudflaressl.com',
                                                           '*.nowsecure.nl',
                                                           'nowsecure.nl'],
                                               'signedCertificateTimestampList': [{'hashAlgorithm': 'SHA-256',
                                                                                   'logDescription': 'Google '
                                                                                                     "'Argon2021' "
                                                                                                     'log',
                                                                                   'logId': 'F65C942FD1773022145418083094568EE34D131933BFDF0C2F200BCC4EF164E3',
                                                                                   'origin': 'Embedded '
                                                                                             'in '
                                                                                             'certificate',
                                                                                   'signatureAlgorithm': 'ECDSA',
                                                                                   'signatureData': '30450221008A25458182A6E7F608FE1492086762A367381E94137952FFD621BA2E60F7E2F702203BCDEBCE1C544DECF0A113DE12B33E299319E6240426F38F08DFC04EF2E42825',
                                                                                   'status': 'Verified',
                                                                                   'timestamp': 1598706372839.0},
                                                                                  {'hashAlgorithm': 'SHA-256',
                                                                                   'logDescription': 'DigiCert '
                                                                                                     'Yeti2021 '
                                                                                                     'Log',
                                                                                   'logId': '5CDC4392FEE6AB4544B15E9AD456E61037FBD5FA47DCA17394B25EE6F6C70ECA',
                                                                                   'origin': 'Embedded '
                                                                                             'in '
                                                                                             'certificate',
                                                                                   'signatureAlgorithm': 'ECDSA',
                                                                                   'signatureData': '3046022100A95A49C7435DBFC73406AC409062C27269E6E69F443A2213F3A085E3BCBD234A022100DEA878296F8A1DB43546DC1865A4C5AD2B90664A243AE0A3A6D4925802EE68A8',
                                                                                   'status': 'Verified',
                                                                                   'timestamp': 1598706372823.0}],
                                               'subjectName': 'sni.cloudflaressl.com',
                                               'validFrom': 1598659200,
                                               'validTo': 1630238400},
                           'securityState': 'secure',
                           'status': 200,
                           'statusText': '',
                           'timing': {'connectEnd': 26.087,
                                      'connectStart': 0,
                                      'dnsEnd': 0,
                                      'dnsStart': 0,
                                      'proxyEnd': -1,
                                      'proxyStart': -1,
                                      'pushEnd': 0,
                                      'pushStart': 0,
                                      'receiveHeadersEnd': 40.709,
                                      'requestTime': 190011.109386,
                                      'sendEnd': 26.346,
                                      'sendStart': 26.182,
                                      'sslEnd': 26.087,
                                      'sslStart': 0,
                                      'workerFetchStart': -1,
                                      'workerReady': -1,
                                      'workerRespondWithSettled': -1,
                                      'workerStart': -1},
                           'url': 'https://nowsecure.nl/cdn-cgi/images/trace/jschal/js/transparent.gif?ray=65444b779ae6546f'},
              'timestamp': 190011.174536,
              'type': 'Image'}}
  {'method': 'Network.dataReceived',
   'params': {'dataLength': 42,
              'encodedDataLength': 0,
              'requestId': '17180.3',
              'timestamp': 190011.174737}}
  {'method': 'Network.dataReceived',
   'params': {'dataLength': 0,
              'encodedDataLength': 44,
              'requestId': '17180.3',
              'timestamp': 190011.17524}}
  {'method': 'Network.loadingFinished',
   'params': {'encodedDataLength': 258,
              'requestId': '17180.3',
              'shouldReportCorbBlocking': False,
              'timestamp': 190011.152073}}
  {'method': 'Network.responseReceived',
   'params': {'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'loaderId': '449906A5C736D819123288133F2797E6',
              'requestId': '17180.4',
              'response': {'connectionId': 0,
                           'connectionReused': True,
                           'encodedDataLength': 178,
                           'fromDiskCache': False,
                           'fromPrefetchCache': False,
                           'fromServiceWorker': False,
                           'headers': {'accept-ranges': 'bytes',
                                       'cache-control': 'max-age=7200\npublic',
                                       'cf-ray': '65444b781d1fe604-LHR',
                                       'content-length': '42',
                                       'content-type': 'image/gif',
                                       'date': 'Mon, 24 May 2021 05:58:53 GMT',
                                       'etag': '"60a4d856-2a"',
                                       'expires': 'Mon, 24 May 2021 07:58:53 GMT',
                                       'last-modified': 'Wed, 19 May 2021 '
                                                        '09:20:22 GMT',
                                       'server': 'cloudflare',
                                       'vary': 'Accept-Encoding',
                                       'x-content-type-options': 'nosniff',
                                       'x-frame-options': 'DENY'},
                           'mimeType': 'image/gif',
                           'protocol': 'h3-29',
                           'remoteIPAddress': '104.21.5.197',
                           'remotePort': 443,
                           'requestHeaders': {':authority': 'nowsecure.nl',
                                              ':method': 'GET',
                                              ':path': '/cdn-cgi/images/trace/jschal/nojs/transparent.gif?ray=65444b779ae6546f',
                                              ':scheme': 'https',
                                              'accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
                                              'accept-encoding': 'gzip, deflate, '
                                                                 'br',
                                              'accept-language': 'en-US,en;q=0.9',
                                              'referer': 'https://nowsecure.nl/',
                                              'sec-ch-ua': '" Not '
                                                           'A;Brand";v="99", '
                                                           '"Chromium";v="90", '
                                                           '"Google '
                                                           'Chrome";v="90"',
                                              'sec-ch-ua-mobile': '?0',
                                              'sec-fetch-dest': 'image',
                                              'sec-fetch-mode': 'no-cors',
                                              'sec-fetch-site': 'same-origin',
                                              'user-agent': 'Mozilla/5.0 '
                                                            '(Windows NT 10.0; '
                                                            'Win64; x64) '
                                                            'AppleWebKit/537.36 '
                                                            '(KHTML, like Gecko) '
                                                            'Chrome/90.0.4430.212 '
                                                            'Safari/537.36'},
                           'responseTime': 1621835932268.067,
                           'securityDetails': {'certificateId': 0,
                                               'certificateTransparencyCompliance': 'compliant',
                                               'cipher': 'AES_128_GCM',
                                               'issuer': 'Cloudflare Inc ECC '
                                                         'CA-3',
                                               'keyExchange': '',
                                               'keyExchangeGroup': 'X25519',
                                               'protocol': 'QUIC',
                                               'sanList': ['sni.cloudflaressl.com',
                                                           '*.nowsecure.nl',
                                                           'nowsecure.nl'],
                                               'signedCertificateTimestampList': [{'hashAlgorithm': 'SHA-256',
                                                                                   'logDescription': 'Google '
                                                                                                     "'Argon2021' "
                                                                                                     'log',
                                                                                   'logId': 'F65C942FD1773022145418083094568EE34D131933BFDF0C2F200BCC4EF164E3',
                                                                                   'origin': 'Embedded '
                                                                                             'in '
                                                                                             'certificate',
                                                                                   'signatureAlgorithm': 'ECDSA',
                                                                                   'signatureData': '30450221008A25458182A6E7F608FE1492086762A367381E94137952FFD621BA2E60F7E2F702203BCDEBCE1C544DECF0A113DE12B33E299319E6240426F38F08DFC04EF2E42825',
                                                                                   'status': 'Verified',
                                                                                   'timestamp': 1598706372839.0},
                                                                                  {'hashAlgorithm': 'SHA-256',
                                                                                   'logDescription': 'DigiCert '
                                                                                                     'Yeti2021 '
                                                                                                     'Log',
                                                                                   'logId': '5CDC4392FEE6AB4544B15E9AD456E61037FBD5FA47DCA17394B25EE6F6C70ECA',
                                                                                   'origin': 'Embedded '
                                                                                             'in '
                                                                                             'certificate',
                                                                                   'signatureAlgorithm': 'ECDSA',
                                                                                   'signatureData': '3046022100A95A49C7435DBFC73406AC409062C27269E6E69F443A2213F3A085E3BCBD234A022100DEA878296F8A1DB43546DC1865A4C5AD2B90664A243AE0A3A6D4925802EE68A8',
                                                                                   'status': 'Verified',
                                                                                   'timestamp': 1598706372823.0}],
                                               'subjectName': 'sni.cloudflaressl.com',
                                               'validFrom': 1598659200,
                                               'validTo': 1630238400},
                           'securityState': 'secure',
                           'status': 200,
                           'statusText': '',
                           'timing': {'connectEnd': -1,
                                      'connectStart': -1,
                                      'dnsEnd': -1,
                                      'dnsStart': -1,
                                      'proxyEnd': -1,
                                      'proxyStart': -1,
                                      'pushEnd': 0,
                                      'pushStart': 0,
                                      'receiveHeadersEnd': 42.415,
                                      'requestTime': 190011.110341,
                                      'sendEnd': 25.713,
                                      'sendStart': 25.609,
                                      'sslEnd': -1,
                                      'sslStart': -1,
                                      'workerFetchStart': -1,
                                      'workerReady': -1,
                                      'workerRespondWithSettled': -1,
                                      'workerStart': -1},
                           'url': 'https://nowsecure.nl/cdn-cgi/images/trace/jschal/nojs/transparent.gif?ray=65444b779ae6546f'},
              'timestamp': 190011.175727,
              'type': 'Image'}}
  {'method': 'Network.dataReceived',
   'params': {'dataLength': 42,
              'encodedDataLength': 0,
              'requestId': '17180.4',
              'timestamp': 190011.175856}}
  {'method': 'Network.dataReceived',
   'params': {'dataLength': 0,
              'encodedDataLength': 44,
              'requestId': '17180.4',
              'timestamp': 190011.176133}}
  {'method': 'Network.loadingFinished',
   'params': {'encodedDataLength': 222,
              'requestId': '17180.4',
              'shouldReportCorbBlocking': False,
              'timestamp': 190011.153335}}
  {'method': 'Network.responseReceivedExtraInfo',
   'params': {'blockedCookies': [],
              'headers': {'alt-svc': 'h3-27=":443"; ma=86400, h3-28=":443"; '
                                     'ma=86400, h3-29=":443"; ma=86400',
                          'cache-control': 'max-age=0, must-revalidate',
                          'cf-ray': '65444b781d1ee604-LHR',
                          'cf-request-id': '0a3e8d7f140000e60496387000000001',
                          'content-encoding': 'br',
                          'content-type': 'text/javascript',
                          'date': 'Mon, 24 May 2021 05:58:53 GMT',
                          'expect-ct': 'max-age=604800, '
                                       'report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"',
                          'nel': '{"report_to":"cf-nel","max_age":604800}',
                          'report-to': '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report?s=ZtI%2Bx8B7DpI8%2FsDA72maecFVCPvIsfBOyJjT8weyiqfmrHrmcBYpRhc%2FI%2F6JmIlnxW%2F%2BBohxLi1F8mpjAUabJ0kXLYnmjGKp2Ndio9M%3D"}],"group":"cf-nel","max_age":604800}',
                          'server': 'cloudflare',
                          'vary': 'Accept-Encoding'},
              'requestId': '17180.2',
              'resourceIPAddressSpace': 'Public'}}
  {'method': 'Network.responseReceived',
   'params': {'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'loaderId': '449906A5C736D819123288133F2797E6',
              'requestId': '17180.2',
              'response': {'connectionId': 0,
                           'connectionReused': True,
                           'encodedDataLength': 510,
                           'fromDiskCache': False,
                           'fromPrefetchCache': False,
                           'fromServiceWorker': False,
                           'headers': {'alt-svc': 'h3-27=":443"; ma=86400, '
                                                  'h3-28=":443"; ma=86400, '
                                                  'h3-29=":443"; ma=86400',
                                       'cache-control': 'max-age=0, '
                                                        'must-revalidate',
                                       'cf-ray': '65444b781d1ee604-LHR',
                                       'cf-request-id': '0a3e8d7f140000e60496387000000001',
                                       'content-encoding': 'br',
                                       'content-type': 'text/javascript',
                                       'date': 'Mon, 24 May 2021 05:58:53 GMT',
                                       'expect-ct': 'max-age=604800, '
                                                    'report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"',
                                       'nel': '{"report_to":"cf-nel","max_age":604800}',
                                       'report-to': '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report?s=ZtI%2Bx8B7DpI8%2FsDA72maecFVCPvIsfBOyJjT8weyiqfmrHrmcBYpRhc%2FI%2F6JmIlnxW%2F%2BBohxLi1F8mpjAUabJ0kXLYnmjGKp2Ndio9M%3D"}],"group":"cf-nel","max_age":604800}',
                                       'server': 'cloudflare',
                                       'vary': 'Accept-Encoding'},
                           'mimeType': 'text/javascript',
                           'protocol': 'h3-29',
                           'remoteIPAddress': '104.21.5.197',
                           'remotePort': 443,
                           'requestHeaders': {':authority': 'nowsecure.nl',
                                              ':method': 'GET',
                                              ':path': '/cdn-cgi/challenge-platform/h/b/orchestrate/jsch/v1?ray=65444b779ae6546f',
                                              ':scheme': 'https',
                                              'accept': '*/*',
                                              'accept-encoding': 'gzip, deflate, '
                                                                 'br',
                                              'accept-language': 'en-US,en;q=0.9',
                                              'referer': 'https://nowsecure.nl/',
                                              'sec-ch-ua': '" Not '
                                                           'A;Brand";v="99", '
                                                           '"Chromium";v="90", '
                                                           '"Google '
                                                           'Chrome";v="90"',
                                              'sec-ch-ua-mobile': '?0',
                                              'sec-fetch-dest': 'script',
                                              'sec-fetch-mode': 'no-cors',
                                              'sec-fetch-site': 'same-origin',
                                              'user-agent': 'Mozilla/5.0 '
                                                            '(Windows NT 10.0; '
                                                            'Win64; x64) '
                                                            'AppleWebKit/537.36 '
                                                            '(KHTML, like Gecko) '
                                                            'Chrome/90.0.4430.212 '
                                                            'Safari/537.36'},
                           'responseTime': 1621835932301.817,
                           'securityDetails': {'certificateId': 0,
                                               'certificateTransparencyCompliance': 'compliant',
                                               'cipher': 'AES_128_GCM',
                                               'issuer': 'Cloudflare Inc ECC '
                                                         'CA-3',
                                               'keyExchange': '',
                                               'keyExchangeGroup': 'X25519',
                                               'protocol': 'QUIC',
                                               'sanList': ['sni.cloudflaressl.com',
                                                           '*.nowsecure.nl',
                                                           'nowsecure.nl'],
                                               'signedCertificateTimestampList': [{'hashAlgorithm': 'SHA-256',
                                                                                   'logDescription': 'Google '
                                                                                                     "'Argon2021' "
                                                                                                     'log',
                                                                                   'logId': 'F65C942FD1773022145418083094568EE34D131933BFDF0C2F200BCC4EF164E3',
                                                                                   'origin': 'Embedded '
                                                                                             'in '
                                                                                             'certificate',
                                                                                   'signatureAlgorithm': 'ECDSA',
                                                                                   'signatureData': '30450221008A25458182A6E7F608FE1492086762A367381E94137952FFD621BA2E60F7E2F702203BCDEBCE1C544DECF0A113DE12B33E299319E6240426F38F08DFC04EF2E42825',
                                                                                   'status': 'Verified',
                                                                                   'timestamp': 1598706372839.0},
                                                                                  {'hashAlgorithm': 'SHA-256',
                                                                                   'logDescription': 'DigiCert '
                                                                                                     'Yeti2021 '
                                                                                                     'Log',
                                                                                   'logId': '5CDC4392FEE6AB4544B15E9AD456E61037FBD5FA47DCA17394B25EE6F6C70ECA',
                                                                                   'origin': 'Embedded '
                                                                                             'in '
                                                                                             'certificate',
                                                                                   'signatureAlgorithm': 'ECDSA',
                                                                                   'signatureData': '3046022100A95A49C7435DBFC73406AC409062C27269E6E69F443A2213F3A085E3BCBD234A022100DEA878296F8A1DB43546DC1865A4C5AD2B90664A243AE0A3A6D4925802EE68A8',
                                                                                   'status': 'Verified',
                                                                                   'timestamp': 1598706372823.0}],
                                               'subjectName': 'sni.cloudflaressl.com',
                                               'validFrom': 1598659200,
                                               'validTo': 1630238400},
                           'securityState': 'secure',
                           'status': 200,
                           'statusText': '',
                           'timing': {'connectEnd': -1,
                                      'connectStart': -1,
                                      'dnsEnd': -1,
                                      'dnsStart': -1,
                                      'proxyEnd': -1,
                                      'proxyStart': -1,
                                      'pushEnd': 0,
                                      'pushStart': 0,
                                      'receiveHeadersEnd': 78.885,
                                      'requestTime': 190011.107975,
                                      'sendEnd': 27.934,
                                      'sendStart': 27.809,
                                      'sslEnd': -1,
                                      'sslStart': -1,
                                      'workerFetchStart': -1,
                                      'workerReady': -1,
                                      'workerRespondWithSettled': -1,
                                      'workerStart': -1},
                           'url': 'https://nowsecure.nl/cdn-cgi/challenge-platform/h/b/orchestrate/jsch/v1?ray=65444b779ae6546f'},
              'timestamp': 190011.188468,
              'type': 'Script'}}
  {'method': 'Network.dataReceived',
   'params': {'dataLength': 31556,
              'encodedDataLength': 0,
              'requestId': '17180.2',
              'timestamp': 190011.188663}}
  {'method': 'Network.dataReceived',
   'params': {'dataLength': 6737,
              'encodedDataLength': 11251,
              'requestId': '17180.2',
              'timestamp': 190011.198249}}
  {'method': 'Network.dataReceived',
   'params': {'dataLength': 0,
              'encodedDataLength': 2049,
              'requestId': '17180.2',
              'timestamp': 190011.200943}}
  {'method': 'Network.loadingFinished',
   'params': {'encodedDataLength': 13810,
              'requestId': '17180.2',
              'shouldReportCorbBlocking': False,
              'timestamp': 190011.198142}}
  {'method': 'Page.loadEventFired', 'params': {'timestamp': 190011.204711}}
  {'method': 'Page.frameScheduledNavigation',
   'params': {'delay': 12,
              'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'reason': 'metaTagRefresh',
              'url': 'https://nowsecure.nl/'}}
  {'method': 'Page.frameStoppedLoading',
   'params': {'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700'}}
  {'method': 'Network.requestWillBeSent',
   'params': {'documentURL': 'https://nowsecure.nl/',
              'frameId': 'F42BAE4BDD4E428EE2503CB5A7B4F700',
              'hasUserGesture': False,
              'initiator': {'type': 'other'},
              'loaderId': '449906A5C736D819123288133F2797E6',
              'request': {'headers': {'Referer': 'https://nowsecure.nl/',
                                      'User-Agent': 'Mozilla/5.0 (Windows NT '
                                                    '10.0; Win64; x64) '
                                                    'AppleWebKit/537.36 (KHTML, '
                                                    'like Gecko) '
                                                    'Chrome/90.0.4430.212 '
                                                    'Safari/537.36',
                                      'sec-ch-ua': '" Not A;Brand";v="99", '
                                                   '"Chromium";v="90", "Google '
                                                   'Chrome";v="90"',
                                      'sec-ch-ua-mobile': '?0'},
                          'initialPriority': 'High',
                          'method': 'GET',
                          'mixedContentType': 'none',
                          'referrerPolicy': 'strict-origin-when-cross-origin',
                          'url': 'https://nowsecure.nl/favicon.ico'},
              'requestId': '17180.5',
              'timestamp': 190011.210491,
              'type': 'Other',
              'wallTime': 1621835932.325683}}
  {'method': 'Network.requestWillBeSentExtraInfo',
   'params': {'associatedCookies': [{'blockedReasons': [],
                                     'cookie': {'domain': 'nowsecure.nl',
                                                'expires': 1621839532,
                                                'httpOnly': False,
                                                'name': 'cf_chl_prog',
                                                'path': '/',
                                                'priority': 'Medium',
                                                'sameParty': False,
                                                'secure': False,
                                                'session': False,
                                                'size': 12,
                                                'sourcePort': 443,
                                                'sourceScheme': 'Secure',
                                                'value': 'e'}}],
              'clientSecurityState': {'initiatorIPAddressSpace': 'Public',
                                      'initiatorIsSecureContext': True,
                                      'privateNetworkRequestPolicy': 'WarnFromInsecureToMorePrivate'},
              'headers': {':authority': 'nowsecure.nl',
                          ':method': 'GET',
                          ':path': '/favicon.ico',
                          ':scheme': 'https',
                          'accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
                          'accept-encoding': 'gzip, deflate, br',
                          'accept-language': 'en-US,en;q=0.9',
                          'cookie': 'cf_chl_prog=e',
                          'referer': 'https://nowsecure.nl/',
                          'sec-ch-ua': '" Not A;Brand";v="99", '
                                       '"Chromium";v="90", "Google '
                                       'Chrome";v="90"',
                          'sec-ch-ua-mobile': '?0',
                          'sec-fetch-dest': 'image',
                          'sec-fetch-mode': 'no-cors',
                          'sec-fetch-site': 'same-origin',
                          'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; '
                                        'x64) AppleWebKit/537.36 (KHTML, like '
                                        'Gecko) Chrome/90.0.4430.212 '
                                        'Safari/537.36'},


  ```

  <br>
  <br>



  ```python
  import undetected_chromedriver as uc


  driver = uc.Chrome()
  driver.get( 'https://distilnetworks.com' )
  ```



  ```python
  import undetected_chromedriver as uc


  uc.TARGET_VERSION = 85
  driver = uc.Chrome()
  ```



  Needs to be done before importing from selenium package

  ```python
  import undetected_chromedriver as uc


  uc.install()

  from selenium.webdriver import Chrome


  driver = Chrome()
  driver.get( 'https://distilnetworks.com' )

  ```



  ```python
  import undetected_chromedriver as uc



  uc.TARGET_VERSION = 78



  uc.install(
      executable_path = 'c:/users/user1/chromedriver.exe' ,
      )

  opts = uc.ChromeOptions()
  opts.add_argument( f'--proxy-server=socks5://127.0.0.1:9050' )
  driver = uc.Chrome( options = opts )
  driver.get( 'https://distilnetworks.com' )
  ```



  These guys have actually a powerful product, and a link to this repo, which makes me wanna test their product. Make sure you use a "clean"ip
  for this one.

  ```python



  from selenium import webdriver


  chrome = webdriver.Chrome()
  chrome.get( 'https://datadome.co/customers-stories/toppreise-ends-web-scraping-and-content-theft-with-datadome/' )
  chrome.save_screenshot( 'datadome_regular_webdriver.png' )
  True  # it caused my ip to be flagged, unfortunately




  import undetected_chromedriver as uc


  options = uc.ChromeOptions()
  options.headless = True
  options.add_argument( '--headless' )
  chrome = uc.Chrome( options = options )
  chrome.get( 'https://datadome.co/customers-stories/toppreise-ends-web-scraping-and-content-theft-with-datadome/' )
  chrome.save_screenshot( 'datadome_undetected_webddriver.png' )

  ```

  **Check both saved screenhots [here](https://imgur.com/a/fEmqadP)**


