# packages

pkgId: 4e161cde4d55f93e37924df9c994dceda658d4837cd782919ac6a8b1bd677a7e
name: python-pytest-base-url
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: pytest plugin for URL based testing
url: https://github.com/pytest-dev/pytest-base-url
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6427ff9-8640-457f-9734-8ee32fa08f0f
location_href: 00011072-python-pytest-base-url/python-pytest-base-url-2.0.0-1.src.rpm
checksum_type: sha256
description:
  pytest-base-url is a simple plugin for pytest_ that provides an optional base
  URL via the command line or configuration file.


pkgId: 8eed290bd325f950178e7990e4d7131d6eb43b384c9afc8ea5018dcf327735b6
name: python-pytest-beakerlib
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: A pytest plugin that reports test results to the BeakerLib framework
url: https://pagure.io/python-pytest-beakerlib
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-553bbd52-b0d7-43bf-9790-a2dbbdba1749
location_href: 00004830-python-pytest-beakerlib/python-pytest-beakerlib-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Release tarballs are available for download from Fedora Hosted:
      https://pagure.io/releases/python-pytest-beakerlib/
  You can also install using pip:
      https://pypi.python.org/pypi/pytest-beakerlib/0.2
  The plugin is also available in Fedora repositories as
  ``python3-pytest-beakerlib``.


pkgId: 0b2d28117a9955b41a3c1020c0083ff075ee419860dfb67db73e8f569230e2f7
name: python-pytest-benchmark
arch: src
version: 4.0.0
epoch: 0
release: 1
url: https://github.com/ionelmc/pytest-benchmark
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02e3c3de-6354-4388-8741-82b4c6fd31bf
location_href: 00004831-python-pytest-benchmark/python-pytest-benchmark-4.0.0-1.src.rpm
checksum_type: sha256
summary:
  A ``pytest`` fixture for benchmarking code. It will group the tests into rounds that are calibrated to the chosen timer.


pkgId: 1373f9ec350f8c40a1762a767e8272c8020bc79fcb37434dc94f9b4e2018f9f3
name: python-pytest-cases
arch: src
version: 3.6.14
epoch: 0
release: 1
summary: Separate test code from test cases in pytest.
url: https://github.com/smarie/python-pytest-cases
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-125cabad-3970-42a4-acf1-c21809ea197d
location_href: 00004834-python-pytest-cases/python-pytest-cases-3.6.14-1.src.rpm
checksum_type: sha256
description:
  [![Python versions](https://img.shields.io/pypi/pyversions/pytest-cases.svg)](https://pypi.python.org/pypi/pytest-cases/) ![Pytest versions](https://img.shields.io/badge/pytest-2%20%7C%203%20%7C%204%20%7C%205%20%7C%206%20%7C%207-blue) [![Build Status](https://github.com/smarie/python-pytest-cases/actions/workflows/base.yml/badge.svg)](https://github.com/smarie/python-pytest-cases/actions/workflows/base.yml) [![Tests Status](https://smarie.github.io/python-pytest-cases/reports/junit/junit-badge.svg?dummy=8484744)](https://smarie.github.io/python-pytest-cases/reports/junit/report.html) [![Coverage Status](https://smarie.github.io/python-pytest-cases/reports/coverage/coverage-badge.svg?dummy=8484744)](https://smarie.github.io/python-pytest-cases/reports/coverage/index.html) [![codecov](https://codecov.io/gh/smarie/python-pytest-cases/branch/main/graph/badge.svg)](https://codecov.io/gh/smarie/python-pytest-cases) [![Flake8 Status](https://smarie.github.io/python-pytest-cases/reports/flake8/flake8-badge.svg?dummy=8484744)](https://smarie.github.io/python-pytest-cases/reports/flake8/index.html)

  [![Documentation](https://img.shields.io/badge/doc-latest-blue.svg)](https://smarie.github.io/python-pytest-cases/) [![PyPI](https://img.shields.io/pypi/v/pytest-cases.svg)](https://pypi.python.org/pypi/pytest-cases/) [![Downloads](https://pepy.tech/badge/pytest-cases)](https://pepy.tech/project/pytest-cases) [![Downloads per week](https://pepy.tech/badge/pytest-cases/week)](https://pepy.tech/project/pytest-cases) [![GitHub stars](https://img.shields.io/github/stars/smarie/python-pytest-cases.svg)](https://github.com/smarie/python-pytest-cases/stargazers) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3937829.svg)](https://doi.org/10.5281/zenodo.3937829)

  Separate test code from test cases in `pytest`.

  The documentation for users is available here: [https://smarie.github.io/python-pytest-cases/](https://smarie.github.io/python-pytest-cases/)

  A readme for developers is available here: [https://github.com/smarie/python-pytest-cases](https://github.com/smarie/python-pytest-cases)


pkgId: e2c4b7dfba613c5c4b7bb44240d4eaa35ad9303faae3c366150d8b34f53f1911
name: python-pytest-console-scripts
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Pytest plugin for testing console scripts
url: https://github.com/kvas-it/pytest-console-scripts
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f61a1929-9524-44db-bd54-0130541a603b
location_href: 00013606-python-pytest-console-scripts/python-pytest-console-scripts-1.3.1-1.src.rpm
checksum_type: sha256
description:
  Pytest-console-scripts is a [pytest][1] plugin for running python scripts from
  within tests. It's quite similar to `subprocess.run()`, but it also has an
  in-process mode, where the scripts are executed by the interpreter that's
  running `pytest` (using some amount of sandboxing).
  In-process mode significantly reduces the run time of the test suites that
  run many external scripts. This is speeds up development. In the CI environment
  subprocess mode can be used to make sure the scripts also work (and behave the
  same) when run by a fresh interpreter.


pkgId: 541c41141bed5b6b86a3ae02241d42feb32c693cc06c34a266816c20b327050c
name: python-pytest-datadir
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: pytest plugin for test data directories and files
url: http://github.com/gabrielcnr/pytest-datadir
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2295fce5-66c4-4aff-9ca7-f19cce0af913
location_href: 00011607-python-pytest-datadir/python-pytest-datadir-1.4.1-1.src.rpm
checksum_type: sha256
description:
  pytest plugin for manipulating test data directories and files.

  [![Build Status](https://github.com/gabrielcnr/pytest-datadir/workflows/build/badge.svg?branch=master)](https://github.com/gabrielcnr/pytest-datadir/workflows/build/badge.svg?branch=master)
  [![PyPI](https://img.shields.io/pypi/v/pytest-datadir.svg)](https://pypi.python.org/pypi/pytest-datadir)
  [![CondaForge](https://img.shields.io/conda/vn/conda-forge/pytest-datadir.svg)](https://anaconda.org/conda-forge/pytest-datadir)
  ![Python Version](https://img.shields.io/badge/python-3.6+-blue.svg)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  pytest-datadir will look up for a directory with the name of your module or the global 'data' folder.
  Let's say you have a structure like this:

  ```
  .
  ├── data/
  │   └── hello.txt
  ├── test_hello/
  │   └── spam.txt
  └── test_hello.py
  ```
  You can access the contents of these files using injected variables `datadir` (for *test_* folder) or `shared_datadir`
  (for *data* folder):

  ```python
  def test_read_global(shared_datadir):
      contents = (shared_datadir / "hello.txt").read_text()
      assert contents == "Hello World!\n"


  def test_read_module(datadir):
      contents = (datadir / "spam.txt").read_text()
      assert contents == "eggs\n"
  ```

  pytest-datadir will copy the original file to a temporary folder, so changing the file contents won't change the original data file.

  Both `datadir` and `shared_datadir` fixtures are `pathlib.Path` objects.



  Follow these steps to make a new release:

  1. Create a new branch `release-X.Y.Z` from `master`.
  2. Update `CHANGELOG.rst`.
  3. Open a PR.
  4. After it is **green** and **approved**, push a new tag in the format `X.Y.Z`.

  Travis will deploy to PyPI automatically.

  Afterwards, update the recipe in [conda-forge/pytest-datadir-feedstock](https://github.com/conda-forge/pytest-datadir-feedstock).



  MIT.


pkgId: d109ad3a48eed77ff4136e463fbd617f1b00083c7e6332bea533d6cc082edc5f
name: python-pytest-dependency
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Manage dependencies of tests
url: https://github.com/RKrahl/pytest-dependency
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-193f4900-c8e3-42b2-b62f-31121391d42c
location_href: 00010513-python-pytest-dependency/python-pytest-dependency-0.5.1-1.src.rpm
checksum_type: sha256
description:
  pytest-dependency - Manage dependencies of tests

  This pytest plugin manages dependencies of tests.  It allows to mark
  some tests as dependent from other tests.  These tests will then be
  skipped if any of the dependencies did fail or has been skipped.


pkgId: 6e115250d783c305e00ff4a5f456938c0c8f396d59a9a266b493d759f11ca701
name: python-pytest-describe
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Describe-style plugin for pytest
url: https://github.com/pytest-dev/pytest-describe
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e2b8beeb-379c-421f-8842-693b225aaca8
location_href: 00011799-python-pytest-describe/python-pytest-describe-2.1.0-1.src.rpm
checksum_type: sha256
description:
  pytest-describe is a plugin for pytest that allows tests to be written in
  arbitrary nested describe-blocks, similar to RSpec (Ruby) and Jasmine
  (JavaScript).
  The main inspiration for this was a `video
  <https://www.youtube.com/watch?v=JJle8L8FRy0>`_ by Gary Bernhardt.


pkgId: 3854a33eb8eda93d18059c7b4af65b5e67ed0604a81f66169d12516050d62f33
name: python-pytest-django
arch: src
version: 4.5.2
epoch: 0
release: 1
summary: A Django plugin for pytest.
url: https://pytest-django.readthedocs.io/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7cbfd647-465c-4a29-aeb7-7daeeddffd6e
location_href: 00004837-python-pytest-django/python-pytest-django-4.5.2-1.src.rpm
checksum_type: sha256
description:
  pytest-django allows you to test your Django project/applications with the
  `pytest testing tool <https://pytest.org/>`_.
  * `Quick start / tutorial
    <https://pytest-django.readthedocs.io/en/latest/tutorial.html>`_
  * `Changelog <https://pytest-django.readthedocs.io/en/latest/changelog.html>`_
  * Full documentation: https://pytest-django.readthedocs.io/en/latest/
  * `Contribution docs
    <https://pytest-django.readthedocs.io/en/latest/contributing.html>`_
  * Version compatibility:
    * Django: 2.2, 3.1, 3.2, 4.0 and latest main branch (compatible at the time of
      each release)
    * Python: CPython>=3.5 or PyPy 3
    * pytest: >=5.4
    For compatibility with older versions, use the pytest-django 3.*.* series.
  * Licence: BSD
  * Project maintainers: Andreas Pelme, Floris Bruynooghe and Daniel Hahler
  * `All contributors <https://github.com/pytest-dev/pytest-django/contributors>`_
  * GitHub repository: https://github.com/pytest-dev/pytest-django
  * `Issue tracker <http://github.com/pytest-dev/pytest-django/issues>`_
  * `Python Package Index (PyPI) <https://pypi.python.org/pypi/pytest-django/>`_


pkgId: 2e8ad6e3977b42908c6c6f3e85e4d3fbdbeb168a586047751ca9e7ba2c17b292
name: python-pytest-docker
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Simple pytest fixtures for Docker and docker-compose based tests
url: https://github.com/avast/pytest-docker
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eded9275-7d79-4ffd-bf0f-de6024157296
location_href: 00012758-python-pytest-docker/python-pytest-docker-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/pytest-docker?color=green)](https://pypi.org/project/pytest-docker/)
  [![Build Status](https://github.com/avast/pytest-docker/actions/workflows/tests.yaml/badge.svg?branch=master)](https://github.com/avast/pytest-docker/actions/workflows/tests.yaml)
  [![Python versions](https://img.shields.io/pypi/pyversions/pytest-docker)](https://pypi.org/project/pytest-docker/)
  [![Code style](https://img.shields.io/badge/formatted%20with-black-black)](https://github.com/psf/black)

  Simple [pytest](http://doc.pytest.org/) fixtures that help you write integration
  tests with Docker and [docker-compose](https://docs.docker.com/compose/).
  Specify all necessary containers in a `docker-compose.yml` file and and
  `pytest-docker` will spin them up for the duration of your tests.
  This package is tested with Python versions `3.6`, `3.7`, `3.8` and
  `3.9`, and `pytest` version 4, 5 and 6. Python 2 is not supported.
  `pytest-docker` was originally created by André Caron.

  Install `pytest-docker` with `pip` or add it to your test requirements. It is
  recommended to install `docker-compose` python package directly in your
  environment to ensure that it is available during tests. This will prevent
  potential dependency conflicts that can occur when the system wide
  `docker-compose` is used in tests.
  The default behavior is not to install `docker-compose` with `pytest-docker`. If you
  want to, you install `pytest-docker` with the `docker-compose-v1`
  extra. You can use the following command:
  ```
  pip install pytest-docker[docker-compose-v1]
  ```

  `pytest-docker` will work with Docker Compose v2 out of the box if
  [`compose-switch`](https://github.com/docker/compose-switch)
  is installed.
  If you want to use the real Docker Compose v2, it has to be installed
  system wide ([more information](https://github.com/docker/compose#linux))
  and you have to modify the [`docker-compose-command`](#docker_compose_command)
  fixture (this behavior might change in the future versions).

  Here is an example of a test that depends on a HTTP service.
  With a `docker-compose.yml` file like this (using the
  [httpbin](https://httpbin.org/) service):
  ```yaml
  version: '2'
  services:
    httpbin:
      image: "kennethreitz/httpbin"
      ports:
        - "8000:80"
  ```
  You can write a test like this:
  ```python
  import pytest
  import requests
  from requests.exceptions import ConnectionError
  def is_responsive(url):
      try:
          response = requests.get(url)
          if response.status_code == 200:
              return True
      except ConnectionError:
          return False
  @pytest.fixture(scope="session")
  def http_service(docker_ip, docker_services):
      """Ensure that HTTP service is up and responsive."""
      
      port = docker_services.port_for("httpbin", 80)
      url = "http://{}:{}".format(docker_ip, port)
      docker_services.wait_until_responsive(
          timeout=30.0, pause=0.1, check=lambda: is_responsive(url)
      )
      return url
  def test_status_code(http_service):
      status = 418
      response = requests.get(http_service + "/status/{}".format(status))
      assert response.status_code == status
  ```
  By default this plugin will try to open `docker-compose.yml` in your
  `tests` directory. If you need to use a custom location, override the
  `docker_compose_file` fixture inside your `conftest.py` file:
  ```python
  import os
  import pytest
  @pytest.fixture(scope="session")
  def docker_compose_file(pytestconfig):
      return os.path.join(str(pytestconfig.rootdir), "mycustomdir", "docker-compose.yml")
  ```

  All fixtures have `session` scope.

  Determine the IP address for TCP connections to Docker containers.

  Get an absolute path to the  `docker-compose.yml` file. Override this fixture in
  your tests if you need a custom location.

  Generate a project name using the current process PID. Override this fixture in
  your tests if you need a particular project name.

  Start all services from the docker compose file (`docker-compose up`).
  After test are finished, shutdown all services (`docker-compose down`).

  Docker Compose command to use to execute Dockers. Default is to use
  Docker Compose v1 (command is `docker-compose`). If you want to use
  Docker Compose v2, change this fixture to return `docker compose`.

  Get the docker_compose command to be executed for test spawn actions.
  Override this fixture in your tests if you need to change spawn actions.
  Returning anything that would evaluate to False will skip this command.

  Get the docker_compose command to be executed for test clean-up actions.
  Override this fixture in your tests if you need to change clean-up actions.
  Returning anything that would evaluate to False will skip this command.

  Use of a virtual environment is recommended. See the
  [venv](https://docs.python.org/3/library/venv.html) package for more
  information.
  First, install `pytest-docker` and its test dependencies:
  	pip install -e ".[tests]"
  Run tests with
  	pytest -c setup.cfg
  to make sure that the correct configuration is used. This is also how tests are
  run in CI.
  Use [black](https://pypi.org/project/black/) with default settings for
  formatting. You can also use `pylint` with `setup.cfg` as the configuration
  file.

  This pytest plug-in and its source code are made available to you under a MIT
  license. It is safe to use in commercial and closed-source applications. Read
  the license for details!
  Found a bug? Think a new feature would make this plug-in more practical? We
  welcome issues and pull requests!
  When creating a pull request, be sure to follow this projects conventions (see
  above).


pkgId: 46da8cc210edde41519322dfcefeeec02d2c43c24eb65a9c9257fe0ffffa1066
name: python-pytest-docker-compose
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: Manages Docker containers during your integration tests
url: https://github.com/pytest-docker-compose/pytest-docker-compose
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-393408b6-0050-4cd5-ae0d-8d06ffe70ced
location_href: 00012467-python-pytest-docker-compose/python-pytest-docker-compose-3.2.1-1.src.rpm
checksum_type: sha256
description:
  This package contains a `pytest`_ plugin for integrating Docker Compose into your automated integration tests.
  Given a path to a ``docker-compose.yml`` file, it will automatically build the project at the start of the test run, bring the containers up before each test starts, and tear them down after each test ends.


pkgId: 58d017095ab613166e57afa851b6dcb0be6162b88a3da42ae5407c5103f7a20e
name: python-pytest-dotenv
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: A py.test plugin that parses environment files before running tests
url: https://github.com/quiqua/pytest-dotenv
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5e200fe4-6e2a-4a74-a06b-5f26ce6e6bdb
location_href: 00010907-python-pytest-dotenv/python-pytest-dotenv-0.5.2-1.src.rpm
checksum_type: sha256
description:
  This little plugin uses `python-dotenv` to load any environment variables from a `.env` file. Extra configuration can be defined in any `pytest` config files, such as `pytest.ini`, `tox.ini` and so on.



  Install the plugin with `pip`:

  ```
  $ pip install pytest-dotenv
  ```



  If all you want is to load environment variables from a `.env` file then installing the plugin is all that is needed. `python-dotenv` will automatically detect your `.env` file and load it. By default, the plugin won't override any existing system variables.






  Add a new section to a config file named `env_vars`.
  You can list as many files as necessary:

  ```
  [pytest]
  env_files =
      .env
      .test.env
      .deploy.env
  ```

  The files will be loaded and added to the `os.environ` dict object before
  any tests are run. If the files are not found on the working directory, it will search for the files in the ancestor directory and upwards.



  By default the plugin will not override any variables already defined in the
  process' environment. If you want that behavior, you have to use the
  `env_override_existing_values` setting:

  ```
  [pytest]
  env_override_existing_values = 1
  env_files =
      .env
      .test.env
      .deploy.env
  ```



  You also have the option to run your tests with `py.test --envfile path/to/.env`.
  This will load all defined environment variables and overwrite any existing ones regardless of the configuration `env_override_existing_values`.


pkgId: 3d17aaf789ad164111c3cfc45e435c485fd702820bd1252609dc2388457d089c
name: python-pytest-error-for-skips
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Pytest plugin to treat skipped tests a test failure
url: https://github.com/jankatins/pytest-error-for-skips
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-51ee72fb-9f72-428b-b9b3-1dfb6c08595e
location_href: 00004839-python-pytest-error-for-skips/python-pytest-error-for-skips-2.0.2-1.src.rpm
checksum_type: sha256
description:
  [![See Build Status on Travis CI](https://travis-ci.org/jankatins/pytest-error-for-skips.svg?branch=master)](https://travis-ci.org/jankatins/pytest-error-for-skips)
  [![See Build Status on AppVeyor](https://ci.appveyor.com/api/projects/status/github/jankatins/pytest-error-for-skips?branch=master)](https://ci.appveyor.com/project/jankatins/pytest-error-for-skips/branch/master)
  [![Documentation Status](https://readthedocs.org/projects/pytest-plugin-to-treat-skipped-tests-as-errors/badge/?version=latest)](http://pytest-plugin-to-treat-skipped-tests-as-errors.readthedocs.io/en/latest/?badge=latest)
  [![PyPI Status](https://badge.fury.io/py/pytest-error-for-skips.svg)](https://badge.fury.io/py/pytest-error-for-skips)
  Pytest plugin to treat skipped tests a test failures.
  This is nice if you want to ensure that your CI tests really run all
  tests and don\'t skip tests because of missing dependencies.


pkgId: 6a86f11523f8c2cba3a573d84fff381547b5bff5676ef34c4f68835ba90792a3
name: python-pytest-flask
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A set of py.test fixtures to test Flask applications.
url: https://github.com/pytest-dev/pytest-flask
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b2ea79ac-a313-4006-8146-99da68fe3dc5
location_href: 00010660-python-pytest-flask/python-pytest-flask-1.2.0-1.src.rpm
checksum_type: sha256
description:
  An extension of `pytest`_ test runner which
  provides a set of useful tools to simplify testing and development
  of the Flask extensions and applications.
  To view a more detailed list of extension features and examples go to
  the `PyPI`_ overview page or
  `package documentation`_.


pkgId: e38ed2c997a19cfdb23f599db884f78f54e11b3f93bf6dd3ce23f38c0f686087
name: python-pytest-flask-sqlalchemy
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A pytest plugin for preserving test isolation in Flask-SQlAlchemy using database transactions.
url: https://github.com/jeancochrane/pytest-flask-sqlalchemy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-84c3cb3a-1712-4fdd-ab88-6034f86f4148
location_href: 00012805-python-pytest-flask-sqlalchemy/python-pytest-flask-sqlalchemy-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/jeancochrane/pytest-flask-sqlalchemy.svg?branch=master)](https://travis-ci.org/jeancochrane/pytest-flask-sqlalchemy) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/Django.svg)

  A [pytest](https://docs.pytest.org/en/latest/) plugin providing fixtures for running tests in
  transactions using [Flask-SQLAlchemy](http://flask-sqlalchemy.pocoo.org/latest/).



  - [**Motivation**](#motivation)
  - [**Quick examples**](#quick-examples)
  - [**Usage**](#usage)
      - [Installation](#installation)
          - [From PyPi](#from-pypi)
          - [Development version](#development-version)
          - [Supported backends](#supported-backends)
      - [Configuration](#configuration)
          - [Conftest setup](#conftest-setup)
          - [Test configuration](#test-configuration)
              - [`mocked-engines`](#mocked-engines)
              - [`mocked-sessions`](#mocked-sessions)
              - [`mocked-sessionmakers`](#mocked-sessionmakers)
          - [Writing transactional tests](#writing-transactional-tests)
      - [Fixtures](#fixtures)
          - [`db_session`](#db_session)
          - [`db_engine`](#db_engine)
      - [Enabling transactions without fixtures](#enabling-transactions-without-fixtures)
  - [**Development**](#development)
      - [Running the tests](#running-the-tests)
      - [Acknowledgements](#acknowledgements)
      - [Copyright](#copyright)



  Inspired by [Django's built-in support for transactional
  tests](https://jeancochrane.com/blog/django-test-transactions), this plugin
  seeks to provide comprehensive, easy-to-use Pytest fixtures for wrapping tests in
  database transactions for [Flask-SQLAlchemy](http://flask-sqlalchemy.pocoo.org/latest/)
  apps. The goal is to make testing stateful Flask-SQLAlchemy applications easier by
  providing fixtures that permit the developer to **make arbitrary database updates
  with the confidence that any changes made during a test will roll back** once the test exits.



  Use the [`db_session` fixture](#db_session) to make **database updates that won't persist beyond
  the body of the test**:

  ```python
  def test_a_transaction(db_session):
     row = db_session.query(Table).get(1)
     row.name = 'testing'

     db_session.add(row)
     db_session.commit()

  def test_transaction_doesnt_persist(db_session):
     row = db_session.query(Table).get(1)
     assert row.name != 'testing'
  ```

  The [`db_engine` fixture](#db_engine) works the same way, but **copies the API of
  SQLAlchemy's [Engine
  object](http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.Engine)**:

  ```python
  def test_a_transaction_using_engine(db_engine):
      with db_engine.begin() as conn:
          row = conn.execute('''UPDATE table SET name = 'testing' WHERE id = 1''')

  def test_transaction_doesnt_persist(db_engine):
      row_name = db_engine.execute('''SELECT name FROM table WHERE id = 1''').fetchone()[0]
      assert row_name != 'testing'
  ```

  Use [configuration properties](#test-configuration) to
  **mock database connections in an app and enforce nested transactions**,
  allowing any method from the codebase to run inside a test with the assurance
  that any database changes made will be rolled back at the end of the test:

  ```ini


  [tool:pytest]
  mocked-sessions=database.db.session
  mocked-engines=database.engine
  ```

  ```python


  db = flask_sqlalchemy.SQLAlchemy()
  engine = sqlalchemy.create_engine('DATABASE_URI')
  ```

  ```python


  class Table(db.Model):
      __tablename__ = 'table'
      id = db.Column(db.Integer, primary_key=True)
      name = db.Column(db.String(80))

      def set_name(new_name):
          self.name = new_name
          db.session.add(self)
          db.session.commit()
  ```

  ```python


  def test_set_name(db_session):
      row = db_session.query(Table).get(1)
      row.set_name('testing')
      assert row.name == 'testing'

  def test_transaction_doesnt_persist(db_session):
     row = db_session.query(Table).get(1)
     assert row.name != 'testing'
  ```







  Install using pip:

  ```
  pip install pytest-flask-sqlalchemy
  ```

  Once installed, pytest will detect the plugin automatically during test collection.
  For basic background on using third-party plugins with pytest, see the [pytest
  documentation](https://docs.pytest.org/en/latest/plugins.html?highlight=plugins).



  Clone the repo from GitHub and switch into the new directory:

  ```
  git clone git@github.com:jeancochrane/pytest-flask-sqlalchemy.git
  cd pytest-flask-sqlalchemy
  ```

  You can install using pip:

  ```
  pip install .
  ```



  So far, pytest-flask-sqlalchemy has been most extensively tested against
  PostgreSQL 9.6. It should theoretically work with any backend that is supported
  by SQLAlchemy, but Postgres is the only backend that is currently tested by the
  test suite.

  Official support for SQLite and MySQL is [planned for a future
  release](https://github.com/jeancochrane/pytest-flask-sqlalchemy/issues/3).
  In the meantime, if you're using one of those backends and you run in to
  problems, we would greatly appreciate your help! [Open an
  issue](https://github.com/jeancochrane/pytest-flask-sqlalchemy/issues/new) if
  something isn't working as you expect.





  This plugin assumes that a fixture called `_db` has been
  defined in the root conftest file for your tests. The `_db` fixture should
  expose access to a valid [SQLAlchemy `Session` object](http://docs.sqlalchemy.org/en/latest/orm/session_api.html?highlight=session#sqlalchemy.orm.session.Session) that can interact with your database,
  for example via the [`SQLAlchemy` initialization class](http://flask-sqlalchemy.pocoo.org/2.3/api/#flask_sqlalchemy.SQLAlchemy)
  that configures Flask-SQLAlchemy.

  The fixtures in this plugin depend on this `_db` fixture to access your
  database and create nested transactions to run tests in. **You must define
  this fixture in your `conftest.py` file for the plugin to work.**

  An example setup that will produce a valid `_db` fixture could look like this
  (this example comes from the [test setup](./tests/_conftest.py#L25-L61) for this repo):

  ```python
  @pytest.fixture(scope='session')
  def database(request):
      '''
      Create a Postgres database for the tests, and drop it when the tests are done.
      '''
      pg_host = DB_OPTS.get("host")
      pg_port = DB_OPTS.get("port")
      pg_user = DB_OPTS.get("username")
      pg_db = DB_OPTS["database"]

      init_postgresql_database(pg_user, pg_host, pg_port, pg_db)

      @request.addfinalizer
      def drop_database():
          drop_postgresql_database(pg_user, pg_host, pg_port, pg_db, 9.6)


  @pytest.fixture(scope='session')
  def app(database):
      '''
      Create a Flask app context for the tests.
      '''
      app = Flask(__name__)

      app.config['SQLALCHEMY_DATABASE_URI'] = DB_CONN

      return app


  @pytest.fixture(scope='session')
  def _db(app):
      '''
      Provide the transactional fixtures with access to the database via a Flask-SQLAlchemy
      database connection.
      '''
      db = SQLAlchemy(app=app)

      return db
  ```

  Alternatively, if you already have a fixture that sets up database access for
  your tests, you can define `_db` to return that fixture directly:

  ```python
  @pytest.fixture(scope='session')
  def database():
      
      
      return db

  @pytest.fixture(scope='session')
  def _db(database):
      return database
  ```



  This plugin allows you to configure a few different properties in a
  `setup.cfg` test configuration file in order to handle the specific database connection needs
  of your app. For basic background on setting up pytest configuration files, see
  the [pytest docs](https://docs.pytest.org/en/latest/customize.html#adding-default-options).

  All three configuration properties ([`mocked-engines`](#mocked-engines),
  [`mocked-sessions`](#mocked-sessions), and [`mocked-sessionmakers`](#mocked-sessionmakers))
  work by **[patching](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.patch)
  one or more specified objects during a test**, replacing them with equivalent objects whose
  database interactions will run inside of a transaction and ultimately be
  rolled back when the test exits. Using these patches, you can call methods from
  your codebase that alter database state with the knowledge that no changes will persist
  beyond the body of the test.

  The configured patches are only applied in tests where a transactional fixture
  (either [`db_session`](#db_session) or [`db_engine`](#db_engine)) is included
  in the test function arguments.



  The `mocked-engines` property directs the plugin to [patch](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.patch)
  objects in your codebase, typically SQLAlchemy [Engine](http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.Engine)
  instances, replacing them with the [`db_engine` fixture](#db_engine) such that
  any database updates performed by the objects get rolled back at the end of
  the test.

  The value for this property should be formatted as a whitespace-separated list
  of standard Python import paths, like `database.engine`. This property is **optional**.

  Example:

  ```python


  engine = sqlalchemy.create_engine(DATABASE_URI)
  ```

  ```ini


  [tool:pytest]
  mocked-engines=database.engine
  ```

  To patch multiple objects at once, separate the paths with a whitespace:

  ```ini


  [tool:pytest]
  mocked-engines=database.engine database.second_engine
  ```



  The `mocked-sessions` property directs the plugin to [patch](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.patch)
  objects in your codebase, typically SQLAlchemy [Session](http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.Engine)
  instances, replacing them with the [`db_session`](#db_session) fixture such that
  any database updates performed by the objects get rolled back at the end of
  the test.

  The value for this property should be formatted as a whitespace-separated list
  of standard Python import paths, like `database.db.session`. This property is **optional**.

  Example:

  ```python


  db = SQLAlchemy()
  ```

  ```ini


  [tool:pytest]
  mocked-sessions=database.db.session
  ```

  To patch multiple objects at once, separate the paths with a whitespace:

  ```ini


  [tool:pytest]
  mocked-sessions=database.db.session database.second_db.session
  ```



  The `mocked-sessionmakers` property directs the plugin to [patch](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.patch)
  objects in your codebase, typically instances of [SQLAlchemy's `sessionmaker`
  factory](http://docs.sqlalchemy.org/en/latest/orm/session_api.html?highlight=sessionmaker#sqlalchemy.orm.session.sessionmaker),
  replacing them with a mocked class that will return the transactional
  [`db_session`](#db_session) fixture. This can be useful if you have
  pre-configured instances of sessionmaker objects that you import in the code
  to spin up sessions on the fly.

  The value for this property should be formatted as a whitespace-separated list
  of standard Python import paths, like `database.WorkerSessionmaker`. This property is **optional**.

  Example:

  ```python


  WorkerSessionmaker = sessionmaker()
  ```

  ```ini
  [tool:pytest]
  mocked-sessionmakers=database.WorkerSessionmaker
  ```

  To patch multiple objects at once, separate the paths with a whitespace.

  ```ini
  [tool:pytest]
  mocked-sessionmakers=database.WorkerSessionmaker database.SecondWorkerSessionmaker
  ```



  Once you have your [conftest file set up](#conftest-setup) and you've [overrided the
  necessary connectables in your test configuration](#test-configuration), you're ready
  to write some transactional tests. Simply import one of the module's [transactional
  fixtures](#fixtures) in your test signature, and the test will be wrapped in a transaction.

  Note that by default, **tests are only wrapped in transactions if they import one of
  the [transactional fixtures](#fixtures) provided by this module.** Tests that do not
  import the fixture will interact with your database without opening a transaction:

  ```python

  def transactional_test(db_session):
      ...



  def non_transactional_test():
      ...
  ```

  The fixtures provide a way for you to control which tests require transactions and
  which don't. This is often useful, since avoiding transaction setup can speed up
  tests that don't interact with your database.

  For more information about the transactional fixtures provided by this module, read on
  to the [fixtures section](#fixtures). For guidance on how to automatically enable
  transactions without having to specify fixtures, see the section on [enabling transactions
  without fixtures](#enabling-transactions-without-fixtures).



  This plugin provides two fixtures for performing database updates inside nested
  transactions that get rolled back at the end of a test: [`db_session`](#db_session) and
  [`db_engine`](#db_engine). The fixtures provide similar functionality, but
  with different APIs.



  The `db_session` fixture allows you to perform direct updates that will be
  rolled back when the test exits. It exposes the same API as [SQLAlchemy's
  `scoped_session` object](http://docs.sqlalchemy.org/en/latest/orm/contextual.html#sqlalchemy.orm.scoping.scoped_session).

  Including this fixture as a function argument of a test will activate any mocks that are defined
  by the configuration properties [`mocked-engines`](#mocked-engines), [`mocked-sessions`](#mocked-sessions),
  or [`mocked-sessionmakers`](#mocked-sessionmakers) in the test configuration file for
  the duration of that test.

  Example:

  ```python
  def test_a_transaction(db_session):
     row = db_session.query(Table).get(1)
     row.name = 'testing'

     db_session.add(row)
     db_session.commit()

  def test_transaction_doesnt_persist(db_session):
     row = db_session.query(Table).get(1)
     assert row.name != 'testing'
  ```



  Like [`db_session`](#db_session), the `db_engine` fixture allows you to perform direct updates
  against the test database that will be rolled back when the test exits. It is
  an instance of Python's built-in [`MagicMock`](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.MagicMock)
  class, with a spec set to match the API of [SQLAlchemy's
  `Engine`](http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.Engine) object.

  Only a few `Engine` methods are exposed on this fixture:

  - `db_engine.begin`: begin a new nested transaction ([API docs](http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.Engine.begin))
  - `db_engine.execute`: execute a raw SQL query ([API docs](http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.Engine.execute))
  - `db_engine.raw_connection`: return a raw DBAPI connection ([API docs](http://docs.sqlalchemy.org/en/latest/core/connections.html#sqlalchemy.engine.Engine.raw_connection))

  Since `db_engine` is an instance of `MagicMock` with an `Engine` spec, other
  methods of the `Engine` API can be called, but they will not perform any useful
  work.

  Including this fixture as a function argument of a test will activate any mocks that are defined
  by the configuration properties [`mocked-engines`](#mocked-engines), [`mocked-sessions`](#mocked-sessions),
  or [`mocked-sessionmakers`](#mocked-sessionmakers) in the test configuration file for
  the duration of that test.

  Example:

  ```python
  def test_a_transaction_using_engine(db_engine):
      with db_engine.begin() as conn:
          row = conn.execute('''UPDATE table SET name = 'testing' WHERE id = 1''')

  def test_transaction_doesnt_persist(db_engine):
      row_name = db_engine.execute('''SELECT name FROM table WHERE id = 1''').fetchone()[0]
      assert row_name != 'testing'
  ```



  If you know you want to make all of your tests transactional, it can be annoying to have
  to specify one of the [fixtures](#fixtures) in every test signature.

  The best way to automatically enable transactions without having to include an extra fixture
  in every test is to wire up an
  [autouse fixture](https://docs.pytest.org/en/latest/fixture.html#autouse-fixtures-xunit-setup-on-steroids)
  for your test suite. This can be as simple as:

  ```python

  @pytest.fixture(autouse=True)
  def enable_transactional_tests(db_session):
      pass
  ```

  In this configuration, the `enable_transactional_tests` fixture will be automatically used in
  all tests, meaning that `db_session` will also be used. This way, all tests will be wrapped
  in transactions without having to explicitly require either `db_session` or `enable_transactional_tests`.





  To run the tests, start by installing a development version of the plugin that
  includes test dependencies:

  ```
  pip install -e .[tests]
  ```

  Next, export a [database connection string](http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls)
  that the tests can use (the database referenced by the string will be created
  during test setup, so it does not need to exist):

  ```
  export TEST_DATABASE_URL=<db_connection_string>
  ```

  Finally, run the tests using pytest:

  ```
  pytest
  ```



  This plugin was initially developed for testing
  [Dedupe.io](https://dedupe.io), a web app for record linkage and entity
  resolution using machine learning. Dedupe.io is built and maintained
  by [DataMade](https://datamade.us).

  The code is greatly indebted to [Alex Michael](https://github.com/alexmic),
  whose blog post ["Delightful testing with pytest and
  Flask-SQLAlchemy"](http://alexmic.net/flask-sqlalchemy-pytest/) helped
  establish the basic approach on which this plugin builds.

  Many thanks to [Igor Ghisi](https://github.com/igortg/), who donated the PyPi
  package name. Igor had been working on a similar plugin and proposed combining
  efforts. Thanks to Igor, the plugin name is much stronger.



  Copyright (c) 2019 Jean Cochrane and DataMade. Released under the MIT License.

  Third-party copyright in this distribution is noted where applicable.


pkgId: fb714640d89a81c288d1a8a16046e21a728c4ca2f5f650842cd26195e8dd9920
name: python-pytest-forked
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: run tests in isolated forked subprocesses
url: https://github.com/pytest-dev/pytest-forked
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2c4f33d9-0154-4e23-9e9c-a9b9b01dc730
location_href: 00009186-python-pytest-forked/python-pytest-forked-1.6.0-1.src.rpm
checksum_type: sha256
description:
  	this is a extraction of the xdist --forked module,
  	future maintenance beyond the bare minimum is not planned until a new maintainer is found.
  This plugin **does not work on Windows** because there's no ``fork`` support.
  * ``--forked``: run each test in a forked
    subprocess to survive ``SEGFAULTS`` or otherwise dying processes.
  |python| |version| |ci| |pre-commit| |black|


pkgId: cea3eda38d3b0ec914b4038b51efb9951f9da42dbad91b52f22f2773fc48963b
name: python-pytest-github-actions-annotate-failures
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: pytest plugin to annotate failed tests with a workflow command for GitHub Actions
url: https://github.com/pytest-dev/pytest-github-actions-annotate-failures
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc138217-85f7-46e9-8adc-487259a67f3a
checksum_type: sha256
description:
  [Pytest](https://pypi.org/project/pytest/) plugin to annotate failed tests with a [workflow command for GitHub Actions](https://help.github.com/en/actions/reference/workflow-commands-for-github-actions)


  Just install and run pytest with this plugin in your workflow. For example,

  ```yaml
  name: test

  on:
    push:

  jobs:
    test:
      runs-on: ubuntu-latest

      steps:
      - uses: actions/checkout@v3

      - uses: actions/setup-python@v4
        with:
          python-version: 3.7

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Install plugin
        run: pip install pytest-github-actions-annotate-failures

      - run: pytest
  ```

  If your test is running in a Docker container, you have to install this plugin and manually set `GITHUB_ACTIONS` environment variable to `true` inside of Docker container. (For example, `docker-compose run --rm -e GITHUB_ACTIONS=true app -- pytest`)

  If your tests are run from a subdirectory of the git repository, you have to set the `PYTEST_RUN_PATH` environment variable to the path of that directory relative to the repository root in order for GitHub to identify the files with errors correctly.


  [![Image from Gyazo](https://i.gyazo.com/b578304465dd1b755ceb0e04692a57d9.png)](https://gyazo.com/b578304465dd1b755ceb0e04692a57d9)

location_href:
  00012099-python-pytest-github-actions-annotate-failures/python-pytest-github-actions-annotate-failures-0.1.8-1.src.rpm


pkgId: 6a0424527015e7020c4ffe86b4b5d138742777cec79efa159aa1a2749cd945e5
name: python-pytest-github-actions-annotate-failures-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for pytest-github-actions-annotate-failures
url: https://github.com/pytest-dev/pytest-github-actions-annotate-failures
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc138217-85f7-46e9-8adc-487259a67f3a
rpm_sourcerpm: python-pytest-github-actions-annotate-failures-0.1.8-1.src.rpm
checksum_type: sha256
description:
  [Pytest](https://pypi.org/project/pytest/) plugin to annotate failed tests with a [workflow command for GitHub Actions](https://help.github.com/en/actions/reference/workflow-commands-for-github-actions)


  Just install and run pytest with this plugin in your workflow. For example,

  ```yaml
  name: test

  on:
    push:

  jobs:
    test:
      runs-on: ubuntu-latest

      steps:
      - uses: actions/checkout@v3

      - uses: actions/setup-python@v4
        with:
          python-version: 3.7

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Install plugin
        run: pip install pytest-github-actions-annotate-failures

      - run: pytest
  ```

  If your test is running in a Docker container, you have to install this plugin and manually set `GITHUB_ACTIONS` environment variable to `true` inside of Docker container. (For example, `docker-compose run --rm -e GITHUB_ACTIONS=true app -- pytest`)

  If your tests are run from a subdirectory of the git repository, you have to set the `PYTEST_RUN_PATH` environment variable to the path of that directory relative to the repository root in order for GitHub to identify the files with errors correctly.


  [![Image from Gyazo](https://i.gyazo.com/b578304465dd1b755ceb0e04692a57d9.png)](https://gyazo.com/b578304465dd1b755ceb0e04692a57d9)

location_href:
  00012099-python-pytest-github-actions-annotate-failures/python-pytest-github-actions-annotate-failures-help-0.1.8-1.noarch.rpm


pkgId: 942aca3d58d3d3c96017d8cc1a8dab7c6d0c0304a2a59922710416f3e286da15
name: python-pytest-harvest
arch: src
version: 1.10.4
epoch: 0
release: 1
url: https://github.com/smarie/python-pytest-harvest
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-40e6553e-38a0-491c-9ba1-7a208447fe9c
location_href: 00004843-python-pytest-harvest/python-pytest-harvest-1.10.4-1.src.rpm
checksum_type: sha256
summary:
  Store data created during your pytest tests execution, and retrieve it at the end of the session, e.g. for applicative benchmarking purposes.

description:
  [![Python versions](https://img.shields.io/pypi/pyversions/pytest-harvest.svg)](https://pypi.python.org/pypi/pytest-harvest/) [![Build Status](https://github.com/smarie/python-pytest-harvest/actions/workflows/base.yml/badge.svg)](https://github.com/smarie/python-pytest-harvest/actions/workflows/base.yml) [![Tests Status](https://smarie.github.io/python-pytest-harvest/reports/junit/junit-badge.svg?dummy=8484744)](https://smarie.github.io/python-pytest-harvest/reports/junit/report.html) [![codecov](https://codecov.io/gh/smarie/python-pytest-harvest/branch/master/graph/badge.svg)](https://codecov.io/gh/smarie/python-pytest-harvest)

  [![Documentation](https://img.shields.io/badge/doc-latest-blue.svg)](https://smarie.github.io/python-pytest-harvest/) [![PyPI](https://img.shields.io/pypi/v/pytest-harvest.svg)](https://pypi.python.org/pypi/pytest-harvest/) [![Downloads](https://pepy.tech/badge/pytest-harvest)](https://pepy.tech/project/pytest-harvest) [![Downloads per week](https://pepy.tech/badge/pytest-harvest/week)](https://pepy.tech/project/pytest-harvest) [![GitHub stars](https://img.shields.io/github/stars/smarie/python-pytest-harvest.svg)](https://github.com/smarie/python-pytest-harvest/stargazers)

  Store data created during your `pytest` tests execution, and retrieve it at the end of the session, e.g. for applicative benchmarking purposes.

  The documentation for users is available here: [https://smarie.github.io/python-pytest-harvest/](https://smarie.github.io/python-pytest-harvest/)

  A readme for developers is available here: [https://github.com/smarie/python-pytest-harvest](https://github.com/smarie/python-pytest-harvest)


pkgId: ffab60508f59261cc91401e6548f6bdf45fc907cdb2ff3ef02a2ab0a77dded78
name: python-pytest-helpers-namespace
arch: src
version: 2021.12.29
epoch: 0
release: 1
summary: Pytest Helpers Namespace Plugin
url: https://github.com/saltstack/pytest-helpers-namespace
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-73306531-e9be-454c-9c85-afe3738fe80c
location_href: 00004844-python-pytest-helpers-namespace/python-pytest-helpers-namespace-2021.12.29-1.src.rpm
checksum_type: sha256
description:
  This plugin does not provide any helpers to `pytest`_, it does, however,
  provide a helpers namespace in `pytest`_ which enables you to register helper
  functions in your ``conftest.py`` to be used within your tests without having
  to import them.


pkgId: 2d5789de179aafda88a372ab60030a6360ae5db0eaee6a692467731f2acaad1d
name: python-pytest-helpers-namespace-help
arch: noarch
version: 2021.12.29
epoch: 0
release: 1
summary: Development documents and examples for pytest-helpers-namespace
url: https://github.com/saltstack/pytest-helpers-namespace
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-73306531-e9be-454c-9c85-afe3738fe80c
rpm_sourcerpm: python-pytest-helpers-namespace-2021.12.29-1.src.rpm
checksum_type: sha256
description:
  This plugin does not provide any helpers to `pytest`_, it does, however,
  provide a helpers namespace in `pytest`_ which enables you to register helper
  functions in your ``conftest.py`` to be used within your tests without having
  to import them.

location_href:
  00004844-python-pytest-helpers-namespace/python-pytest-helpers-namespace-help-2021.12.29-1.noarch.rpm


pkgId: 34f0fe96148c36e7cdcdc0dabef97caeba6db262eb3d2699a578648a85f199b3
name: python-pytest-helpers-namespace-help
arch: noarch
version: 2021.12.29
epoch: 0
release: 1
summary: Development documents and examples for pytest-helpers-namespace
url: https://github.com/saltstack/pytest-helpers-namespace
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a14c4d20-d179-42ac-8ab9-0183ad8a6bbe
rpm_sourcerpm: python-pytest-helpers-namespace-2021.12.29-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 244 characters]

location_href:
  00008179-python-pytest-helpers-namespace/python-pytest-helpers-namespace-help-2021.12.29-1.noarch.rpm


pkgId: eeb317854cd36cc28cbdaf3804daaebd8f590247aba4951784bf6cb27cfa6d93
name: python-pytest-html
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: pytest plugin for generating HTML reports
url: https://github.com/pytest-dev/pytest-html
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ff46f9f1-c0d0-4c6b-8901-c589f8b0032f
location_href: 00009484-python-pytest-html/python-pytest-html-3.2.0-1.src.rpm
checksum_type: sha256
description:
  pytest-html is a plugin for `pytest <http://pytest.org>`_ that generates a HTML report for test results.


pkgId: a92d7acf74fc09440f46ecc2d192a780bcbcdf744602397a5cca95f0e1ac0ba2
name: python-pytest-httpbin
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Easily test your HTTP library against a local copy of httpbin
url: https://github.com/kevin1024/pytest-httpbin
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02a7dfa6-bd1d-4a9b-8b7d-6f35f670b836
location_href: 00004845-python-pytest-httpbin/python-pytest-httpbin-1.0.2-1.src.rpm
checksum_type: sha256
description:
  httpbin is an amazing web service for testing HTTP libraries. It has several
  great endpoints that can test pretty much everything you need in a HTTP
  library. The only problem is: maybe you don't want to wait for your tests to
  travel across the Internet and back to make assertions against a remote web
  service.
  Enter pytest-httpbin. Pytest-httpbin creates a pytest "fixture" that is
  dependency-injected into your tests. It automatically starts up a HTTP server
  in a separate thread running httpbin and provides your test with the URL in the
  fixture. Check out this example:
      def test_that_my_library_works_kinda_ok(httpbin):
          assert requests.get(httpbin.url + '/get/').status_code == 200
  This replaces a test that might have looked like this before:
      def test_that_my_library_works_kinda_ok():
          assert requests.get('http://httpbin.org/get').status_code == 200
  pytest-httpbin also supports https and includes its own CA cert you can use.
  Check out `the full documentation`_ on the github page.


pkgId: c74d1b20b78ff2f9322da1b1a20ffc47125e4e65930790a38db7070ac661ba18
name: python-pytest-httpx
arch: src
version: 0.21.3
epoch: 0
release: 1
summary: Send responses to httpx.
url: https://colin-b.github.io/pytest_httpx/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0425c58e-916f-4c2e-a2ae-10a7ac4a8176
location_href: 00004846-python-pytest-httpx/python-pytest-httpx-0.21.3-1.src.rpm
checksum_type: sha256
description:
  <h2 align="center">Send responses to HTTPX using pytest</h2>

  <p align="center">
  <a href="https://pypi.org/project/pytest-httpx/"><img alt="pypi version" src="https://img.shields.io/pypi/v/pytest_httpx"></a>
  <a href="https://github.com/Colin-b/pytest_httpx/actions"><img alt="Build status" src="https://github.com/Colin-b/pytest_httpx/workflows/Release/badge.svg"></a>
  <a href="https://github.com/Colin-b/pytest_httpx/actions"><img alt="Coverage" src="https://img.shields.io/badge/coverage-100%25-brightgreen"></a>
  <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  <a href="https://github.com/Colin-b/pytest_httpx/actions"><img alt="Number of tests" src="https://img.shields.io/badge/tests-168 passed-blue"></a>
  <a href="https://pypi.org/project/pytest-httpx/"><img alt="Number of downloads" src="https://img.shields.io/pypi/dm/pytest_httpx"></a>
  </p>

  > Version 1.0.0 will be released once httpx is considered as stable (release of 1.0.0).
  >
  > However, current state can be considered as stable.

  Once installed, `httpx_mock` [`pytest`](https://docs.pytest.org/en/latest/) fixture will make sure every [`httpx`](https://www.python-httpx.org) request will be replied to with user provided responses.

  - [Add responses](#add-responses)
    - [JSON body](#add-json-response)
    - [Custom body](#reply-with-custom-body)
    - [Multipart body (files, ...)](#add-multipart-response)
    - [HTTP status code](#add-non-200-response)
    - [HTTP headers](#reply-with-custom-headers)
    - [HTTP/2.0](#add-http/2.0-response)
  - [Add dynamic responses](#dynamic-responses)
  - [Raising exceptions](#raising-exceptions)
  - [Check requests](#check-sent-requests)
  - [Do not mock some requests](#do-not-mock-some-requests)
  - [Migrating](#migrating-to-pytest-httpx)
    - [responses](#from-responses)
    - [aioresponses](#from-aioresponses)



  You can register responses for both sync and async [`HTTPX`](https://www.python-httpx.org) requests.

  ```python
  import pytest
  import httpx


  def test_something(httpx_mock):
      httpx_mock.add_response()

      with httpx.Client() as client:
          response = client.get("https://test_url")


  @pytest.mark.asyncio
  async def test_something_async(httpx_mock):
      httpx_mock.add_response()

      async with httpx.AsyncClient() as client:
          response = await client.get("https://test_url")
  ```

  If all registered responses are not sent back during test execution, the test case will fail at teardown.

  This behavior can be disabled thanks to the `assert_all_responses_were_requested` fixture:

  ```python
  import pytest

  @pytest.fixture
  def assert_all_responses_were_requested() -> bool:
      return False
  ```

  Default response is a HTTP/1.1 200 (OK) without any body.



  In case more than one response match request, the first one not yet sent (according to the registration order) will be sent.

  In case all matching responses have been sent, the last one (according to the registration order) will be sent.

  You can add criteria so that response will be sent only in case of a more specific matching.



  `url` parameter can either be a string, a python [re.Pattern](https://docs.python.org/3/library/re.html) instance or a [httpx.URL](https://www.python-httpx.org/api/#url) instance.

  Matching is performed on the full URL, query parameters included.

  Order of parameters in the query string does not matter, however order of values do matter if the same parameter is provided more than once.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_url(httpx_mock: HTTPXMock):
      httpx_mock.add_response(url="https://test_url?a=1&b=2")

      with httpx.Client() as client:
          response1 = client.delete("https://test_url?a=1&b=2")
          response2 = client.get("https://test_url?b=2&a=1")
  ```



  Use `method` parameter to specify the HTTP method (POST, PUT, DELETE, PATCH, HEAD) to reply to.

  `method` parameter must be a string. It will be upper-cased, so it can be provided lower cased.

  Matching is performed on equality.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_post(httpx_mock: HTTPXMock):
      httpx_mock.add_response(method="POST")

      with httpx.Client() as client:
          response = client.post("https://test_url")


  def test_put(httpx_mock: HTTPXMock):
      httpx_mock.add_response(method="PUT")

      with httpx.Client() as client:
          response = client.put("https://test_url")


  def test_delete(httpx_mock: HTTPXMock):
      httpx_mock.add_response(method="DELETE")

      with httpx.Client() as client:
          response = client.delete("https://test_url")


  def test_patch(httpx_mock: HTTPXMock):
      httpx_mock.add_response(method="PATCH")

      with httpx.Client() as client:
          response = client.patch("https://test_url")


  def test_head(httpx_mock: HTTPXMock):
      httpx_mock.add_response(method="HEAD")

      with httpx.Client() as client:
          response = client.head("https://test_url")

  ```



  Use `match_headers` parameter to specify the HTTP headers to reply to.

  Matching is performed on equality for each provided header.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_headers_matching(httpx_mock: HTTPXMock):
      httpx_mock.add_response(match_headers={'user-agent': 'python-httpx/0.23.0'})

      with httpx.Client() as client:
          response = client.get("https://test_url")
  ```



  Use `match_content` parameter to specify the full HTTP body to reply to.

  Matching is performed on equality.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_content_matching(httpx_mock: HTTPXMock):
      httpx_mock.add_response(match_content=b"This is the body")

      with httpx.Client() as client:
          response = client.post("https://test_url", content=b"This is the body")
  ```



  Use `json` parameter to add a JSON response using python values.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_json(httpx_mock: HTTPXMock):
      httpx_mock.add_response(json=[{"key1": "value1", "key2": "value2"}])

      with httpx.Client() as client:
          assert client.get("https://test_url").json() == [{"key1": "value1", "key2": "value2"}]

  ```

  Note that the `content-type` header will be set to `application/json` by default in the response.



  Use `text` parameter to reply with a custom body by providing UTF-8 encoded string.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_str_body(httpx_mock: HTTPXMock):
      httpx_mock.add_response(text="This is my UTF-8 content")

      with httpx.Client() as client:
          assert client.get("https://test_url").text == "This is my UTF-8 content"

  ```

  Use `content` parameter to reply with a custom body by providing bytes.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_bytes_body(httpx_mock: HTTPXMock):
      httpx_mock.add_response(content=b"This is my bytes content")

      with httpx.Client() as client:
          assert client.get("https://test_url").content == b"This is my bytes content"

  ```

  Use `html` parameter to reply with a custom body by providing UTF-8 encoded string.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_html_body(httpx_mock: HTTPXMock):
      httpx_mock.add_response(html="<body>This is <p> HTML content</body>")

      with httpx.Client() as client:
          assert client.get("https://test_url").text == "<body>This is <p> HTML content</body>"

  ```



  Use `stream` parameter to stream chunks that you specify.

  ```python
  import httpx
  import pytest
  from pytest_httpx import HTTPXMock, IteratorStream

  def test_sync_streaming(httpx_mock: HTTPXMock):
      httpx_mock.add_response(stream=IteratorStream([b"part 1", b"part 2"]))

      with httpx.Client() as client:
          with client.stream(method="GET", url="https://test_url") as response:
              assert list(response.iter_raw()) == [b"part 1", b"part 2"]


  @pytest.mark.asyncio
  async def test_async_streaming(httpx_mock: HTTPXMock):
      httpx_mock.add_response(stream=IteratorStream([b"part 1", b"part 2"]))

      async with httpx.AsyncClient() as client:
          async with client.stream(method="GET", url="https://test_url") as response:
              assert [part async for part in response.aiter_raw()] == [b"part 1", b"part 2"]

  ```



  Use the httpx `MultipartStream` via the `stream` parameter to send a multipart response.

  Reach out to `httpx` developers if you need this publicly exposed as [this is not a standard use case](https://github.com/encode/httpx/issues/872#issuecomment-633584819).

  ```python
  import httpx
  from httpx._multipart import MultipartStream
  from pytest_httpx import HTTPXMock


  def test_multipart_body(httpx_mock: HTTPXMock):
      httpx_mock.add_response(stream=MultipartStream(data={"key1": "value1"}, files={"file1": b"content of file 1"}, boundary=b"2256d3a36d2a61a1eba35a22bee5c74a"))

      with httpx.Client() as client:
          assert client.get("https://test_url").text == '''--2256d3a36d2a61a1eba35a22bee5c74a\r
  Content-Disposition: form-data; name="key1"\r
  \r
  value1\r
  --2256d3a36d2a61a1eba35a22bee5c74a\r
  Content-Disposition: form-data; name="file1"; filename="upload"\r
  Content-Type: application/octet-stream\r
  \r
  content of file 1\r
  --2256d3a36d2a61a1eba35a22bee5c74a--\r
  '''

  ```



  Use `status_code` parameter to specify the HTTP status code of the response.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_status_code(httpx_mock: HTTPXMock):
      httpx_mock.add_response(status_code=404)

      with httpx.Client() as client:
          assert client.get("https://test_url").status_code == 404

  ```



  Use `headers` parameter to specify the extra headers of the response.

  Any valid httpx headers type is supported, you can submit headers as a dict (str or bytes), a list of 2-tuples (str or bytes) or a `httpx.Header` instance.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_headers_as_str_dict(httpx_mock: HTTPXMock):
      httpx_mock.add_response(headers={"X-Header1": "Test value"})

      with httpx.Client() as client:
          assert client.get("https://test_url").headers["x-header1"] == "Test value"


  def test_headers_as_str_tuple_list(httpx_mock: HTTPXMock):
      httpx_mock.add_response(headers=[("X-Header1", "Test value")])

      with httpx.Client() as client:
          assert client.get("https://test_url").headers["x-header1"] == "Test value"


  def test_headers_as_httpx_headers(httpx_mock: HTTPXMock):
      httpx_mock.add_response(headers=httpx.Headers({b"X-Header1": b"Test value"}))

      with httpx.Client() as client:
          assert client.get("https://test_url").headers["x-header1"] == "Test value"

  ```



  Cookies are sent in the `set-cookie` HTTP header.

  You can then send cookies in the response by setting the `set-cookie` header with [the value following key=value format]((https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie)).

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_cookie(httpx_mock: HTTPXMock):
      httpx_mock.add_response(headers={"set-cookie": "key=value"})

      with httpx.Client() as client:
          response = client.get("https://test_url")
      assert dict(response.cookies) == {"key": "value"}


  def test_cookies(httpx_mock: HTTPXMock):
      httpx_mock.add_response(headers=[("set-cookie", "key=value"), ("set-cookie", "key2=value2")])

      with httpx.Client() as client:
          response = client.get("https://test_url")
      assert dict(response.cookies) == {"key": "value", "key2": "value2"}

  ```




  Use `http_version` parameter to specify the HTTP protocol version of the response.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_http_version(httpx_mock: HTTPXMock):
      httpx_mock.add_response(http_version="HTTP/2.0")

      with httpx.Client() as client:
          assert client.get("https://test_url").http_version == "HTTP/2.0"

  ```



  You can perform custom manipulation upon request reception by registering callbacks.

  Callback should expect one parameter, the received [`httpx.Request`](https://www.python-httpx.org/api/#request).

  If all callbacks are not executed during test execution, the test case will fail at teardown.

  This behavior can be disabled thanks to the `assert_all_responses_were_requested` fixture:

  ```python
  import pytest

  @pytest.fixture
  def assert_all_responses_were_requested() -> bool:
      return False
  ```

  Note that callbacks are considered as responses, and thus are [selected the same way](#how-response-is-selected).



  Callback should return a `httpx.Response`.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_dynamic_response(httpx_mock: HTTPXMock):
      def custom_response(request: httpx.Request):
          return httpx.Response(
              status_code=200, json={"url": str(request.url)},
          )

      httpx_mock.add_callback(custom_response)

      with httpx.Client() as client:
          response = client.get("https://test_url")
          assert response.json() == {"url": "https://test_url"}

  ```

  Alternatively, callbacks can also be asynchronous.

  As in the following sample simulating network latency on some responses only.

  ```python
  import asyncio
  import httpx
  import pytest
  from pytest_httpx import HTTPXMock


  @pytest.mark.asyncio
  async def test_dynamic_async_response(httpx_mock: HTTPXMock):
      async def simulate_network_latency(request: httpx.Request):
          await asyncio.sleep(1)
          return httpx.Response(
              status_code=200, json={"url": str(request.url)},
          )

      httpx_mock.add_callback(simulate_network_latency)
      httpx_mock.add_response()

      async with httpx.AsyncClient() as client:
          responses = await asyncio.gather(
              
              client.get("https://test_url"),
              
              client.get("https://test_url")
          )

  ```



  You can simulate HTTPX exception throwing by raising an exception in your callback or use `httpx_mock.add_exception` with the exception instance.

  This can be useful if you want to assert that your code handles HTTPX exceptions properly.

  ```python
  import httpx
  import pytest
  from pytest_httpx import HTTPXMock


  def test_exception_raising(httpx_mock: HTTPXMock):
      httpx_mock.add_exception(httpx.ReadTimeout("Unable to read within timeout"))

      with httpx.Client() as client:
          with pytest.raises(httpx.ReadTimeout):
              client.get("https://test_url")

  ```

  Note that default behavior is to send an `httpx.TimeoutException` in case no response can be found. You can then test this kind of exception this way:

  ```python
  import httpx
  import pytest
  from pytest_httpx import HTTPXMock


  def test_timeout(httpx_mock: HTTPXMock):
      with httpx.Client() as client:
          with pytest.raises(httpx.TimeoutException):
              client.get("https://test_url")

  ```



  The best way to ensure the content of your requests is still to use the `match_headers` and / or `match_content` parameters when adding a response.
  In the same spirit, ensuring that no request was issued does not necessarily requires any code.

  In any case, you always have the ability to retrieve the requests that were issued.

  As in the following samples:

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


  def test_many_requests(httpx_mock: HTTPXMock):
      httpx_mock.add_response()

      with httpx.Client() as client:
          response1 = client.get("https://test_url")
          response2 = client.get("https://test_url")

      requests = httpx_mock.get_requests()


  def test_single_request(httpx_mock: HTTPXMock):
      httpx_mock.add_response()

      with httpx.Client() as client:
          response = client.get("https://test_url")

      request = httpx_mock.get_request()


  def test_no_request(httpx_mock: HTTPXMock):
      assert not httpx_mock.get_request()
  ```



  You can add criteria so that requests will be returned only in case of a more specific matching.



  `url` parameter can either be a string, a python [re.Pattern](https://docs.python.org/3/library/re.html) instance or a [httpx.URL](https://www.python-httpx.org/api/#url) instance.

  Matching is performed on the full URL, query parameters included.



  Use `method` parameter to specify the HTTP method (POST, PUT, DELETE, PATCH, HEAD) of the requests to retrieve.

  `method` parameter must be a string. It will be upper-cased, so it can be provided lower cased.

  Matching is performed on equality.



  Use `match_headers` parameter to specify the HTTP headers executing the callback.

  Matching is performed on equality for each provided header.



  Use `match_content` parameter to specify the full HTTP body executing the callback.

  Matching is performed on equality.



  By default, `pytest-httpx` will mock every request.

  But, for instance, in case you want to write integration tests with other servers, you might want to let some requests go through.

  To do so, you can use the `non_mocked_hosts` fixture:

  ```python
  import pytest

  @pytest.fixture
  def non_mocked_hosts() -> list:
      return ["my_local_test_host", "my_other_test_host"]
  ```

  Every other requested hosts will be mocked as in the following example

  ```python
  import pytest
  import httpx

  @pytest.fixture
  def non_mocked_hosts() -> list:
      return ["my_local_test_host"]


  def test_partial_mock(httpx_mock):
      httpx_mock.add_response()

      with httpx.Client() as client:
          
          response1 = client.get("https://www.my_local_test_host/sub?param=value")
          
          response2 = client.get("https://test_url")
  ```



  Here is how to migrate from well-known testing libraries to `pytest-httpx`.



  | Feature           | responses                  | pytest-httpx                |
  |:------------------|:---------------------------|:----------------------------|
  | Add a response    | `responses.add()`          | `httpx_mock.add_response()` |
  | Add a callback    | `responses.add_callback()` | `httpx_mock.add_callback()` |
  | Retrieve requests | `responses.calls`          | `httpx_mock.get_requests()` |



  Undocumented parameters means that they are unchanged between `responses` and `pytest-httpx`.
  Below is a list of parameters that will require a change in your code.

  | Parameter            | responses                           | pytest-httpx                                                         |
  |:---------------------|:------------------------------------|:---------------------------------------------------------------------|
  | method               | `method=responses.GET`              | `method="GET"`                                                       |
  | body (as bytes)      | `body=b"sample"`                    | `content=b"sample"`                                                  |
  | body (as str)        | `body="sample"`                     | `text="sample"`                                                      |
  | status code          | `status=201`                        | `status_code=201`                                                    |
  | headers              | `adding_headers={"name": "value"}`  | `headers={"name": "value"}`                                          |
  | content-type header  | `content_type="application/custom"` | `headers={"content-type": "application/custom"}`                     |
  | Match the full query | `match_querystring=True`            | The full query is always matched when providing the `url` parameter. |

  Sample adding a response with `responses`:
  ```python
  from responses import RequestsMock

  def test_response(responses: RequestsMock):
      responses.add(
          method=responses.GET,
          url="https://test_url",
          body=b"This is the response content",
          status=400,
      )

  ```

  Sample adding the same response with `pytest-httpx`:
  ```python
  from pytest_httpx import HTTPXMock

  def test_response(httpx_mock: HTTPXMock):
      httpx_mock.add_response(
          method="GET",
          url="https://test_url",
          content=b"This is the response content",
          status_code=400,
      )

  ```



  | Feature        | aioresponses            | pytest-httpx                               |
  |:---------------|:------------------------|:-------------------------------------------|
  | Add a response | `aioresponses.method()` | `httpx_mock.add_response(method="METHOD")` |
  | Add a callback | `aioresponses.method()` | `httpx_mock.add_callback(method="METHOD")` |



  Undocumented parameters means that they are unchanged between `responses` and `pytest-httpx`.
  Below is a list of parameters that will require a change in your code.

  | Parameter       | responses            | pytest-httpx        |
  |:----------------|:---------------------|:--------------------|
  | body (as bytes) | `body=b"sample"`     | `content=b"sample"` |
  | body (as str)   | `body="sample"`      | `text="sample"`     |
  | body (as JSON)  | `payload=["sample"]` | `json=["sample"]`   |
  | status code     | `status=201`         | `status_code=201`   |

  Sample adding a response with `aioresponses`:
  ```python
  import pytest
  from aioresponses import aioresponses


  @pytest.fixture
  def mock_aioresponse():
      with aioresponses() as m:
          yield m


  def test_response(mock_aioresponse):
      mock_aioresponse.get(
          url="https://test_url",
          body=b"This is the response content",
          status=400,
      )

  ```

  Sample adding the same response with `pytest-httpx`:
  ```python
  def test_response(httpx_mock):
      httpx_mock.add_response(
          method="GET",
          url="https://test_url",
          content=b"This is the response content",
          status_code=400,
      )

  ```


pkgId: 083e6afadf257a8a6763e2dfb3a282a0ce61c72bc868a14b2613417854fa34aa
name: python-pytest-json-report
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: A pytest plugin to report test results as JSON files
url: https://github.com/numirias/pytest-json-report
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-38e65068-ee3b-4741-9897-0089d1eb21e4
location_href: 00010591-python-pytest-json-report/python-pytest-json-report-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/numirias/pytest-json-report/actions/workflows/main.yml/badge.svg)](https://github.com/numirias/pytest-json-report/actions/workflows/main.yml)
  [![PyPI Version](https://img.shields.io/pypi/v/pytest-json-report.svg)](https://pypi.python.org/pypi/pytest-json-report)
  [![Python Versions](https://img.shields.io/pypi/pyversions/pytest-json-report.svg)](https://pypi.python.org/pypi/pytest-json-report)

  This pytest plugin creates test reports as JSON. This makes it easy to process test results in other applications.

  It can report a summary, test details, captured output, logs, exception tracebacks and more. Additionally, you can use the available fixtures and hooks to [add metadata](#metadata) and [customize](#modifying-the-report) the report as you like.



  * [Installation](#installation)
  * [Options](#options)
  * [Usage](#usage)
     * [Metadata](#metadata)
     * [Modifying the report](#modifying-the-report)
     * [Direct invocation](#direct-invocation)
  * [Format](#format)
     * [Summary](#summary)
     * [Environment](#environment)
     * [Collectors](#collectors)
     * [Tests](#tests)
     * [Test stage](#test-stage)
     * [Log](#log)
     * [Warnings](#warnings)
  * [Related tools](#related-tools)



  ```
  pip install pytest-json-report --upgrade
  ```



  | Option | Description |
  | --- | --- |
  | `--json-report` | Create JSON report |
  | `--json-report-file=PATH` | Target path to save JSON report (use "none" to not save the report) |
  | `--json-report-summary` | Just create a summary without per-test details |
  | `--json-report-omit=FIELD_LIST` | List of fields to omit in the report (choose from: `collectors`, `log`, `traceback`, `streams`, `warnings`, `keywords`) |
  | `--json-report-indent=LEVEL` | Pretty-print JSON with specified indentation level |
  | `--json-report-verbosity=LEVEL` | Set verbosity (default is value of `--verbosity`) |



  Just run pytest with `--json-report`. The report is saved in `.report.json` by default.

  ```bash
  $ pytest --json-report -v tests/
  $ cat .report.json
  {"created": 1518371686.7981803, ... "tests":[{"nodeid": "test_foo.py", "outcome": "passed", ...}, ...]}
  ```

  If you just need to know how many tests passed or failed and don't care about details, you can produce a summary only:

  ```bash
  $ pytest --json-report --json-report-summary
  ```

  Many fields can be omitted to keep the report size small. E.g., this will leave out keywords and stdout/stderr output:

  ```bash
  $ pytest --json-report --json-report-omit keywords streams
  ```

  If you don't like to have the report saved, you can specify `none` as the target file name:

  ```bash
  $ pytest --json-report --json-report-file none
  ```





  The easiest way to add your own metadata to a test item is by using the `json_metadata` [test fixture](https://docs.pytest.org/en/stable/fixture.html):

  ```python
  def test_something(json_metadata):
      json_metadata['foo'] = {"some": "thing"}
      json_metadata['bar'] = 123
  ```

  Or use the `pytest_json_runtest_metadata` [hook](https://docs.pytest.org/en/stable/reference.html#hooks) (in your `conftest.py`) to add metadata based on the current test run. The dict returned will automatically be merged with any existing metadata. E.g., this adds the start and stop time of each test's `call` stage:

  ```python
  def pytest_json_runtest_metadata(item, call):
      if call.when != 'call':
          return {}
      return {'start': call.start, 'stop': call.stop}
  ```

  Also, you could add metadata using [pytest-metadata's `--metadata` switch](https://github.com/pytest-dev/pytest-metadata#additional-metadata) which will add metadata to the report's `environment` section, but not to a specific test item. You need to make sure all your metadata is JSON-serializable.



  If you're using a `pytest_json_*` hook although the plugin is not installed or not active (not using `--json-report`), pytest doesn't recognize it and may fail with an internal error like this:
  ```
  INTERNALERROR> pluggy.manager.PluginValidationError: unknown hook 'pytest_json_runtest_metadata' in plugin <module 'conftest' from 'conftest.py'>
  ```
  You can avoid this by declaring the hook implementation optional:

  ```python
  import pytest
  @pytest.hookimpl(optionalhook=True)
  def pytest_json_runtest_metadata(item, call):
      ...
  ```



  You can modify the entire report before it's saved by using the `pytest_json_modifyreport` hook.

  Just implement the hook in your `conftest.py`, e.g.:

  ```python
  def pytest_json_modifyreport(json_report):
      
      json_report['foo'] = 'bar'
      
      del json_report['summary']
  ```

  After `pytest_sessionfinish`, the report object is also directly available to script via `config._json_report.report`. So you can access it using some built-in hook:

  ```python
  def pytest_sessionfinish(session):
      report = session.config._json_report.report
      print('exited with', report['exitcode'])
  ```

  If you *really* want to change how the result of a test stage run is turned into JSON, you can use the `pytest_json_runtest_stage` hook. It takes a [`TestReport`](https://docs.pytest.org/en/latest/reference.html#_pytest.runner.TestReport) and returns a JSON-serializable dict:

  ```python
  def pytest_json_runtest_stage(report):
      return {'outcome': report.outcome}
  ```



  You can use the plugin when invoking `pytest.main()` directly from code:

  ```python
  import pytest
  from pytest_jsonreport.plugin import JSONReport

  plugin = JSONReport()
  pytest.main(['--json-report-file=none', 'test_foo.py'], plugins=[plugin])
  ```

  You can then access the `report` object:

  ```python
  print(plugin.report)
  ```

  And save the report manually:

  ```python
  plugin.save_report('/tmp/my_report.json')
  ```




  The JSON report contains metadata of the session, a summary, collectors, tests and warnings. You can find a sample report in [`sample_report.json`](sample_report.json).

  | Key | Description |
  | --- | --- |
  | `created` | Report creation date. (Unix time) |
  | `duration` | Session duration in seconds. |
  | `exitcode` | Process exit code as listed [in the pytest docs](https://docs.pytest.org/en/latest/usage.html#possible-exit-codes). The exit code is a quick way to tell if any tests failed, an internal error occurred, etc. |
  | `root` | Absolute root path from which the session was started. |
  | `environment` | [Environment](#environment) entry. |
  | `summary` | [Summary](#summary) entry. |
  | `collectors` | [Collectors](#collectors) entry. (absent if `--json-report-summary` or if no collectors)  |
  | `tests` | [Tests](#tests) entry. (absent if `--json-report-summary`)  |
  | `warnings` | [Warnings](#warnings) entry. (absent if `--json-report-summary` or if no warnings)  |



  ```python
  {
      "created": 1518371686.7981803,
      "duration": 0.1235666275024414,
      "exitcode": 1,
      "root": "/path/to/tests",
      "environment": ENVIRONMENT,
      "summary": SUMMARY,
      "collectors": COLLECTORS,
      "tests": TESTS,
      "warnings": WARNINGS,
  }
  ```



  Number of outcomes per category and the total number of test items.

  | Key | Description |
  | --- | --- |
  |  `collected` | Total number of tests collected. |
  |  `total` | Total number of tests run. |
  |  `deselected` | Total number of tests deselected. (absent if number is 0) |
  | `<outcome>` | Number of tests with that outcome. (absent if number is 0) |



  ```python
  {
      "collected": 10,
      "passed": 2,
      "failed": 3,
      "xfailed": 1,
      "xpassed": 1,
      "error": 2,
      "skipped": 1,
      "total": 10
  }
  ```



  The environment section is provided by [pytest-metadata](https://github.com/pytest-dev/pytest-metadata). All metadata given by that plugin will be added here, so you need to make sure it is JSON-serializable.



  ```python
  {
      "Python": "3.6.4",
      "Platform": "Linux-4.56.78-9-ARCH-x86_64-with-arch",
      "Packages": {
          "pytest": "3.4.0",
          "py": "1.5.2",
          "pluggy": "0.6.0"
      },
      "Plugins": {
          "json-report": "0.4.1",
          "xdist": "1.22.0",
          "metadata": "1.5.1",
          "forked": "0.2",
          "cov": "2.5.1"
      },
      "foo": "bar", # Custom metadata entry passed via pytest-metadata
  }
  ```



  A list of collector nodes. These are useful to check what tests are available without running them, or to debug an error during test discovery.

  | Key | Description |
  | --- | --- |
  | `nodeid` | ID of the collector node. ([See docs](https://docs.pytest.org/en/latest/example/markers.html#node-id)) The root node has an empty node ID. |
  | `outcome` | Outcome of the collection. (Not the test outcome!) |
  | `result` | Nodes collected by the collector. |
  | `longrepr` | Representation of the collection error. (absent if no error occurred) |

  The `result` is a list of the collected nodes:

  | Key | Description |
  | --- | --- |
  | `nodeid` | ID of the node. |
  | `type` | Type of the collected node. |
  | `lineno` | Line number. (absent if not applicable) |
  | `deselected` | `true` if the test is deselected. (absent if not deselected) |



  ```python
  [
      {
          "nodeid": "",
          "outcome": "passed",
          "result": [
              {
                  "nodeid": "test_foo.py",
                  "type": "Module"
              }
          ]
      },
      {
          "nodeid": "test_foo.py",
          "outcome": "passed",
          "result": [
              {
                  "nodeid": "test_foo.py::test_pass",
                  "type": "Function",
                  "lineno": 24,
                  "deselected": true
              },
              ...
          ]
      },
      {
          "nodeid": "test_bar.py",
          "outcome": "failed",
          "result": [],
          "longrepr": "/usr/lib/python3.6 ... invalid syntax"
      },
      ...
  ]
  ```



  A list of test nodes. Each completed test stage produces a stage object (`setup`, `call`, `teardown`) with its own `outcome`.

  | Key | Description |
  | --- | --- |
  | `nodeid` | ID of the test node. |
  | `lineno` | Line number where the test starts. |
  | `keywords` | List of keywords and markers associated with the test. |
  | `outcome` | Outcome of the test run. |
  | `{setup, call, teardown}` | [Test stage](#test-stage) entry. To find the error in a failed test you need to check all stages. (absent if stage didn't run) |
  | `metadata` | [Metadata](#metadata) item. (absent if no metadata) |



  ```python
  [
      {
          "nodeid": "test_foo.py::test_fail",
          "lineno": 50,
          "keywords": [
              "test_fail",
              "test_foo.py",
              "test_foo0"
          ],
          "outcome": "failed",
          "setup": TEST_STAGE,
          "call": TEST_STAGE,
          "teardown": TEST_STAGE,
          "metadata": {
              "foo": "bar",
          }
      },
      ...
  ]
  ```




  A test stage item.

  | Key | Description |
  | --- | --- |
  | `duration` | Duration of the test stage in seconds. |
  | `outcome` | Outcome of the test stage. (can be different from the overall test outcome) |
  | `crash` | Crash entry. (absent if no error occurred) |
  | `traceback` | List of traceback entries. (absent if no error occurred; affected by `--tb` option) |
  | `stdout` | Standard output. (absent if none available) |
  | `stderr` | Standard error. (absent if none available) |
  | `log` | [Log](#log) entry. (absent if none available) |
  | `longrepr` | Representation of the error. (absent if no error occurred; format affected by `--tb` option) |



  ```python
  {
      "duration": 0.00018835067749023438,
      "outcome": "failed",
      "crash": {
          "path": "/path/to/tests/test_foo.py",
          "lineno": 54,
          "message": "TypeError: unsupported operand type(s) for -: 'int' and 'NoneType'"
      },
      "traceback": [
          {
              "path": "test_foo.py",
              "lineno": 65,
              "message": ""
          },
          {
              "path": "test_foo.py",
              "lineno": 63,
              "message": "in foo"
          },
          {
              "path": "test_foo.py",
              "lineno": 63,
              "message": "in <listcomp>"
          },
          {
              "path": "test_foo.py",
              "lineno": 54,
              "message": "TypeError"
          }
      ],
      "stdout": "foo\nbar\n",
      "stderr": "baz\n",
      "log": LOG,
      "longrepr": "def test_fail_nested():\n ..."
  }
  ```



  A list of log records. The fields of a log record are the [`logging.LogRecord` attributes](https://docs.python.org/3/library/logging.html#logrecord-attributes), with the exception that the fields `exc_info` and `args` are always empty and `msg` contains the formatted log message.

  You can apply [`logging.makeLogRecord()`](https://docs.python.org/3/library/logging.html#logging.makeLogRecord)  on a log record to convert it back to a `logging.LogRecord` object.



  ```python
  [
      {
          "name": "root",
          "msg": "This is a warning.",
          "args": null,
          "levelname": "WARNING",
          "levelno": 30,
          "pathname": "/path/to/tests/test_foo.py",
          "filename": "test_foo.py",
          "module": "test_foo",
          "exc_info": null,
          "exc_text": null,
          "stack_info": null,
          "lineno": 8,
          "funcName": "foo",
          "created": 1519772464.291738,
          "msecs": 291.73803329467773,
          "relativeCreated": 332.90839195251465,
          "thread": 140671803118912,
          "threadName": "MainThread",
          "processName": "MainProcess",
          "process": 31481
      },
      ...
  ]
  ```




  A list of warnings that occurred during the session. (See the [pytest docs on warnings](https://docs.pytest.org/en/latest/warnings.html).)

  | Key | Description |
  | --- | --- |
  | `filename` | File name. |
  | `lineno` | Line number. |
  | `message` | Warning message. |
  | `when` | When the warning was captured. (`"config"`, `"collect"` or `"runtest"` as listed [here](https://docs.pytest.org/en/latest/reference.html#_pytest.hookspec.pytest_warning_captured)) |



  ```python
  [
      {
          "code": "C1",
          "path": "/path/to/tests/test_foo.py",
          "nodeid": "test_foo.py::TestFoo",
          "message": "cannot collect test class 'TestFoo' because it has a __init__ constructor"
      }
  ]
  ```



  - [pytest-json](https://github.com/mattcl/pytest-json) has some great features but appears to be unmaintained. I borrowed some ideas and test cases from there.

  - [tox has a switch](http://tox.readthedocs.io/en/latest/example/result.html) to create a JSON report including a test result summary. However, it just provides the overall outcome without any per-test details.


pkgId: 64444995cca38815651f02ee309e0b953c195856b23c1abbabe500ffb7cc7da5
name: python-pytest-kind
arch: src
version: 22.11.1
epoch: 0
release: 1
summary: Kubernetes test support with KIND for pytest
url: https://codeberg.org/hjacobs/pytest-kind
rpm_license: GPL-3.0+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f095523-b47b-439a-b277-7378af8b0100
location_href: 00013381-python-pytest-kind/python-pytest-kind-22.11.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/hjacobs/pytest-kind.svg?branch=master)](https://travis-ci.com/hjacobs/pytest-kind)
  [![PyPI](https://img.shields.io/pypi/v/pytest-kind)](https://pypi.org/project/pytest-kind/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-kind)
  ![License](https://img.shields.io/github/license/hjacobs/pytest-kind)
  ![CalVer](https://img.shields.io/badge/calver-YY.MM.MICRO-22bfda.svg)

  Test your Python Kubernetes app/operator end-to-end with [kind](https://kind.sigs.k8s.io/) and [pytest](https://pytest.org).

  `pytest-kind` is a plugin for pytest which provides the `kind_cluster` fixture.
  The fixture will install kind 0.17.0, create a Kubernetes 1.25 cluster, and provide convenience functionality such as port forwarding.




  Install `pytest-kind` via pip or via [poetry](https://poetry.eustace.io/), e.g.:

  ```
  poetry add --dev pytest-kind
  ```

  Write your pytest functions and use the provided `kind_cluster` fixture, e.g.:

  ```python
  def test_kubernetes_version(kind_cluster):
      assert kind_cluster.api.version == ('1', '25')
  ```

  To load your custom Docker image and apply deployment manifests:

  ```python
  import requests
  from pykube import Pod

  def test_myapp(kind_cluster):
      kind_cluster.load_docker_image("myapp")
      kind_cluster.kubectl("apply", "-f", "deployment.yaml")
      kind_cluster.kubectl("rollout", "status", "deployment/myapp")

      
      for pod in Pod.objects(kind_cluster.api).filter(selector="app=myapp"):
          assert "Sucessfully started" in pod.logs()

      with kind_cluster.port_forward("service/myapp", 80) as port:
          r = requests.get(f"http://localhost:{port}/hello/world")
          r.raise_for_status()
          assert r.text == "Hello world!"
  ```

  See the `examples` directory for sample projects and also check out [kube-web-view](https://codeberg.org/hjacobs/kube-web-view) which uses pytest-kind for its e2e tests.




  The `kind_cluster` fixture is an instance of the KindCluster class with the following methods:

  * `load_docker_image(docker_image)`: load the specified Docker image into the kind cluster
  * `kubectl(*args)`: run the `kubectl` binary against the cluster with the specified arguments. Returns the process output as string.
  * `port_forward(service_or_pod_name, remote_port, *args)`: run "kubectl port-forward" for the given service/pod and return the (random) local port. To be used as context manager ("with" statement). Pass the namespace as additional args to kubectl via "-n", "mynamespace".

  KindCluster has the following attributes:

  * `name`: the kind cluster name
  * `kubeconfig_path`: the path to the Kubeconfig file to access the cluster
  * `kind_path`: path to the `kind` binary
  * `kubectl_path`: path to the `kubectl` binary
  * `api`: [pykube](https://pykube.readthedocs.io/) HTTPClient instance to access the cluster from Python

  You can also use KindCluster directly without pytest:

  ```python
  from pytest_kind import KindCluster

  cluster = KindCluster("myclustername")
  cluster.create()
  cluster.kubectl("apply", "-f", "..")

  cluster.delete()
  ```




  The kind cluster name can be set via the `--cluster-name` CLI option.

  The kind cluster is deleted after each pytest session, you can keep the cluster by passing `--keep-cluster` to pytest.

  Note that you can use the `PYTEST_ADDOPTS` environment variable to pass these options to pytest. This also works if you call pytest from a Makefile:

  ```bash

  PYTEST_ADDOPTS=--keep-cluster make test
  ```




  * The `kind_cluster` fixture is session-scoped, i.e. the same cluster will be used across all test modules/functions.
  * The `kind` and `kubectl` binaries will be downloaded once to the local directory `./.pytest-kind/{cluster-name}/`. You can use them to interact with the cluster (e.g. when `--keep-cluster` is used).
  * Some cluster pods might not be ready immediately (e.g. kind's CoreDNS take a moment), add wait/poll functionality as required to make your tests predictable.


pkgId: e230290dc0bd125700ee9bcf2fd509b6c9551d70069178057c9dd6002f1b9c37
name: python-pytest-logger
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Plugin configuring handlers for loggers from Python logging module.
url: https://github.com/aurzenligl/pytest-logger
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b181aced-d67f-4d87-91d5-90435f342072
location_href: 00012766-python-pytest-logger/python-pytest-logger-0.5.1-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/pytest-logger.svg
      :target: https://pypi.python.org/pypi/pytest-logger
      :alt: Pypi Package Version
  .. image:: https://img.shields.io/pypi/pyversions/pytest-logger.svg
      :target: https://pypi.python.org/pypi/pytest-logger
      :alt: Supported Python Versions
  .. image:: https://readthedocs.org/projects/pytest-logger/badge
      :target: http://pytest-logger.readthedocs.io/en/latest
      :alt: Documentation Status
  .. image:: https://coveralls.io/repos/github/aurzenligl/pytest-logger/badge.svg?branch=master
      :target: https://coveralls.io/github/aurzenligl/pytest-logger?branch=master
      :alt: Coverage Status
  .. image:: https://travis-ci.org/aurzenligl/pytest-logger.svg?branch=master
      :target: https://travis-ci.org/aurzenligl/pytest-logger
      :alt: Travis-CI Build Status
  .. image:: https://ci.appveyor.com/api/projects/status/1h4cy8tk220pn03o?svg=true
      :target: https://ci.appveyor.com/project/aurzenligl/pytest-logger
      :alt: AppVeyor-CI Build Status

  Pytest-logger is a pytest plugin configuring handlers for loggers from Python logging module.

  You can install pytest-logger via ``pip`` from ``PyPI``::

      $ [sudo] pip install pytest-logger

  Plugin puts logs on per-logger basis to:

  - standard output,
  - files within log-specific directory under pytest's ``tmpdir_factory`` session directory.

  You can setup plugin using hook::

      
      import os

      def pytest_logger_config(logger_config):
          logger_config.add_loggers(['foo', 'bar', 'baz'], stdout_level='info')
          logger_config.set_log_option_default('foo,bar')

      def pytest_logger_logdirlink(config):
          return os.path.join(os.path.dirname(__file__), 'mylogs')

  have logging tests or libraries (including fixtures)::

      
      import pytest
      import logging

      foo = logging.getLogger('foo')
      bar = logging.getLogger('bar')
      baz = logging.getLogger('baz')

      @pytest.yield_fixture(scope='session')
      def session_thing():
          foo.debug('constructing session thing')
          yield
          foo.debug('destroying session thing')

      @pytest.yield_fixture
      def testcase_thing():
          foo.debug('constructing testcase thing')
          yield
          foo.debug('destroying testcase thing')

      def test_one(session_thing, testcase_thing):
          foo.info('one executes')
          bar.warning('this test does nothing aside from logging')
          baz.info('extra log, rarely read')

      def test_two(session_thing, testcase_thing):
          foo.info('two executes')
          bar.warning('neither does this')
          baz.info('extra log, not enabled by default')

  and expect output in terminal (if not captured)::

      $ py.test -s -v
      (...)
      test_something.py::test_one
      00:00.002 inf foo: one executes
      00:00.002 wrn bar: this test does nothing aside from logging
      PASSED

      test_something.py::test_two
      00:00.000 inf foo: two executes
      00:00.000 wrn bar: neither does this
      PASSED

  being able to change this output by cmdline option::

      $ pytest -s -v --log foo.debug,baz
      (...)
      test_something.py::test_one
      00:00.002 dbg foo: constructing session thing
      00:00.002 dbg foo: constructing testcase thing
      00:00.002 inf foo: one executes
      00:00.003 inf baz: extra log, rarely read
      PASSED

      test_something.py::test_two
      00:00.000 dbg foo: constructing testcase thing
      00:00.000 inf foo: two executes
      00:00.001 inf baz: extra log, not enabled by default
      PASSED

  and - the same - in filesystem::

      $ file mylogs
      mylogs: symbolic link to `/tmp/pytest-of-aurzenligl/pytest-48/logs'

      $ tree mylogs
      mylogs
      `-- test_something.py
          |-- test_one
          |   |-- bar
          |   |-- baz
          |   `-- foo
          `-- test_two
              |-- bar
              |-- baz
              `-- foo

  Distributed under the terms of the ``MIT`` license, pytest-logger is free and open source software.


pkgId: 8851674ae7206386fb565086f449a31fe57ef4672dc7baa05a19eb033dfc9ee9
name: python-pytest-metadata
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: pytest plugin for test session metadata
url: https://github.com/pytest-dev/pytest-metadata
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d2bae23-e8fc-4816-9b40-5f120ced7e08
location_href: 00004849-python-pytest-metadata/python-pytest-metadata-2.0.4-1.src.rpm
checksum_type: sha256
description:
  pytest-metadata is a plugin for `pytest <http://pytest.org>`_ that provides
  access to test session metadata.


pkgId: 79bb4427d5e6f80372dea72f0771f5b47879939a3aec94773db4f0412df2f4e2
name: python-pytest-mpi
arch: src
version: 0.6
epoch: 0
release: 1
summary: pytest plugin to collect information from tests
url: https://pytest-mpi.readthedocs.io
rpm_license: 3-clause BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12a4d6f3-7e1b-4cb1-a7d2-5aa42bd3f4e9
location_href: 00004850-python-pytest-mpi/python-pytest-mpi-0.6-1.src.rpm
checksum_type: sha256
description:
  `pytest_mpi` is a plugin for pytest providing some useful tools when running
  tests under MPI, and testing MPI-related code.

  To run a test only when using MPI, use the `pytest.mark.mpi` marker like:
  ::

      @pytest.mark.mpi
      def test_mpi():
          pass


  Further documentation can be found at `<https://pytest-mpi.readthedocs.io>`_.

  Bug reports and suggestions should be filed at
  `<https://github.com/aragilar/pytest-mpi/issues>`_.


  |Documentation Status| |Build Status| |Coverage Status|

  .. |Documentation Status| image:: https://readthedocs.org/projects/pytest-mpi/badge/?version=latest
     :target: http://pytest-mpi.readthedocs.org/en/latest/?badge=latest
  .. |Build Status| image:: https://travis-ci.org/aragilar/pytest-mpi.svg?branch=master
     :target: https://travis-ci.org/aragilar/pytest-mpi
  .. |Coverage Status| image:: https://codecov.io/github/aragilar/pytest-mpi/coverage.svg?branch=master
     :target: https://codecov.io/github/aragilar/pytest-mpi?branch=master


pkgId: d03bb1d01d13d3e042987833d5a2ece01cf7db1acfb96803d3de255eb86a9914
name: python-pytest-mpl
arch: src
version: 0.16.1
epoch: 0
release: 1
summary: pytest plugin to help with testing figures output from Matplotlib
url: https://github.com/matplotlib/pytest-mpl
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-01859cd6-5af6-482c-8a61-381badce92f7
location_href: 00004851-python-pytest-mpl/python-pytest-mpl-0.16.1-1.src.rpm
checksum_type: sha256
description:
  This is a plugin to facilitate image comparison for
  `Matplotlib <http://www.matplotlib.org>`__ figures in pytest.
  For each figure to test, the reference image is subtracted from the
  generated image, and the RMS of the residual is compared to a
  user-specified tolerance. If the residual is too large, the test will
  fail (this is implemented using helper functions from
  ``matplotlib.testing``).
  For more information on how to write tests to do this, see the **Using**
  section below.


pkgId: 8d532c8a26642eeb6efbd351459db862f9c84a6cafc056dc89a207a1c17452b3
name: python-pytest-multihost
arch: src
version: 3.4
epoch: 0
release: 1
summary: Utility for writing multi-host tests for pytest
url: https://pagure.io/python-pytest-multihost
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-189a9362-934e-45b7-81ff-085f7f3e9ccb
location_href: 00004852-python-pytest-multihost/python-pytest-multihost-3.4-1.src.rpm
checksum_type: sha256
description:
  Release tarballs will be made available for download from Pagure Releases:
      https://pagure.io/releases/python-pytest-multihost/
  The goal is to include this project in Fedora repositories. Until that happens,
  you can use testing builds from COPR – see "Developer links" below.
  You can also install using pip:
      https://pypi.python.org/pypi/pytest-multihost


pkgId: 8dc783ef21368ea2e6f5d42f4009424194a0f0cfac1f90f637078d8e308b7345
name: python-pytest-order
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: pytest plugin to run your tests in a specific order
url: https://github.com/pytest-dev/pytest-order
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc9cbbca-75fe-4995-add1-ab35cf429e8c
location_href: 00011561-python-pytest-order/python-pytest-order-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/pytest-order.svg)](https://pypi.org/project/pytest-order) [![Testsuite](https://github.com/pytest-dev/pytest-order/workflows/Testsuite/badge.svg)](https://github.com/pytest-dev/pytest-order/actions?query=workflow%3ATestsuite) [![DocBuild](https://readthedocs.org/projects/pytest-pyfakefs/badge/?version=latest)](https://pytest-pyfakefs.readthedocs.io/en/latest/?badge=latest) [![codecov](https://codecov.io/gh/pytest-dev/pytest-order/branch/main/graph/badge.svg?token=M9PHWZSHUU)](https://codecov.io/gh/pytest-dev/pytest-order) [![Python version](https://img.shields.io/pypi/pyversions/pytest-order.svg)](https://pypi.org/project/pytest-order)
  `pytest-order` is a pytest plugin that allows you to customize the order in which
  your tests are run. It uses the marker `order` that defines when a specific
  test shall run, either by using an ordinal number, or by specifying the
  relationship to other tests.
  `pytest-order` is a fork of
  [pytest-ordering](https://github.com/ftobia/pytest-ordering) that provides
  additional features like ordering relative to other tests.
  `pytest-order` works with Python 3.7 - 3.11, with pytest
  versions >= 5.0.0 for all versions up to Python 3.9, and for pytest >=
  6.2.4 for Python 3.10 and 3.11. `pytest-order` runs on Linux, macOS and Windows.


pkgId: ac13d4d5e2caf35fd2d108cc7182f0a2db92eb8a58b8aa12669bd32d43556964
name: python-pytest-parallel
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: a pytest plugin for parallel and concurrent testing
url: https://github.com/browsertron/pytest-parallel
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2226925f-6a88-4175-b76a-b6a9721859bf
location_href: 00011067-python-pytest-parallel/python-pytest-parallel-0.1.1-1.src.rpm
checksum_type: sha256
description:
  a pytest plugin for parallel and concurrent testing



  This plugin makes it possible to run tests quickly using multiprocessing (parallelism) and multithreading (concurrency).



  `pytest-xdist` is great to run tests that:
    1. aren't threadsafe
    2. perform poorly when multithreaded
    3. need state isolation

  `pytest-parallel` is better for some use cases (like Selenium tests) that:
    1. can be threadsafe
    2. can use non-blocking IO for http requests to make it performant
    3. manage little or no state in the Python environment

  Put simply, `pytest-xdist` does parallelism while `pytest-parallel` does parallelism and concurrency.



  * Python3 version [3.6+]
  * Unix or Mac for `--workers`
  * Unix, Mac, or Windows for `--tests-per-worker`



  `pip install pytest-parallel`



  * `workers` (optional) - max workers (aka processes) to start. Can be a **positive integer or `auto`** which uses one worker per core. **Defaults to 1**.
  * `tests-per-worker` (optional) - max concurrent tests per worker. Can be a **positive integer or `auto`** which evenly divides tests among the workers up to 50 concurrent tests. **Defaults to 1**.



  ```bash

  pytest --workers 2


  pytest --workers auto


  pytest --tests-per-worker 4


  pytest --tests-per-worker auto


  pytest --workers 2 --tests-per-worker auto
  ```



  Beginning with Python 3.8, forking behavior is forced on macOS at the expense of safety.

      Changed in version 3.8: On macOS, the spawn start method is now the default. The fork start method should be considered unsafe as it can lead to crashes of the subprocess. See bpo-33725.

  [Source](https://docs.python.org/3/library/multiprocessing.html#contexts-and-start-methods)



  MIT


pkgId: 0aae141e0adc4a354b6e61cb064576495d02b97dbb9d39762b84148f42325bb9
name: python-pytest-profiling
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Profiling plugin for py.test
url: https://github.com/manahl/pytest-plugins
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5dd64c31-b8f0-463e-bd9c-2f008838ab18
location_href: 00011269-python-pytest-profiling/python-pytest-profiling-1.7.0-1.src.rpm
checksum_type: sha256
description:
  Profiling plugin for pytest, with tabular and heat graph output.
  Tests are profiled with
  `cProfile <http://docs.python.org/library/profile.html#module-cProfile>`__
  and analysed with
  `pstats <http://docs.python.org/library/profile.html#pstats.Stats>`__;
  heat graphs are generated using
  `gprof2dot <http://code.google.com/p/jrfonseca/wiki/Gprof2Dot>`__ and
  `dot <http://www.graphviz.org/>`__.


pkgId: 1e482a840eb36f8e926bdc5090922411a3f7afb8a954e88c5b43b082a2b87f41
name: python-pytest-recording
arch: src
version: 0.12.2
epoch: 0
release: 1
summary: A pytest plugin that allows you recording of network interactions via VCR.py
url: https://github.com/kiwicom/pytest-recording
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-46571dbb-360d-477b-95af-5cae87fb5971
location_href: 00014277-python-pytest-recording/python-pytest-recording-0.12.2-1.src.rpm
checksum_type: sha256
description:
  |codecov| |Build| |Version| |Python versions| |License|
  A pytest plugin that records network interactions in your tests via VCR.py.


pkgId: deef7cd814ebe4758da32fcd5e0776aafa47f3d47f2a3857622c4f2e38d6c250
name: python-pytest-repeat
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: pytest plugin for repeating tests
url: https://github.com/pytest-dev/pytest-repeat
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a148c52-09bf-41a1-a30a-0a4644c4a2af
location_href: 00004858-python-pytest-repeat/python-pytest-repeat-0.9.1-1.src.rpm
checksum_type: sha256
description:
  pytest-repeat is a plugin for `pytest <https://docs.pytest.org>`_ that makes it
  easy to repeat a single test, or multiple tests, a specific number of times.


pkgId: 5388eae884297a1efbb7b2d81c7e9d92350742652d1bfa7121ae50c2e20795d2
name: python-pytest-reraise
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Make multi-threaded pytest test cases fail when they should
url: https://github.com/bjoluc/pytest-reraise
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-861e55e8-dea7-4b37-9abf-68ac06231aff
location_href: 00013164-python-pytest-reraise/python-pytest-reraise-2.1.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pytest-reraise)](https://pypi.python.org/pypi/pytest-reraise/)
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/bjoluc/pytest-reraise/build)](https://github.com/bjoluc/pytest-reraise/actions)
  [![codecov](https://codecov.io/gh/bjoluc/pytest-reraise/branch/main/graph/badge.svg)](https://codecov.io/gh/bjoluc/pytest-reraise)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/pytest-reraise)](https://pypi.python.org/pypi/pytest-reraise/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/pytest-reraise)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000)](https://github.com/psf/black)
  [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079)](https://github.com/bjoluc/semantic-release-config-poetry)

  Let's assume you write a pytest test case that includes assertions in another thread, like so:

  ```python
  from threading import Thread

  def test_assert():

      def run():
          assert False

      Thread(target=run).start()
  ```

  This test will pass, as the `AssertionError` is not raised in the main thread.
  `pytest-reraise` is here to help you capture the exception and raise it in the main thread:

  ```sh
  pip install pytest-reraise
  ```

  ```python
  from threading import Thread

  def test_assert(reraise):

      def run():
          with reraise:
              assert False

      Thread(target=run).start()
  ```

  The above test will fail, as `pytest-reraise` captures the exception and raises it at the end of the test case.





  Instead of using the `reraise` context manager in a function, you can also wrap the entire function with it via the `reraise.wrap()` method.
  Hence, the example
  ```python
  def run():
      with reraise:
          assert False

  Thread(target=run).start()
  ```
  can also be written as
  ```python
  def run():
      assert False

  Thread(target=reraise.wrap(run)).start()
  ```
  or even
  ```python
  @reraise.wrap
  def run():
      assert False

  Thread(target=run).start()
  ```



  By default, the captured exception (if any) is raised at the end of the test case.
  If you want to raise it before then, call `reraise()` in your test case.
  If an exception has been raised within a `with reraise` block by then, `reraise()` will raise it right away:

  ```python
  def test_assert(reraise):

      def run():
          with reraise:
              assert False

      reraise() # This will not raise anything yet

      t = Thread(target=run)
      t.start()
      t.join()

      reraise() # This will raise the assertion error
  ```

  As seen in the example above, `reraise()` can be called multiple times during a test case. Whenever an exception has been raised in a `with reraise` block since the last call, it will be raised on the next call.



  When the `reraise` context manager is used multiple times in a single test case, only the first-raised exception will be re-raised in the end.
  In the below example, both threads raise an exception but only one of these exceptions will be re-raised.

  ```python
  def test_assert(reraise):

      def run():
          with reraise:
              assert False

      for _ in range(2):
          Thread(target=run).start()
  ```



  By default, the `reraise` context manager does not catch exceptions, so they will not be hidden from the thread in which they are raised.
  If you want to change this, use `reraise(catch=True)` instead of `reraise`:

  ```python
  def test_assert(reraise):

      def run():
          with reraise(catch=True):
              assert False
          print("I'm alive!")

      Thread(target=run).start()
  ```

  Note that you cannot use `reraise()` (without the `catch` argument) as a context manager, as it is used to raise exceptions.



  If `reraise` captures an exception and the main thread raises an exception as well, the exception captured by `reraise` will mask the main thread's exception unless that exception was already re-raised.
  The objective behind this is that the outcome of the main thread often depends on the work performed in other threads.
  Thus, failures in in other threads are likely to cause failures in the main thread, and other threads' exceptions (if any) are of greater importance for the developer than main thread exceptions.

  The example below will report `assert False`, not `assert "foo" == "bar"`.

  ```python
  def test_assert(reraise):

      def run():
          with reraise:
              assert False # This will be reported

      t = Thread(target=run)
      t.start()
      t.join()

      assert "foo" == "bar" # This won't
  ```



  `reraise` provides an `exception` property to retrieve the exception that was captured, if any.
  `reraise.exception` can also be used to assign an exception if no exception has been captured yet.
  In addition to that, `reraise.reset()` returns the value of `reraise.exception` and resets it to `None` so that the exception will not be raised anymore.

  Here's a quick demonstration test case that passes:

  ```python
  def test_assert(reraise):

      def run():
          with reraise:
              assert False

      t = Thread(target=run)
      t.start()
      t.join()

      
      assert type(reraise.exception) is AssertionError

      
      reraise.exception = Exception()

      
      assert type(reraise.reset()) is AssertionError

      
      assert reraise.exception is None
  ```


pkgId: 585ba62e09e52b4fb86ca5d9b7c65be30d8bf0cd1aa1dec48a864609f08ac42b
name: python-pytest-rerunfailures
arch: src
version: 11.1.2
epoch: 0
release: 1
summary: pytest plugin to re-run tests to eliminate flaky failures
url: https://github.com/pytest-dev/pytest-rerunfailures
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b1ec126a-5733-4c63-b7e9-84ce6f901193
location_href: 00004859-python-pytest-rerunfailures/python-pytest-rerunfailures-11.1.2-1.src.rpm
checksum_type: sha256
description:
  pytest-rerunfailures is a plugin for `pytest <https://pytest.org>`_ that
  re-runs tests to eliminate intermittent failures.


pkgId: fba822a8d4599c3e3ef0e3009564282150c2e441884225f05d441841384fd0f1
name: python-pytest-sanic
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: a pytest plugin for Sanic
url: https://github.com/yunstanford/pytest-sanic
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eba9e53e-1d08-4b7a-b2df-cc89a4e42624
location_href: 00004860-python-pytest-sanic/python-pytest-sanic-1.9.1-1.src.rpm
checksum_type: sha256
description:
      * - Build
        - | |travis|
      * - Docs
        - |docs|
      * - Package
        - | |version| |wheel| |supported-versions| |supported-implementations|
  A pytest plugin for `Sanic <http://sanic.readthedocs.io/en/latest/>`_. It helps you to test your code asynchronously.
  This plugin provides:
  * very easy testing with async coroutines
  * common and useful fixtures
  * asynchronous fixture support
  * test_client/sanic_client for Sanic application
  * test_server for Sanic application
  You can find out more here:
  http://pytest-sanic.readthedocs.io/en/latest/
  Releases and change logs can be found here:


pkgId: b3f85d99accabe9a46f90d43b56e2640576e8b959e7f2b466065ae0e6b68cee8
name: python-pytest-shard
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/AdamGleave/pytest-shard
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3740e749-d03b-4601-a350-f6a63e3c1cf5
location_href: 00012608-python-pytest-shard/python-pytest-shard-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/AdamGleave/pytest-shard.svg?style=svg)](https://circleci.com/gh/AdamGleave/pytest-shard)
  [![PyPI version](https://badge.fury.io/py/pytest-shard.svg)](https://badge.fury.io/py/pytest-shard)



  Shards tests based on a hash of their test name enabling easy parallelism across machines, suitable for a wide variety of continuous integration services. Tests are split at the finest level of granularity, individual test cases, enabling parallelism even if all of your tests are in a single file (or even single parameterized test method).



  `pytest-shard` aims for simplicity. When installed, simply run:

  ```
  $ pytest --shard-id=I --num-shards=N
  ```

  where `I` is the index of this shard and `N` the total number of shards. For example, to split tests across two machines:

  ```

  $ pytest --shard-id=0 --num-shards=2

  $ pytest --shard-id=1 --num-shards=2
  ```

  The intended use case is for continuous integration services that allow you to run jobs in parallel. For CircleCI, enable [parallelism](https://circleci.com/docs/2.0/parallelism-faster-jobs/) and then use:
  ```
  pytest --shard-id=${CIRCLE_NODE_INDEX} --num-shards=${CIRCLE_NODE_TOTAL}
  ```

  On Travis, you must define the environment variables explicitly, but can use a [similar approach](https://docs.travis-ci.com/user/speeding-up-the-build/).



  [pytest-xdist](https://github.com/pytest-dev/pytest-xdist) allows you to parallelize tests across cores on a single machine, and can also schedule tests on a remote machine. I use `pytest-shard` to split tests across CI workers, and `pytest-xdist` to parallelize across CPU cores within each worker.

  `pytest-shard` does not take into account the run time of tests, which can lead to suboptimal allocations. [pytest-circleci-parallelized](https://github.com/ryanwilsonperkin/pytest-circleci-parallelized) uses test run time, but can only split at the granularity of classes, and is specific to CircleCI.

  Please open a PR if there are other promising alternatives that I have overlooked.



  You can install `pytest-shard` via `pip`:

  ```
  $ pip install pytest-shard
  ```



  Contributions are welcome. Test may be run using `tox`.



  This software is MIT licensed.


pkgId: 915429bbfaf9175e5e018b0a7e534ac7f6202e8dd61bf259ca17dcff1ee9c44e
name: python-pytest-spec
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Library pytest-spec is a pytest plugin to display test execution output like a SPECIFICATION.
url: https://github.com/pchomik/pytest-spec
rpm_license: GPL-2.0-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0a55bc24-38f0-486b-ad90-69e01dad7a44
location_href: 00004862-python-pytest-spec/python-pytest-spec-3.2.0-1.src.rpm
checksum_type: sha256
description:
  <p>
      <h1 align="center">pytest-spec</h1>
      <p align="center">
          <img src="https://badgen.net/badge/python/2.7/green">
          <img src="https://badgen.net/badge/python/3.5/green">
          <img src="https://badgen.net/badge/python/3.6/green">
          <img src="https://badgen.net/badge/python/3.7/green">
          <img src="https://badgen.net/badge/python/3.8/green">
          <img src="https://badgen.net/badge/python/3.9/green">
      </p>
      <p align="center">
          <img src="https://badgen.net/badge/os/linux/blue">
          <img src="https://badgen.net/badge/os/windows/blue">
          <img src="https://badgen.net/badge/os/macos/blue">
      </p>
      <p align="center">
          <img src="https://badgen.net/badge/pytest/3.9.3/purple">
          <img src="https://badgen.net/badge/pytest/4.6.11/purple">
          <img src="https://badgen.net/badge/pytest/5.4.3/purple">
          <img src="https://badgen.net/badge/pytest/6.1.2/purple">
      </p>
      <p align="center">
          Library pytest-spec is a pytest plugin to display test execution output like a SPECIFICATION.
      </p>
  </p>




  * Format output to look like specification.
  * Group tests by classes and files
  * Failed, passed and skipped are marked and colored.
  * Remove test\_ and underscores for every test.
  * It is possible to use docstring summary instead of test name.
  * Supports function based, class based test.
  * Supports describe like tests.




  ![Example](https://github.com/pchomik/pytest-spec/raw/master/docs/output.gif)






  You can configure the format of the test headers by specifying a [format string](https://docs.python.org/2/library/string.html#format-string-syntax) in your [ini-file](http://doc.pytest.org/en/latest/customize.html#inifiles):

  ```ini
      [tool:pytest]
      spec_header_format = {module_path}:
  ```

  In addition to the ``{path}`` and ``{class_name}`` replacement fields, there is also ``{test_case}`` that holds a more human readable name.



  You can configure the format of the test results by specifying a [format string](https://docs.python.org/2/library/string.html#format-string-syntax) in your [ini-file](http://doc.pytest.org/en/latest/customize.html#inifiles):

  3 variables are available:
  * result - place for indicator
  * name - name of test
  * docstring_summary - first line from test docstring if available

  ```ini
      [tool:pytest]
      spec_test_format = {result} {name}
  ```

  or

  ```ini
      [tool:pytest]
      spec_test_format = {result} {docstring_summary}
  ```

  In second example where docstring is not available the name will be added to spec output.



  You can configure the indicator displayed when test passed.

  ```ini
      [tool:pytest]
      spec_success_indicator = ✓
  ```



  You can configure the indicator displated when test failed.

  ```ini
      [tool:pytest]
      spec_failure_indicator = ✗
  ```



  You can configure the indicator displated when test is skipped.

  ```ini
      [tool:pytest]
      spec_skipped_indicator = ?
  ```



  Comma-separated settings to ignore/hide some tests or output from from plugins like FLAKE8 or ISORT.
  Any test which contain provided string will be ignored in output spec.

  ```ini
      [tool:pytest]
      spec_ignore = FLAKE8
  ```



  ```ini
      [tool:pytest]
      spec_indent = "   "
  ```



  [![Tests](https://github.com/pchomik/pytest-spec/workflows/test/badge.svg)](https://github.com/pchomik/pytest-spec/actions)




  All versions of library are available on official [pypi server](https://pypi.org/project/pytest-spec/#history).



  ```sh
      pip install pytest-spec
  ```



  Please feel free to present your idea by code example (pull request) or reported issues.



  * [@0x64746b](https://github.com/0x64746b)
  * [@lucasmarshall](https://github.com/lucasmarshall)
  * [@amcgregor](https://github.com/amcgregor)
  * [@jhermann](https://github.com/jhermann)
  * [@frenzymadness](https://github.com/frenzymadness)
  * [@chrischambers](https://github.com/chrischambers)
  * [@maxalbert](https://github.com/maxalbert)
  * [@jayvdb](https://github.com/jayvdb)



  pytest-spec - pytest plugin to display test execution output like a SPECIFICATION.

  Copyright (C) 2014-2021 Pawel Chomicki

  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 2 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.


pkgId: 17fa5d592eae8b697b1c8aeaf2044b673f17a0cac0c592287382733de03894ee
name: python-pytest-split
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Pytest plugin which splits the test suite to equally sized sub suites based on test execution time.
url: https://jerry-git.github.io/pytest-split
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a6a536bc-14f1-471f-b7c0-3ebc01d4d83d
location_href: 00011127-python-pytest-split/python-pytest-split-0.8.0-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: [https://jerry-git.github.io/pytest-split](https://jerry-git.github.io/pytest-split)
  **Source Code**: [https://github.com/jerry-git/pytest-split](https://github.com/jerry-git/pytest-split)


pkgId: 21fddc3aa622ffd40bd142173099aea247b7d444e31e1ef1cb2ff714b2560266
name: python-pytest-steps
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Create step-wise / incremental tests in pytest.
url: https://github.com/smarie/python-pytest-steps
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f85ad09-6ab9-49d1-a895-eef04836a80c
location_href: 00004863-python-pytest-steps/python-pytest-steps-1.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Python versions](https://img.shields.io/pypi/pyversions/pytest-steps.svg)](https://pypi.python.org/pypi/pytest-steps/) ![Pytest versions](https://img.shields.io/badge/pytest-2%20%7C%203%20%7C%204%20%7C%205%20%7C%206-blue) [![Build Status](https://github.com/smarie/python-pytest-steps/actions/workflows/base.yml/badge.svg)](https://github.com/smarie/python-pytest-steps/actions/workflows/base.yml) [![Tests Status](https://smarie.github.io/python-pytest-steps/reports/junit/junit-badge.svg?dummy=8484744)](https://smarie.github.io/python-pytest-steps/reports/junit/report.html) [![Coverage Status](https://smarie.github.io/python-pytest-steps/reports/coverage/coverage-badge.svg?dummy=8484744)](https://smarie.github.io/python-pytest-steps/reports/coverage/index.html) [![codecov](https://codecov.io/gh/smarie/python-pytest-steps/branch/main/graph/badge.svg)](https://codecov.io/gh/smarie/python-pytest-steps) [![Flake8 Status](https://smarie.github.io/python-pytest-steps/reports/flake8/flake8-badge.svg?dummy=8484744)](https://smarie.github.io/python-pytest-steps/reports/flake8/index.html)

  [![Documentation](https://img.shields.io/badge/doc-latest-blue.svg)](https://smarie.github.io/python-pytest-steps/) [![PyPI](https://img.shields.io/pypi/v/pytest-steps.svg)](https://pypi.python.org/pypi/pytest-steps/) [![Downloads](https://pepy.tech/badge/pytest-steps)](https://pepy.tech/project/pytest-steps) [![Downloads per week](https://pepy.tech/badge/pytest-steps/week)](https://pepy.tech/project/pytest-steps) [![GitHub stars](https://img.shields.io/github/stars/smarie/python-pytest-steps.svg)](https://github.com/smarie/python-pytest-steps/stargazers)

  Create step-wise / incremental tests in `pytest`.

  The documentation for users is available here: [https://smarie.github.io/python-pytest-steps/](https://smarie.github.io/python-pytest-steps/)

  A readme for developers is available here: [https://github.com/smarie/python-pytest-steps](https://github.com/smarie/python-pytest-steps)


pkgId: 1432258f8e71963c6f1e17a82e9582a42a5f139e6801567d570eacd5c5dd6516
name: python-pytest-sugar
arch: src
version: 0.9.6
epoch: 0
release: 1
url: https://pivotfinland.com/pytest-sugar/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c51b843e-d96f-4c37-9ba6-3f72ac8922de
location_href: 00004864-python-pytest-sugar/python-pytest-sugar-0.9.6-1.src.rpm
checksum_type: sha256
summary:
  pytest-sugar is a plugin for pytest that changes the default look and feel of pytest (e.g. progressbar, show tests that fail instantly).

description:
  [![Build status](https://travis-ci.org/Teemu/pytest-sugar.svg?branch=master)](https://travis-ci.org/Teemu/pytest-sugar)
  [![Pypi version](https://img.shields.io/pypi/v/pytest-sugar.svg)](https://pypi.org/project/pytest-sugar/)

  pytest-sugar is a plugin for [pytest](http://pytest.org) that shows
  failures and errors instantly and shows a progress bar.

  ![Demo](https://i.imgur.com/jER0Jxj.gif)



  - [pytest-rich](https://github.com/nicoddemus/pytest-rich)
  - [pytest-pretty](https://github.com/samuelcolvin/pytest-pretty)



  You will need the following prerequisites in order to use pytest-sugar:

  - Python 2.7, 3.4 or newer
  - pytest 2.9.0 or newer
  - pytest-xdist 1.14 or above if you want the progress bar to work while running
    tests in parallel



  To install pytest-sugar:

      pip install pytest-sugar

  Then run your tests with:

      $ pytest

  If you would like more detailed output (one test per line), then you may use the verbose option:

      $ pytest --verbose

  If you would like to run tests without pytest-sugar, use:

      $ pytest -p no:sugar



  If you are seeing gibberish, you might want to try changing charset and fonts. See [this comment]( https://github.com/Teemu/pytest-sugar/pull/49#issuecomment-146567670) for more details.


pkgId: 7fa1f2bcc74ac18e4c4a79a46e67b3e6134d25838ac3821f14a690c1c09da531
name: python-pytest-test-groups
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A Pytest plugin for running a subset of your tests by splitting them in to equally sized groups.
url: https://github.com/mark-adams/pytest-test-groups
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95711187-1197-4428-a697-f0cd56a940fe
location_href: 00011748-python-pytest-test-groups/python-pytest-test-groups-1.0.3-1.src.rpm
checksum_type: sha256
description:
  pytest-test-groups allows you to split your test runs into groups of a specific
  size to make it easier to split up your test runs.


pkgId: dc2649667068db18b1da69138dc72e9dd3a4f59da64849b44208b62b1f594266
name: python-pytest-testinfra
arch: src
version: 7.0.0
epoch: 0
release: 1
summary: Test infrastructures
url: https://github.com/pytest-dev/pytest-testinfra
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-23684731-6e07-4be3-8987-a7ed91b589d7
location_href: 00004865-python-pytest-testinfra/python-pytest-testinfra-7.0.0-1.src.rpm
checksum_type: sha256
description:
  With Testinfra you can write unit tests in Python to test *actual state* of
  your servers configured by management tools like Salt_, Ansible_, Puppet_,
  Chef_ and so on.
  Testinfra aims to be a Serverspec_ equivalent in python and is written as
  a plugin to the powerful Pytest_ test engine


pkgId: 4c1fb4833136bd0e2b1d2ebfba0217dbd46a1e38b7a697149a5296d5f784582d
name: python-pytest-testmon
arch: src
version: 1.4.5
epoch: 0
release: 1
summary: selects tests affected by changed files and methods
url: https://testmon.org
rpm_license: AGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-39deae3d-3981-4317-8142-6ec07fadde4b
location_href: 00004866-python-pytest-testmon/python-pytest-testmon-1.4.5-1.src.rpm
checksum_type: sha256
description:
  <br>
  <img src=https://user-images.githubusercontent.com/135344/189406660-601f16b2-2bb1-4f4d-a764-f7ceed093cb7.svg width=400>

  This is a pytest plug-in which automatically selects and re-executes
  only tests affected by recent changes. How is this possible in dynamic
  language like Python and how reliable is it? Read here: [Determining
  affected tests](https://testmon.org/determining-affected-tests.html)



      pip install pytest-testmon

      
      pytest --testmon

      

      
      pytest --testmon

  To learn more about different options you can use with testmon, please
  head to [testmon.org](https://testmon.org)



  We would like to run testmon within your project, collect data and improve!
  We'll prepare the PR for you and set everything up so that no tests are deselected initially.
  You can start using the full functionality whenever the reliability and time savings seem right!
  Please <a href="https://testmon.org/ci.html">get in touch</a> and we'll contact you shortly.


pkgId: b7e4eb1dee0599861b6992be4dd81f8f28948ad01359bd96568d409ea60024b2
name: python-pytest-testmon
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: selects tests affected by changed files and methods
url: https://testmon.org
rpm_license: AGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03c4818a-6a6d-4a55-9528-7bd1698cd318
location_href: 00008201-python-pytest-testmon/python-pytest-testmon-2.0.6-1.src.rpm
checksum_type: sha256
description:
  <img src=https://user-images.githubusercontent.com/135344/219700265-0a9b152f-7285-4607-bbce-0c9aeddd520b.svg width=300>

  This is a pytest plug-in which automatically selects and re-executes
  only tests affected by recent changes. How is this possible in dynamic
  language like Python and how reliable is it? Read here: [Determining
  affected tests](https://testmon.org/blog/determining-affected-tests/)



      pip install pytest-testmon

      
      pytest --testmon

      

      
      pytest --testmon

  To learn more about different options you can use with testmon, please
  head to [testmon.org](https://testmon.org)



  We would like to run testmon within your project, collect data and improve!
  We'll prepare the PR for you and set everything up so that no tests are deselected initially.
  You can start using the full functionality whenever the reliability and time savings seem right!
  Please <a href="https://testmon.org/ci.html">get in touch</a> and we'll contact you shortly.


pkgId: f5339098a444663df77077f6693ede892f9e6cf9249fe08d019f66e8e4932f12
name: python-pytest-toolbox
arch: src
version: 0.4
epoch: 0
release: 1
summary: Numerous useful plugins for pytest.
url: https://github.com/samuelcolvin/pytest-toolbox
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd72fa2f-b943-4edf-bcd1-1082a2461956
location_href: 00004867-python-pytest-toolbox/python-pytest-toolbox-0.4-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |codecov.io| |PyPI Status| |license|
  Copyright (C) 2016 Samuel Colvin
  Numerous useful plugins for pytest.


pkgId: 1b3642adb14b7b200e14d972e66d8a023b8cad8b47fcdcf879cfc623a86ec787
name: python-pytest-tornado
arch: src
version: 0.8.1
epoch: 0
release: 1
url: https://github.com/eugeniy/pytest-tornado
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-47b2cc80-1059-4002-a522-c778cad0e8b2
location_href: 00004868-python-pytest-tornado/python-pytest-tornado-0.8.1-1.src.rpm
checksum_type: sha256
summary:
  A py.test plugin providing fixtures and markers to simplify testing of asynchronous tornado applications.

description:
  A py.test_ plugin providing fixtures and markers to simplify testing
  of asynchronous tornado applications.


pkgId: 3f29126166f57eb89d2abe55c7cbe208c5ccff98f0d1731c68b7cfdd8fb3caa2
name: python-pytest-trio
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Pytest plugin for trio
url: https://github.com/python-trio/pytest-trio
rpm_license: MIT OR Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-642f6318-abd8-4c5e-95dd-12ae61716252
location_href: 00004869-python-pytest-trio/python-pytest-trio-0.8.0-1.src.rpm
checksum_type: sha256
description:
  This is a pytest plugin to help you test projects that use `Trio
  <https://trio.readthedocs.io/>`__, a friendly library for concurrency
  and async I/O in Python. For an overview of features, see our `manual
  <https://pytest-trio.readthedocs.io>`__, or jump straight to the
  `quickstart guide
  <https://pytest-trio.readthedocs.io/en/latest/quickstart.html>`__.


pkgId: 1c528431991cd68db42cad770e5dd724b6176e97999ab9b6b6801dfea0784021
name: python-pytest-variables
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: pytest plugin for providing variables to tests/fixtures
url: https://github.com/pytest-dev/pytest-variables
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e07c8d8c-d77a-4248-9dcf-374c115b5c0f
location_href: 00011332-python-pytest-variables/python-pytest-variables-2.0.0-1.src.rpm
checksum_type: sha256
description:
  pytest-variables is a plugin for pytest_ that provides variables to
  tests/fixtures as a dictionary via a file specified on the command line.


pkgId: 3fbc228d501457dfc0ec974072c0f7e18252429cac288215fb8c6eaa617b50a9
name: python-pytest-vcr
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Plugin for managing VCR.py cassettes
url: https://github.com/ktosiek/pytest-vcr
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c510ca75-eb09-4d5e-a332-9ab4c4238dee
location_href: 00004870-python-pytest-vcr/python-pytest-vcr-1.0.2-1.src.rpm
checksum_type: sha256
description:
  Install the plugin:
      pip install pytest-vcr
  Annotate your tests:
      @pytest.mark.vcr()
      def test_iana():
          response = urlopen('http://www.iana.org/domains/reserved').read()
          assert b'Example domains' in response
  And that's it!
  A new file ``cassettes/test_iana.yaml`` will be created next to your test file on the first run.
  This file should be committed to a VCS.
  For more examples and configuration options see the `documention on ReadTheDocs <http://pytest-vcr.readthedocs.io/en/latest/>`_.


pkgId: c084a0235d8c4d659cc4bbae5a46431f7d7c50cbc2a913cc756654a2cf4395cc
name: python-pytest-watch
arch: src
version: 4.2.0
epoch: 0
release: 1
summary: Local continuous test runner with pytest and watchdog.
url: http://github.com/joeyespo/pytest-watch
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5bbc6e73-f5c0-4eec-b250-2acfe5c0b132
location_href: 00004872-python-pytest-watch/python-pytest-watch-4.2.0-1.src.rpm
checksum_type: sha256
description:
  `Current version on PyPI <http://pypi.python.org/pypi/pytest-watch/>`__
  `Say Thanks! <https://saythanks.io/to/joeyespo>`__
  **pytest-watch** a zero-config CLI tool that runs
  `pytest <http://pytest.org/>`__, and re-runs it when a file in your
  project changes. It beeps on failures and can run arbitrary commands on
  each passing and failing test run.


pkgId: ec4c4c8d5cbf6d16ec454474c3185289d3ab4442fb23a6c4c069d86713b32037
name: python-python3-nmap
arch: src
version: 1.6.0
epoch: 0
release: 1
url: https://www.nmmapper.com/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e407a13e-58bc-4ccd-8d5d-b07e6f40d8bb
location_href: 00013055-python-python3-nmap/python-python3-nmap-1.6.0-1.src.rpm
checksum_type: sha256
summary:
  Python3-nmap converts Nmap commands into python3 methods making it very easy to use nmap in any of your python pentesting projects

description:
  A python 3  library which helps in using nmap port scanner. The way this tools works is by defining each nmap command into a python function making it very easy to use sophisticated nmap commands in other python scripts. Nmap is a complicated piece of software used for reconnaissance on target networks, over the years new features have been added making it more sophisticated.

  With this python3-nmap we make using nmap in python very easy and painless

  For example in nmap if you want to scan for common ports you would to something like this
  ```sh
  $ nmap your-host.com --top-ports 10
  ```
  But in this python3-nmap  script you would do something like this
  ```py
  import nmap3
  nmap = nmap3.Nmap()
  results = nmap.scan_top_ports("your-host.com")

  ```
  You will notice each nmap command is defined as a python function/method. this make it easy to remember this in python and easily use them.

  Again in nmap if you want to use the famous dns-brute script you would do something like this
  ```sh
  $ nmap your-host.com  --script dns-brute.nse
  ```
  But in this python3 script again it's very easy you just do something like this
  ```py
  import nmap3
  nmap = nmap3.Nmap()
  results = nmap.nmap_dns_brute_script("your-host.com")


  [
      {
          "address": "mail.your-host.com",
          "hostname": "68.65.122.10"
      },
      {
          "address": "www.your-host.com",
          "hostname": "5.189.129.43"
      }
  ]
  ```


  Using this scripts is very easy, though it assumes you have nmap already installed, as it is the primary dependence required. Also this tools supports both windows and linux, it's cross platform so to say.

  **Installation**
  ```sh
  $ git clone https://github.com/wangoloj/python3-nmap.git

  $ pip3 install -r requirements.txt



  $ apt-get install nmap


  ```
  In nmap some commands require root privileges for example the command to identify OS requires root privileges;
  ```sh
  $ nmap -O your-host.com

  TCP/IP fingerprinting (for OS scan) requires root privileges.
  QUITTING!


  $ sudo nmap -O your-host.com

  ```
  The same applies to the script to be able to run the os identifier  you have to be a super user.


  ```py
  import nmap3
  nmap = nmap3.Nmap()
  os_results = nmap.nmap_os_detection("192.168.178.2") # MOST BE ROOT
  ```
  ```json
  [
      {
          "accuracy": "100",
          "cpe": "cpe:/o:linux:linux_kernel:2.6",
          "line": "45249",
          "name": "Linux 2.6.14 - 2.6.34",
          "osclass": {
              "accuracy": "100",
              "osfamily": "Linux",
              "osgen": "2.6.X",
              "type": "general purpose",
              "vendor": "Linux"
          }
      },
      {
          "accuracy": "100",
          "cpe": "cpe:/o:linux:linux_kernel:2.6.17",
          "line": "45775",
          "name": "Linux 2.6.17",
          "osclass": {
              "accuracy": "100",
              "osfamily": "Linux",
              "osgen": "2.6.X",
              "type": "general purpose",
              "vendor": "Linux"
          }
      },
      {
          "accuracy": "100",
          "cpe": "cpe:/o:linux:linux_kernel:2.6.17",
          "line": "45811",
          "name": "Linux 2.6.17 (Mandriva)",
          "osclass": {
              "accuracy": "100",
              "osfamily": "Linux",
              "osgen": "2.6.X",
              "type": "general purpose",
              "vendor": "Linux"
          }
      },
      {
          "accuracy": "100",
          "cpe": "cpe:/o:linux:linux_kernel:3.13",
          "line": "60884",
          "name": "Linux 3.13",
          "osclass": {
              "accuracy": "100",
              "osfamily": "Linux",
              "osgen": "3.X",
              "type": "general purpose",
              "vendor": "Linux"
          }
      }
  ]
  ```


  The script is made of up the following classes, each holding different nmap abilities and scan types.

   - Nmap
   - NmapHostDiscovery
   - NmapScanTechniques


  In nmap if you want to identify versions you would run this kind of command
  ```sh
  $ nmap 192.168.178.1  -sV
  ```
  In this python script you would do something like this
  ```py
  import nmap3
  nmap = nmap3.Nmap()
  version_result = nmap.nmap_version_detection("your-host.com")
  ```
  ```json
  [
      {
          "cpe": [
              {
                  "cpe": "cpe:/o:linux:linux_kernel"
              }
          ],
          "port": "80",
          "protocol": "tcp",
          "service": {
              "conf": "10",
              "extrainfo": "Ubuntu",
              "method": "probed",
              "name": "http",
              "ostype": "Linux",
              "product": "nginx",
              "version": "1.14.0"
          }
      },
      {
          "cpe": [
              {
                  "cpe": "cpe:/o:linux:linux_kernel"
              }
          ],
          "port": "443",
          "protocol": "tcp",
          "service": {
              "conf": "10",
              "extrainfo": "Ubuntu",
              "method": "probed",
              "name": "http",
              "ostype": "Linux",
              "product": "nginx",
              "tunnel": "ssl",
              "version": "1.14.0"
          }
      },
      {
          "cpe": [
              {
                  "cpe": "cpe:/o:linux:linux_kernel"
              }
          ],
          "port": "2000",
          "protocol": "tcp",
          "service": {
              "conf": "10",
              "extrainfo": "Ubuntu Linux; protocol 2.0",
              "method": "probed",
              "name": "ssh",
              "ostype": "Linux",
              "product": "OpenSSH",
              "version": "7.6p1 Ubuntu 4ubuntu0.3"
          }
      }
  ]
  ```

  The following nmaps commands have been added to the following scripts

   - get Nmap version details
     ```python
     import nmap3
     nmap = nmap3.Nmap()
     results = nmap.nmap_version()
     ```
   - Nmap top port scan
     ```python
     import nmap3
     nmap = nmap3.Nmap()
     results = nmap.scan_top_ports("your-host")
     ```
   - Nmap Dns-brute-script( to get subdomains )
   ```python
      import nmap3
      nmap = nmap3.Nmap()
      results = nmap.nmap_dns_brute_script("domain")
    ```
   - Nmap list scan
   ```python
      import nmap3
      nmap = nmap3.Nmap()
      results = nmap.nmap_list_scan("your-host")
   ```
   - Nmap Os detection
   ```python
     import nmap3
     nmap = nmap3.Nmap()
     results = nmap.nmap_os_detection("your-host");
   ```
   - Nmap subnet scan
   ```python
      import nmap3
      nmap = nmap3.Nmap()
      results = nmap.nmap_subnet_scan("your-host") #Must be root
   ```
   - Nmap version detection
  ```python
     import nmap3
     nmap = nmap3.Nmap()
     results = nmap.nmap_version_detection("your-host") # Must be root
  ```


  The script offers nmap scan techniques also as python function/methods
   - nmap_fin_scan
     ```python
     import nmap3
     nmap = nmap3.NmapScanTechniques()
     result = nmap.nmap_fin_scan("192.168.178.1")
     ```

   - nmap_idle_scan
   ```python
      import nmap3
      nmap = nmap3.NmapScanTechniques()
      result = nmap.nmap_idle_scan("192.168.178.1")
   ```
   - nmap_ping_scan
   ```python
      import nmap3
      nmap = nmap3.NmapScanTechniques()
      result = nmap.nmap_ping_scan("192.168.178.1")
   ```
   - nmap_syn_scan
   ```python
      import nmap3
      nmap = nmap3.NmapScanTechniques()
      result = nmap.nmap_syn_scan("192.168.178.1")
   ```
   - nmap_tcp_scan
   ```python
      import nmap3
      nmap = nmap3.NmapScanTechniques()
      result = nmap.nmap_tcp_scan("192.168.178.1")
   ```

  - nmap_udp_scan
   ```python
      import nmap3
      nmap = nmap3.NmapScanTechniques()
      result = nmap.nmap_udp_scan("192.168.178.1")
   ```

  The script also offers support for map Added Nmap Host discovery techniques still as python function/methods

   - Only port scan    (-Pn)
   - Only host discover    (-sn)
   - Arp discovery on a local network  (-PR)
   - Disable DNS resolution    (-n)

  NmapHostDiscovery

   -  `def nmap_portscan_only(self, host, args=None)`
   ```python
      import nmap3
      nmap = nmap3.NmapHostDiscovery()
      results = nmap.nmap_portscan_only("your-host")
   ```
   -  `def nmap_no_portscan(self, host, args=None):`
   ```python
      import nmap3
      nmap = nmap3.NmapHostDiscovery()
      results = nmap.nmap_no_portscan("your-host")
   ```
   -  `def nmap_arp_discovery(self, host, args=None):`
    ```python
      import nmap3
      nmap = nmap3.NmapHostDiscovery()
      results = nmap.nmap_arp_discovery("your-host")
   ```
   -  `def nmap_disable_dns(self, host, args=None):`
    ```python
      import nmap3
      nmap = nmap3.NmapHostDiscovery()
      results = nmap.nmap_disable_dns("your-host")
   ```

  Nmap is a large tool, as you can see python3-nmap provides only things what you could say commonly used nmap features.


  As we said, the script defines each set of nmap command as python function/methods. You can also pass arguments to those methods/function thus extending your capabilities for example.
  Let's say we want to scan top ports but also perform version detection .

  ```python
     import nmap3
     nmap = nmap3.Nmap()
     results = nmap.scan_top_ports("host", args="-sV")
  ```


  You scan the the target IP using version detection ('-sV') to get the service and, the script performs a lookup in the CVE database. The nmap vulners script is part of the default Nmap installation, so you shouldn't need to install any other packages.

  ```python
     import nmap3
     nmap = nmap3.Nmap()
     ressults = nmap_version_detection("host", args="--script vulners --script-args mincvss+5.0")
  ```


  * [Ethical-tools](https://ethicaltools.gitbook.io/subdomainfinder/)
  * [Wappalyzer online](https://www.nmmapper.com/st/cms-detection/wappalyzer-online/)
  * [Whatweb online](https://www.nmmapper.com/tools/cms-detection/whatweb-online/WhatWeb/)
  * [Raccoon By Offensive security](https://www.nmmapper.com/tools/reconnaissance-tools/raccoon-vulnerability-scanning/Raccoon%20tool/)
  * [Detect WAF](https://www.nmmapper.com/tools/reconnaissance-tools/waf/web-application-firewall-detector/)
  * [Dnsdumpster](https://dnsdumpster.readthedocs.io/)
  * [Become a patreon](https://www.patreon.com/nmmapper)
  * [Online port scanner](https://www.nmmapper.com/st/networkmapper/nmap/online-port-scanning/)


pkgId: 881293bb7ff8750604cb9717c9a6e31c7a49f57a2ad47bff8f560bf477ca9b39
name: python-python3-openid
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: OpenID support for modern servers and consumers.
url: http://github.com/necaris/python3-openid
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d30d7e29-0a68-47eb-b985-f9cc1e1c83b0
location_href: 00009394-python-python3-openid/python-python3-openid-3.2.0-1.src.rpm
checksum_type: sha256
description:
  This is a set of Python packages to support use of
  the OpenID decentralized identity system in your application, update to Python
  3.  Want to enable single sign-on for your web site?  Use the openid.consumer
  package.  Want to run your own OpenID server? Check out openid.server.
  Includes example code and support for a variety of storage back-ends.


pkgId: 1e8af7ade8849f65a43b47cfcb40bd5616f4de5ec79903f0e3405bb0c3c03a1a
name: python-pythonping
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: A simple way to ping in Python
url: https://github.com/alessandromaggio/pythonping
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-be7a8e06-56e2-4995-854c-72c9cd3d5c8e
location_href: 00011608-python-pythonping/python-pythonping-1.1.4-1.src.rpm
checksum_type: sha256
description:
  PythonPing is simple way to ping in Python. With it, you can send ICMP Probes to remote devices like
  you would do from the terminal. PythonPing is modular, so that you can run it in a script as a
  standalone function, or integrate its components in a fully-fledged application.


  The simplest usage of PythonPing is in a script. You can use the `ping` function to ping a target.
  If you want to see the output immediately, emulating what happens on the terminal, use the
  `verbose` flag as below.

  ```python
  from pythonping import ping

  ping('127.0.0.1', verbose=True)
  ```
  This will yeld the following result.
  ```
  Reply from 127.0.0.1, 9 bytes in 0.17ms
  Reply from 127.0.0.1, 9 bytes in 0.14ms
  Reply from 127.0.0.1, 9 bytes in 0.12ms
  Reply from 127.0.0.1, 9 bytes in 0.12ms
  ```

  Regardless of the verbose mode, the `ping` function will always return a `ResponseList` object.
  This is a special iterable object, containing a list of `Response` items. In each response, you can
  find the packet received and some meta information, like the time it took to receive the response
  and any error message.

  You can also tune your ping by using some of its additional parameters:
  * `size` is an integer that allows you to specify the size of the ICMP payload you desire
  * `timeout` is the number of seconds you wish to wait for a response, before assuming the target
  is unreachable
  * `payload` allows you to use a specific payload (bytes)
  * `count` specify allows you to define how many ICMP packets to send
  * `interval` the time to wait between pings, in seconds
  * `sweep_start` and `sweep_end` allows you to perform a ping sweep, starting from payload size
  defined in `sweep_start` and growing up to size defined in `sweep_end`. Here, we repeat the payload
  you provided to match the desired size, or we generate a random one if no payload was provided.
  Note that if you defined `size`, these two fields will be ignored
  * `df` is a flag that, if set to True, will enable the *Don't Fragment* flag in the IP header
  * `verbose` enables the verbose mode, printing output to a stream (see `out`)
  * `out` is the target stream of verbose mode. If you enable the verbose mode and do not provide
  `out`, verbose output will be send to the `sys.stdout` stream. You may want to use a file here.
  * `match` is a flag that, if set to True, will enable payload matching between a ping request
  and reply (default behaviour follows that of Windows which counts a successful reply by a
  matched packet identifier only; Linux behaviour counts a non equivalent payload with a matched
  packet identifier in reply as fail, such as when pinging 8.8.8.8 with 1000 bytes and the reply
  is truncated to only the first 74 of request payload with a matching packet identifier)



  Yes, you need to be root to use pythonping.


  All operating systems allow programs to create TCP or UDP sockets without requiring particular
  permissions. However, ping runs in ICMP (which is neither TCP or UDP). This means we have to create
  raw IP packets, and sniff the traffic on the network card.
  **Operating systems are designed to require root for such operations**. This is because having
  unrestricted access to the NIC can expose the user to risks if the application running has bad
  intentions. This is not the case with pythonping of course, but nonetheless we need this capability
  to create custom IP packets. Unfortunately, there is simply no other way to create ICMP packets.


  If you wish to extend PythonPing, or integrate it in your application, we recommend to use the
  classes that are part of Python Ping instead of the `ping` function. `executor.Communicator`
  handles the communication with the target device, it takes care of sending ICMP requests and
  processing responses (note that for it to be thread safe you must then handle making a unique
  seed ID for each thread instance, see ping.__init\__ for an example of this). It ultimately
  produces the `executor.ResponseList` object. The `Communicator` needs to know a target and
  which payloads to send to the remote device. For that, we have several classes in the
  `payload_provider` module. You may want to create your own provider by extending
  `payload_provider.PayloadProvider`. If you are interested in that, you should check the
  documentation of both `executor` and `payload_provider` module.




  Our project directory structure contains all src files in the pythonping folder, test cases in another folder, and helping documentation in on the top level directory.

  ```
  .
  ├── pythonping              # Source files
  ├── test                    # Automated Testcases for the package
  ├── CODE_OF_CONDUCT         # An md file containing code of conduct
  ├── CONTRIBUTING            # Contributing Guidlins
  ├── LICENSE                 # MIT License
  ├── README.md               # An md file
  └── setup.py                # Instalation
  ```

  A UML Diagram of the code structure is below:

  ![ER1](https://raw.githubusercontent.com/alessandromaggio/pythonping/master/docs/UML-Diagram.png)

  As per the uml diagram above five distinct classes outside of init exist in this package: Executor, Icmp, Payload Provider, and Utils. Each of them rely on attributes which have been listed as sub-classes for brevities sake. An overview of each class is as follows.


  Simply generates random text. See function random_text.


  Opens a socket to send and recive data. See functions send, recv, and del.


  Generates ICMP Payloads with no Headers. It's functionaly a interface. It has three
  functions init, iter, and next, which are all implmented by subclasses List, Repeat, and Sweep which store payloads in diffrent lists.


  Generates the ICMP heaser through subclass ICMPType, and various helper functions.


  Has various subclasses including Message, Response, Success, and Communicator used for sending icmp packets and collecting data.


  Uses network, executor, payload_provider and utils.random_text to construct and send ICMP packets to ping a network.


  A test package exists under the folder test, and contains a serise of unit tests. Before commiting changes make sure to run the test bench and make sure all corrisponding cases pass. For new functionality new test cases must be added and documented.

  To run testcases we can simply use the ```unitest discover``` utility by running the following command:

  ```
  python -m unittest discover <test_directory>
  ```

  To run the test cases in a specific file FILE we must run the following command:

  ```
  python -m unittest discover -s <test_directory> -p FILE
  ```

  Another option is to run the following from the top level directory:

  ```
  pytest test
  ```

  To test for coverage simply run:

  ```
  coverage run -m pytest test
  ```


  Before contributing read through the contribution guidlines found the CONTRIBUTING file.


  A few key points when contributing to this repo are as follows:
  1. Use tabs over spaces.
  2. Format doc strings as such:
      ```
      DESCRIPTION

          :param X: DESCRIPTION
          :type X: Type
          :param Y: DESCRIPTION
          :type Y: Type
      ```
      Please add doc strings to all functions added.
  3. Do not add spaces between docstring and first function line.
  4. Do not go over 200 characters per line.
  5. When closing multiline items under brackets('()', '[]', ... etc) put the closing bracket on it's own line.


pkgId: 1410aa9ed6f660c45785116c6e3ef73b30c9bdb5cd1c6fb954ea634fe4115245
name: python-pythreejs
arch: src
version: 2.4.2
epoch: 0
release: 1
url: https://github.com/jupyter-widgets/pythreejs
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-031f0df6-c913-404b-8d91-6c69f8791c1b
location_href: 00013523-python-pythreejs/python-pythreejs-2.4.2-1.src.rpm
checksum_type: sha256
summary:
  Interactive 3D graphics for the Jupyter Notebook and JupyterLab, using Three.js and Jupyter Widgets.

description:
  [![Interactive demo on Binder][binder-badge]][binder]
  [![Install from PyPI][pypi-badge]][pypi]
  [![Install from conda-forge][cf-badge]][cf]
  [![Reuse from npm][npm-badge]][npm]
  [![Documentation Status][docs-badge]][docs]
  [![Build Status][ci-badge]][ci]

  A Python / ThreeJS bridge for [Jupyter Widgets][widgets].

  ![Screencast]

  [binder-badge]: https://mybinder.org/badge_logo.svg
  [binder]: https://mybinder.org/v2/gh/jupyter-widgets/pythreejs/HEAD?urlpath=lab%2Ftree%2Fexamples%2FExamples.ipynb
  [pypi-badge]: https://img.shields.io/pypi/v/pythreejs?logo=pypi
  [pypi]: https://pypi.org/project/pythreejs
  [cf-badge]: https://img.shields.io/conda/vn/conda-forge/pythreejs?logo=conda-forge
  [cf]: https://anaconda.org/conda-forge/pythreejs
  [npm-badge]: https://img.shields.io/npm/v/jupyter-threejs?logo=npm
  [npm]: https://www.npmjs.com/package/jupyter-threejs
  [docs-badge]: https://readthedocs.org/projects/pythreejs/badge/?version=stable
  [docs]: https://pythreejs.readthedocs.io/en/stable
  [ci-badge]: https://github.com/jupyter-widgets/pythreejs/actions/workflows/ci.yml/badge.svg
  [ci]: https://github.com/jupyter-widgets/pythreejs/actions/workflows/ci.yml?query=branch%3Amaster
  [widgets]: https://jupyter.org/widgets
  [screencast]: https://raw.githubusercontent.com/jupyter-widgets/pythreejs/master/screencast.gif



  Using `pip`:

  ```bash
  pip install pythreejs
  ```

  or `conda`:

  ```bash
  conda install -c conda-forge pythreejs
  ```

  > For a development install, see the [contributing guide][contributing].

  The extension should then be installed automatically for your Jupyter client.

  > For JupyterLab `<3`, you may also need to ensure `nodejs` is installed, and
  > rebuild the application:
  >
  > ```bash
  > # conda install -c cond-forge 'nodejs>=12'
  > jupyter lab build
  > ```

  [contributing]: https://github.com/jupyter-widgets/pythreejs/blob/master/CONTRIBUTING.md



  If the extension is not automatically installed, you can manually enable it



  ```bash
  jupyter nbextension list
  jupyter nbextension install --py --symlink --sys-prefix pythreejs
  jupyter nbextension enable --py --sys-prefix pythreejs
  jupyter nbextension list
  ```

  You should see:

  ```bash
  Known nbextensions:
    ...
    jupyter-js-widgets/extension  enabled
      - Validating: OK
  ```

  > Note for developers: the `--symlink` argument on Linux or MacOS allows one to
  > modify the JavaScript code in-place. This feature is not available on Windows.



  To perform a _source installation_:

  ```bash


  jupyter labextension list
  jupyter labextension install --no-build @jupyter-widgets/jupyterlab-manager
  jupyter labextension install --no-build jupyter-datawidgets/extension
  jupyter labextension install jupyter-threejs
  jupyter labextension list
  ```

  You should see:

  ```bash
  JupyterLab v...
    ...
      jupyterlab-datawidgets v... enabled OK
      @jupyter-widgets/jupyterlab-manager v... enabled OK
      jupyter-threejs v... enabled OK

  ```

  > This approach is _not recommended_ for JupyterLab 3, which enables
  > _federated modules_, installed via `pip`, `conda` or other package managers,
  > and does not require rebuilding the entire application.



  Using `pip`:

  ```bash
  pip uninstall pythreejs
  ```

  or `conda`:

  ```bash
  conda uninstall pythreejs
  ```

  > If you applied any manual steps above, it may be necessary to remove the



  ```bash
  jupyter nbextension disable --py --sys-prefix pythreejs
  ```



  ```bash
  jupyter labextension uninstall jupyter-threejs
  ```



  This software is licensed under the [BSD-3-Clause][] License.

  [bsd-3-clause]: https://github.com/jupyter-widgets/pythreejs/blob/master/LICENSE


pkgId: 43cd3ce47831a087539d8c309177e0ccb90f8295dfad48077d0e6f32a7da135f
name: python-pytile
arch: src
version: 2022.10.0
epoch: 0
release: 1
summary: A simple Python API for Tile® Bluetooth trackers
url: https://github.com/bachya/pytile
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-13f61460-0255-4d31-a674-f7a33146bd74
location_href: 00004875-python-pytile/python-pytile-2022.10.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bachya/pytile/workflows/CI/badge.svg)](https://github.com/bachya/pytile/actions)
  [![PyPi](https://img.shields.io/pypi/v/pytile.svg)](https://pypi.python.org/pypi/pytile)
  [![Version](https://img.shields.io/pypi/pyversions/pytile.svg)](https://pypi.python.org/pypi/pytile)
  [![License](https://img.shields.io/pypi/l/pytile.svg)](https://github.com/bachya/pytile/blob/main/LICENSE)
  [![Code Coverage](https://codecov.io/gh/bachya/pytile/branch/dev/graph/badge.svg)](https://codecov.io/gh/bachya/pytile)
  [![Maintainability](https://api.codeclimate.com/v1/badges/71eb642c735e33adcdfc/maintainability)](https://codeclimate.com/github/bachya/pytile/maintainability)
  [![Say Thanks](https://img.shields.io/badge/SayThanks-!-1EAEDB.svg)](https://saythanks.io/to/bachya)

  <a href="https://www.buymeacoffee.com/bachya1208P" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174"></a>

  `pytile` is a simple Python library for retrieving information on
  [Tile® Bluetooth trackers](https://www.thetileapp.com/en-us/) (including last
  location and more).

  This library is built on an unpublished, unofficial Tile API; it may alter or
  cease operation at any point.

  - [Python Versions](#python-versions)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Contributing](#contributing)



  Version 5.0.0 is a complete re-architecture of `pytile` – as such, the API has changed.
  Please read the documentation carefully!



  `pytile` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  ```bash
  pip install pytile
  ```





  `pytile` usage starts with an [`aiohttp`](https://github.com/aio-libs/aiohttp) `ClientSession` –
  note that this ClientSession is required to properly authenticate the library:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login("<EMAIL>", "<PASSWORD>", session)


  asyncio.run(main())
  ```

  If for some reason you need to use a specific client UUID (to, say, ensure that the
  Tile API sees you as a client it's seen before) or a specific locale, you can do
  so easily:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login(
              "<EMAIL>", "<PASSWORD>", session, client_uuid="MY_UUID", locale="en-GB"
          )


  asyncio.run(main())
  ```



  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login("<EMAIL>", "<PASSWORD>", session)

          tiles = await api.async_get_tiles()


  asyncio.run(main())
  ```

  The `async_get_tiles` coroutine returns a dict with Tile UUIDs as the keys and `Tile`
  objects as the values.



  The Tile object comes with several properties:

  - `accuracy`: the location accuracy of the Tile
  - `altitude`: the altitude of the Tile
  - `archetype`: the internal reference string that describes the Tile's "family"
  - `dead`: whether the Tile is inactive
  - `firmware_version`: the Tile's firmware version
  - `hardware_version`: the Tile's hardware version
  - `kind`: the kind of Tile (e.g., `TILE`, `PHONE`)
  - `last_timestamp`: the timestamp at which the current attributes were received
  - `latitude`: the latitude of the Tile
  - `longitude`: the latitude of the Tile
  - `lost`: whether the Tile has been marked as "lost"
  - `lost_timestamp`: the timestamp at which the Tile was last marked as "lost"
  - `name`: the name of the Tile
  - `uuid`: the Tile UUID
  - `visible`: whether the Tile is visible in the mobile app

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login("<EMAIL>", "<PASSWORD>", session)

          tiles = await api.async_get_tiles()

          for tile_uuid, tile in tiles.items():
              print(f"The Tile's name is {tile.name}")
              


  asyncio.run(main())
  ```

  In addition to these properties, the `Tile` object comes with an `async_update` coroutine
  which requests new data from the Tile cloud API for this Tile:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login("<EMAIL>", "<PASSWORD>", session)

          tiles = await api.async_get_tiles()

          for tile_uuid, tile in tiles.items():
              await tile.async_update()


  asyncio.run(main())
  ```



  1. [Check for open features/bugs](https://github.com/bachya/pytile/issues)
     or [initiate a discussion on one](https://github.com/bachya/pytile/issues/new).
  2. [Fork the repository](https://github.com/bachya/pytile/fork).
  3. (_optional, but highly recommended_) Create a virtual environment: `python3 -m venv .venv`
  4. (_optional, but highly recommended_) Enter the virtual environment: `source ./.venv/bin/activate`
  5. Install the dev environment: `script/setup`
  6. Code your new feature or bug fix.
  7. Write tests that cover your new functionality.
  8. Run tests and ensure 100% code coverage: `poetry run pytest --cov pytile tests`
  9. Update `README.md` with any new documentation.
  10. Add yourself to `AUTHORS.md`.
  11. Submit a pull request!


pkgId: 812651c5725fe13f96b40ae5d32cd60370cc6ea98cde024f2aae98d03425f7b2
name: python-pytoml
arch: src
version: 0.1.21
epoch: 0
release: 1
summary: A parser for TOML-0.4.0
url: https://github.com/avakar/pytoml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-33f0dfdb-7c5e-466b-8711-77e9a8f092d6
location_href: 00010103-python-pytoml/python-pytoml-0.1.21-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pytoml.svg)](https://pypi.python.org/pypi/pytoml)
  [![Build Status](https://travis-ci.org/avakar/pytoml.svg?branch=master)](https://travis-ci.org/avakar/pytoml)



  The pytoml project is no longer being actively maintained. Consider using the
  [toml](https://github.com/uiri/toml) package instead.



  This project aims at being a specs-conforming and strict parser and writer for [TOML][1] files.
  The library currently supports [version 0.4.0][2] of the specs and runs with Python 2.7+ and 3.5+.

  Install:

      pip install pytoml

  The interface is the same as for the standard `json` package.

      >>> import pytoml as toml
      >>> toml.loads('a = 1')
      {'a': 1}
      >>> with open('file.toml', 'rb') as fin:
      ...     obj = toml.load(fin)
      >>> obj
      {'a': 1}

  The `loads` function accepts either a bytes object
  (that gets decoded as UTF-8 with no BOM allowed),
  or a unicode object.

  Use `dump` or `dumps` to serialize a dict into TOML.

      >>> print toml.dumps(obj)
      a = 1



  To run the tests update the `toml-test` submodule:

      git submodule update --init --recursive

  Then run the tests:

      python test/test.py

    [1]: https://github.com/toml-lang/toml
    [2]: https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md


pkgId: 822b2ab65b940a4bbccac76730fa2b8125b5421d78701356801955d5bf222a23
name: python-pytools
arch: src
version: 2022.1.14
epoch: 0
release: 1
summary: A collection of tools for Python
url: http://pypi.python.org/pypi/pytools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5833d597-19b8-4e3c-9244-3beaae84aac9
location_href: 00004877-python-pytools/python-pytools-2022.1.14-1.src.rpm
checksum_type: sha256
description:
  Pytools is a big bag of things that are "missing" from the Python standard
  library. This is mainly a dependency of my other software packages, and is
  probably of little interest to you unless you use those. If you're curious
  nonetheless, here's what's on offer:
  * A ton of small tool functions such as `len_iterable`, `argmin`,
    tuple generation, permutation generation, ASCII table pretty printing,
    GvR's monkeypatch_xxx() hack, the elusive `flatten`, and much more.
  * A time-series logging module, `pytools.log`.
  * Batch job submission, `pytools.batchjob`.
  * A lexer, `pytools.lex`.
  Links:
  * `Documentation <https://documen.tician.de/pytools>`_
  * `Github <https://github.com/inducer/pytools>`_
  * ``pytools.log`` has been spun out into a separate project,
    `logpyle <https://github.com/illinois-ceesd/logpyle>`__.


pkgId: 2e989571dd81787b7d83e4c231d2e41f54eaa1aaa77ade488fd48fae54ba47ad
name: python-pytorch-ignite
arch: src
version: 0.4.11
epoch: 0
release: 1
summary: A lightweight library to help with training neural networks in PyTorch.
url: https://github.com/pytorch/ignite
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c8d371f-f483-411a-b379-be6939030ce8
location_href: 00011212-python-pytorch-ignite/python-pytorch-ignite-0.4.11-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <!-- ![Ignite Logo](assets/logo/ignite_logo_mixed.svg) -->

  <img src="https://raw.githubusercontent.com/pytorch/ignite/master/assets/logo/ignite_logo_mixed.svg" width=512>

  <!-- [![image](https://travis-ci.com/pytorch/ignite.svg?branch=master)](https://travis-ci.com/pytorch/ignite) -->

  | ![image](https://img.shields.io/badge/-Tests:-black?style=flat-square) [![image](https://github.com/pytorch/ignite/workflows/Run%20unit%20tests/badge.svg)](https://github.com/pytorch/ignite/actions) [![image](https://img.shields.io/badge/-GPU%20tests-black?style=flat-square)](https://app.circleci.com/pipelines/github/pytorch/ignite?branch=master)[![image](https://circleci.com/gh/pytorch/ignite.svg?style=svg)](https://app.circleci.com/pipelines/github/pytorch/ignite?branch=master) [![image](https://codecov.io/gh/pytorch/ignite/branch/master/graph/badge.svg)](https://codecov.io/gh/pytorch/ignite) [![image](https://img.shields.io/badge/dynamic/json.svg?label=docs&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fpytorch-ignite%2Fjson&query=%24.info.version&colorB=brightgreen&prefix=v)](https://pytorch.org/ignite/index.html) |
  |:---
  | ![image](https://img.shields.io/badge/-Stable%20Releases:-black?style=flat-square) [![image](https://anaconda.org/pytorch/ignite/badges/version.svg)](https://anaconda.org/pytorch/ignite) [![image](https://anaconda.org/pytorch/ignite/badges/downloads.svg)](https://anaconda.org/pytorch/ignite) [![image](https://img.shields.io/badge/dynamic/json.svg?label=PyPI&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fpytorch-ignite%2Fjson&query=%24.info.version&colorB=brightgreen&prefix=v)](https://pypi.org/project/pytorch-ignite/) [![image](https://pepy.tech/badge/pytorch-ignite)](https://pepy.tech/project/pytorch-ignite) |
  | ![image](https://img.shields.io/badge/-Nightly%20Releases:-black?style=flat-square) [![image](https://anaconda.org/pytorch-nightly/ignite/badges/version.svg)](https://anaconda.org/pytorch-nightly/ignite) [![image](https://img.shields.io/badge/PyPI-pre%20releases-brightgreen)](https://pypi.org/project/pytorch-ignite/#history)|
  | ![image](https://img.shields.io/badge/-Features:-black?style=flat-square) [![image](https://img.shields.io/badge/docker-hub-blue)](https://hub.docker.com/u/pytorchignite) [![image](https://img.shields.io/badge/Optuna-integrated-blue)](https://optuna.org) [![image](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) |
  | ![image](https://img.shields.io/badge/-Community:-black?style=flat-square) [![Twitter](https://img.shields.io/badge/news-twitter-blue)](https://twitter.com/pytorch_ignite) [![facebook](https://img.shields.io/badge/news-facebook-blue)](https://www.facebook.com/PyTorch-Ignite-Community-105837321694508) [![numfocus](https://img.shields.io/badge/NumFOCUS-affiliated%20project-green)](https://numfocus.org/sponsored-projects/affiliated-projects) [![discord](https://img.shields.io/badge/chat-discord-blue?logo=discord)](https://discord.gg/djZtm3EmKj) |
  | ![image](https://img.shields.io/badge/-Supported_PyTorch/Python_versions:-black?style=flat-square) [![link](https://img.shields.io/badge/-check_here-blue)](https://github.com/pytorch/ignite/actions?query=workflow%3A%22PyTorch+version+tests%22)|

  </div>



  Ignite is a high-level library to help with training and evaluating neural networks in PyTorch flexibly and transparently.

  <div align="center">

  <a href="https://colab.research.google.com/github/pytorch/ignite/blob/master/assets/tldr/teaser.ipynb">
   <img alt="PyTorch-Ignite teaser"
        src="https://raw.githubusercontent.com/pytorch/ignite/master/assets/tldr/pytorch-ignite-teaser.gif"
        width=532>
  </a>

  _Click on the image to see complete code_

  </div>



  - [Less code than pure PyTorch](https://raw.githubusercontent.com/pytorch/ignite/master/assets/ignite_vs_bare_pytorch.png)
    while ensuring maximum control and simplicity

  - Library approach and no program's control inversion - _Use ignite where and when you need_

  - Extensible API for metrics, experiment managers, and other components

  <!-- ############################################################################################################### -->



  - [Table of Contents](#table-of-contents)
  - [Why Ignite?](#why-ignite)
    - [Simplified training and validation loop](#simplified-training-and-validation-loop)
    - [Power of Events & Handlers](#power-of-events--handlers)
      - [Execute any number of functions whenever you wish](#execute-any-number-of-functions-whenever-you-wish)
      - [Built-in events filtering](#built-in-events-filtering)
      - [Stack events to share some actions](#stack-events-to-share-some-actions)
      - [Custom events to go beyond standard events](#custom-events-to-go-beyond-standard-events)
    - [Out-of-the-box metrics](#out-of-the-box-metrics)
  - [Installation](#installation)
    - [Nightly releases](#nightly-releases)
    - [Docker Images](#docker-images)
      - [Using pre-built images](#using-pre-built-images)
  - [Getting Started](#getting-started)
  - [Documentation](#documentation)
    - [Additional Materials](#additional-materials)
  - [Examples](#examples)
    - [Tutorials](#tutorials)
    - [Reproducible Training Examples](#reproducible-training-examples)
  - [Communication](#communication)
    - [User feedback](#user-feedback)
  - [Contributing](#contributing)
  - [Projects using Ignite](#projects-using-ignite)
  - [Citing Ignite](#citing-ignite)
  - [About the team & Disclaimer](#about-the-team--disclaimer)

  <!-- ############################################################################################################### -->



  Ignite is a **library** that provides three high-level features:

  - Extremely simple engine and event system
  - Out-of-the-box metrics to easily evaluate models
  - Built-in handlers to compose training pipeline, save artifacts and log parameters and metrics



  No more coding `for/while` loops on epochs and iterations. Users instantiate engines and run them.

  <details>
  <summary>
  Example
  </summary>

  ```python
  from ignite.engine import Engine, Events, create_supervised_evaluator
  from ignite.metrics import Accuracy



  def train_step(engine, batch):
      
      
      

  trainer = Engine(train_step)


  evaluator = create_supervised_evaluator(model, metrics={"accuracy": Accuracy()})

  def validation():
      state = evaluator.run(validation_data_loader)
      
      print(trainer.state.epoch, state.metrics)


  trainer.add_event_handler(Events.EPOCH_COMPLETED, validation)


  trainer.run(training_data_loader, max_epochs=100)
  ```

  </details>



  The cool thing with handlers is that they offer unparalleled flexibility (compared to, for example, callbacks). Handlers can be any function: e.g. lambda, simple function, class method, etc. Thus, we do not require to inherit from an interface and override its abstract methods which could unnecessarily bulk up your code and its complexity.



  <details>
  <summary>
  Examples
  </summary>

  ```python
  trainer.add_event_handler(Events.STARTED, lambda _: print("Start training"))


  mydata = [1, 2, 3, 4]
  logger = ...

  def on_training_ended(data):
      print(f"Training is ended. mydata={data}")
      
      logger.info("Training is ended")


  trainer.add_event_handler(Events.COMPLETED, on_training_ended, mydata)

  trainer.add_event_handler(Events.COMPLETED, lambda engine: print(engine.state.times))

  @trainer.on(Events.ITERATION_COMPLETED)
  def log_something(engine):
      print(engine.state.output)
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  ```python

  @trainer.on(Events.EPOCH_COMPLETED(every=5))
  def run_validation():
      


  @trainer.on(Events.EPOCH_STARTED(once=20))
  def change_training_variable():
      


  @trainer.on(Events.ITERATION_COMPLETED(event_filter=first_x_iters))
  def log_gradients():
      
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  Events can be stacked together to enable multiple calls:

  ```python
  @trainer.on(Events.COMPLETED | Events.EPOCH_COMPLETED(every=10))
  def run_validation():
      
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  Custom events related to backward and optimizer step calls:

  ```python
  from ignite.engine import EventEnum


  class BackpropEvents(EventEnum):
      BACKWARD_STARTED = 'backward_started'
      BACKWARD_COMPLETED = 'backward_completed'
      OPTIM_STEP_COMPLETED = 'optim_step_completed'

  def update(engine, batch):
      
      loss = criterion(y_pred, y)
      engine.fire_event(BackpropEvents.BACKWARD_STARTED)
      loss.backward()
      engine.fire_event(BackpropEvents.BACKWARD_COMPLETED)
      optimizer.step()
      engine.fire_event(BackpropEvents.OPTIM_STEP_COMPLETED)
      

  trainer = Engine(update)
  trainer.register_events(*BackpropEvents)

  @trainer.on(BackpropEvents.BACKWARD_STARTED)
  def function_before_backprop(engine):
      
  ```

  - Complete snippet is found [here](https://pytorch.org/ignite/faq.html#creating-custom-events-based-on-forward-backward-pass).
  - Another use-case of custom events: [trainer for Truncated Backprop Through Time](https://pytorch.org/ignite/contrib/engines.html#ignite.contrib.engines.create_supervised_tbptt_trainer).

  </details>



  - [Metrics](https://pytorch.org/ignite/metrics.html#complete-list-of-metrics) for various tasks:
    Precision, Recall, Accuracy, Confusion Matrix, IoU etc, ~20 [regression metrics](https://pytorch.org/ignite/contrib/metrics.html#regression-metrics).

  - Users can also [compose their metrics](https://pytorch.org/ignite/metrics.html#metric-arithmetics) with ease from
    existing ones using arithmetic operations or torch methods.

  <details>
  <summary>
  Example
  </summary>

  ```python
  precision = Precision(average=False)
  recall = Recall(average=False)
  F1_per_class = (precision * recall * 2 / (precision + recall))
  F1_mean = F1_per_class.mean()  # torch mean method
  F1_mean.attach(engine, "F1")
  ```

  </details>

  <!-- ############################################################################################################### -->



  From [pip](https://pypi.org/project/pytorch-ignite/):

  ```bash
  pip install pytorch-ignite
  ```

  From [conda](https://anaconda.org/pytorch/ignite):

  ```bash
  conda install ignite -c pytorch
  ```

  From source:

  ```bash
  pip install git+https://github.com/pytorch/ignite
  ```



  From pip:

  ```bash
  pip install --pre pytorch-ignite
  ```

  From conda (this suggests to install [pytorch nightly release](https://anaconda.org/pytorch-nightly/pytorch) instead of stable
  version as dependency):

  ```bash
  conda install ignite -c pytorch-nightly
  ```





  Pull a pre-built docker image from [our Docker Hub](https://hub.docker.com/u/pytorchignite) and run it with docker v19.03+.

  ```bash
  docker run --gpus all -it -v $PWD:/workspace/project --network=host --shm-size 16G pytorchignite/base:latest /bin/bash
  ```

  <details>

  <summary>
  List of available pre-built images
  </summary>

  Base
  - `pytorchignite/base:latest`
  - `pytorchignite/apex:latest`
  - `pytorchignite/hvd-base:latest`
  - `pytorchignite/hvd-apex:latest`
  - `pytorchignite/msdp-apex:latest`

  Vision:
  - `pytorchignite/vision:latest`
  - `pytorchignite/hvd-vision:latest`
  - `pytorchignite/apex-vision:latest`
  - `pytorchignite/hvd-apex-vision:latest`
  - `pytorchignite/msdp-apex-vision:latest`

  NLP:
  - `pytorchignite/nlp:latest`
  - `pytorchignite/hvd-nlp:latest`
  - `pytorchignite/apex-nlp:latest`
  - `pytorchignite/hvd-apex-nlp:latest`
  - `pytorchignite/msdp-apex-nlp:latest`

  </details>

  For more details, see [here](docker).

  <!-- ############################################################################################################### -->



  Few pointers to get you started:

  - [Quick Start Guide: Essentials of getting a project up and running](https://pytorch.org/ignite/quickstart.html)
  - [Concepts of the library: Engine, Events & Handlers, State, Metrics](https://pytorch.org/ignite/concepts.html)
  - Full-featured template examples (coming soon)

  <!-- ############################################################################################################### -->



  - Stable API documentation and an overview of the library: https://pytorch.org/ignite/
  - Development version API documentation: https://pytorch.org/ignite/master/
  - [FAQ](https://pytorch.org/ignite/faq.html),
    ["Questions on Github"](https://github.com/pytorch/ignite/issues?q=is%3Aissue+label%3Aquestion+) and
    ["Questions on Discuss.PyTorch"](https://discuss.pytorch.org/c/ignite).
  - [Project's Roadmap](https://github.com/pytorch/ignite/wiki/Roadmap)



  - [Distributed Training Made Easy with PyTorch-Ignite](https://labs.quansight.org/blog/2021/06/distributed-made-easy-with-ignite/)
  - [PyTorch Ecosystem Day 2021 Breakout session presentation](https://colab.research.google.com/drive/1qhUgWQ0N2U71IVShLpocyeY4AhlDCPRd)
  - [Tutorial blog post about PyTorch-Ignite](https://labs.quansight.org/blog/2020/09/pytorch-ignite/)
  - [8 Creators and Core Contributors Talk About Their Model Training Libraries From PyTorch Ecosystem](https://neptune.ai/blog/model-training-libraries-pytorch-ecosystem?utm_source=reddit&utm_medium=post&utm_campaign=blog-model-training-libraries-pytorch-ecosystem)
  - Ignite Posters from Pytorch Developer Conferences:
    - [2021](https://drive.google.com/file/d/1YXrkJIepPk_KltSG1ZfWRtA5IRgPFz_U)
    - [2019](https://drive.google.com/open?id=1bqIl-EM6GCCCoSixFZxhIbuF25F2qTZg)
    - [2018](https://drive.google.com/open?id=1_2vzBJ0KeCjGv1srojMHiJRvceSVbVR5)

  <!-- ############################################################################################################### -->





  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/TextCNN.ipynb) [Text Classification using Convolutional Neural
    Networks](https://github.com/pytorch/ignite/blob/master/examples/notebooks/TextCNN.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/VAE.ipynb) [Variational Auto
    Encoders](https://github.com/pytorch/ignite/blob/master/examples/notebooks/VAE.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/FashionMNIST.ipynb) [Convolutional Neural Networks for Classifying Fashion-MNIST
    Dataset](https://github.com/pytorch/ignite/blob/master/examples/notebooks/FashionMNIST.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_nvidia_apex.ipynb) [Training Cycle-GAN on Horses to
    Zebras with Nvidia/Apex](https://github.com/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_nvidia_apex.ipynb) - [ logs on W&B](https://app.wandb.ai/vfdev-5/ignite-cyclegan-apex)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_torch_cuda_amp.ipynb) [Another training Cycle-GAN on Horses to
    Zebras with Native Torch CUDA AMP](https://github.com/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_torch_cuda_amp.ipynb) - [logs on W&B](https://app.wandb.ai/vfdev-5/ignite-cyclegan-torch-amp)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/EfficientNet_Cifar100_finetuning.ipynb) [Finetuning EfficientNet-B0 on
    CIFAR100](https://github.com/pytorch/ignite/blob/master/examples/notebooks/EfficientNet_Cifar100_finetuning.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/Cifar10_Ax_hyperparam_tuning.ipynb) [Hyperparameters tuning with
    Ax](https://github.com/pytorch/ignite/blob/master/examples/notebooks/Cifar10_Ax_hyperparam_tuning.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/FastaiLRFinder_MNIST.ipynb) [Basic example of LR finder on
    MNIST](https://github.com/pytorch/ignite/blob/master/examples/notebooks/FastaiLRFinder_MNIST.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb) [Benchmark mixed precision training on Cifar100:
    torch.cuda.amp vs nvidia/apex](https://github.com/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/MNIST_on_TPU.ipynb) [MNIST training on a single
    TPU](https://github.com/pytorch/ignite/blob/master/examples/notebooks/MNIST_on_TPU.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1E9zJrptnLJ_PKhmaP5Vhb6DTVRvyrKHx) [CIFAR10 Training on multiple TPUs](https://github.com/pytorch/ignite/tree/master/examples/contrib/cifar10)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/HandlersTimeProfiler_MNIST.ipynb) [Basic example of handlers
    time profiling on MNIST training example](https://github.com/pytorch/ignite/blob/master/examples/notebooks/HandlersTimeProfiler_MNIST.ipynb)



  Inspired by [torchvision/references](https://github.com/pytorch/vision/tree/master/references),
  we provide several reproducible baselines for vision tasks:

  - [ImageNet](examples/references/classification/imagenet) - logs on Ignite Trains server coming soon ...
  - [Pascal VOC2012](examples/references/segmentation/pascal_voc2012) - logs on Ignite Trains server coming soon ...

  Features:

  - Distributed training: native or horovod and using [PyTorch native AMP](https://pytorch.org/docs/stable/notes/amp_examples.html)



  The easiest way to create your training scripts with PyTorch-Ignite:
  - https://code-generator.pytorch-ignite.ai/


  <!-- ############################################################################################################### -->



  - [GitHub issues](https://github.com/pytorch/ignite/issues): questions, bug reports, feature requests, etc.

  - [Discuss.PyTorch](https://discuss.pytorch.org/c/ignite), category "Ignite".

  - [PyTorch-Ignite Discord Server](https://discord.gg/djZtm3EmKj): to chat with the community

  - [GitHub Discussions](https://github.com/pytorch/ignite/discussions): general library-related discussions, ideas, Q&A, etc.



  We have created a form for ["user feedback"](https://github.com/pytorch/ignite/issues/new/choose). We
  appreciate any type of feedback, and this is how we would like to see our
  community:

  - If you like the project and want to say thanks, this the right
    place.
  - If you do not like something, please, share it with us, and we can
    see how to improve it.

  Thank you!

  <!-- ############################################################################################################### -->



  Please see the [contribution guidelines](https://github.com/pytorch/ignite/blob/master/CONTRIBUTING.md) for more information.

  As always, PRs are welcome :)

  <!-- ############################################################################################################### -->



  <details>

  <summary>
  Research papers
  </summary>

  - [BatchBALD: Efficient and Diverse Batch Acquisition for Deep Bayesian Active Learning](https://github.com/BlackHC/BatchBALD)
  - [A Model to Search for Synthesizable Molecules](https://github.com/john-bradshaw/molecule-chef)
  - [Localised Generative Flows](https://github.com/jrmcornish/lgf)
  - [Extracting T Cell Function and Differentiation Characteristics from the Biomedical Literature](https://github.com/hammerlab/t-cell-relation-extraction)
  - [Variational Information Distillation for Knowledge Transfer](https://github.com/amzn/xfer/tree/master/var_info_distil)
  - [XPersona: Evaluating Multilingual Personalized Chatbot](https://github.com/HLTCHKUST/Xpersona)
  - [CNN-CASS: CNN for Classification of Coronary Artery Stenosis Score in MPR Images](https://github.com/ucuapps/CoronaryArteryStenosisScoreClassification)
  - [Bridging Text and Video: A Universal Multimodal Transformer for Video-Audio Scene-Aware Dialog](https://github.com/ictnlp/DSTC8-AVSD)
  - [Adversarial Decomposition of Text Representation](https://github.com/text-machine-lab/adversarial_decomposition)
  - [Uncertainty Estimation Using a Single Deep Deterministic Neural Network](https://github.com/y0ast/deterministic-uncertainty-quantification)
  - [DeepSphere: a graph-based spherical CNN](https://github.com/deepsphere/deepsphere-pytorch)
  - [Norm-in-Norm Loss with Faster Convergence and Better Performance for Image Quality Assessment](https://github.com/lidq92/LinearityIQA)
  - [Unified Quality Assessment of In-the-Wild Videos with Mixed Datasets Training](https://github.com/lidq92/MDTVSFA)
  - [Deep Signature Transforms](https://github.com/patrick-kidger/Deep-Signature-Transforms)
  - [Neural CDEs for Long Time-Series via the Log-ODE Method](https://github.com/jambo6/neuralCDEs-via-logODEs)
  - [Volumetric Grasping Network](https://github.com/ethz-asl/vgn)
  - [Mood Classification using Listening Data](https://github.com/fdlm/listening-moods)
  - [Deterministic Uncertainty Estimation (DUE)](https://github.com/y0ast/DUE)
  - [PyTorch-Hebbian: facilitating local learning in a deep learning framework](https://github.com/Joxis/pytorch-hebbian)
  - [Stochastic Weight Matrix-Based Regularization Methods for Deep Neural Networks](https://github.com/rpatrik96/lod-wmm-2019)
  - [Learning explanations that are hard to vary](https://github.com/gibipara92/learning-explanations-hard-to-vary)
  - [The role of disentanglement in generalisation](https://github.com/mmrl/disent-and-gen)
  - [A Probabilistic Programming Approach to Protein Structure Superposition](https://github.com/LysSanzMoreta/Theseus-PP)
  - [PadChest: A large chest x-ray image dataset with multi-label annotated reports](https://github.com/auriml/Rx-thorax-automatic-captioning)

  </details>

  <details>

  <summary>
  Blog articles, tutorials, books
  </summary>

  - [State-of-the-Art Conversational AI with Transfer Learning](https://github.com/huggingface/transfer-learning-conv-ai)
  - [Tutorial on Transfer Learning in NLP held at NAACL 2019](https://github.com/huggingface/naacl_transfer_learning_tutorial)
  - [Deep-Reinforcement-Learning-Hands-On-Second-Edition, published by Packt](https://github.com/PacktPublishing/Deep-Reinforcement-Learning-Hands-On-Second-Edition)
  - [Once Upon a Repository: How to Write Readable, Maintainable Code with PyTorch](https://towardsdatascience.com/once-upon-a-repository-how-to-write-readable-maintainable-code-with-pytorch-951f03f6a829)
  - [The Hero Rises: Build Your Own SSD](https://allegro.ai/blog/the-hero-rises-build-your-own-ssd/)
  - [Using Optuna to Optimize PyTorch Ignite Hyperparameters](https://medium.com/pytorch/using-optuna-to-optimize-pytorch-ignite-hyperparameters-626ffe6d4783)
  - [PyTorch Ignite - Classifying Tiny ImageNet with EfficientNet](https://towardsdatascience.com/pytorch-ignite-classifying-tiny-imagenet-with-efficientnet-e5b1768e5e8f)

  </details>

  <details>

  <summary>
  Toolkits
  </summary>

  - [Project MONAI - AI Toolkit for Healthcare Imaging](https://github.com/Project-MONAI/MONAI)
  - [DeepSeismic - Deep Learning for Seismic Imaging and Interpretation](https://github.com/microsoft/seismic-deeplearning)
  - [Nussl - a flexible, object-oriented Python audio source separation library](https://github.com/nussl/nussl)
  - [PyTorch Adapt - A fully featured and modular domain adaptation library](https://github.com/KevinMusgrave/pytorch-adapt)
  - [gnina-torch: PyTorch implementation of GNINA scoring function](https://github.com/RMeli/gnina-torch)

  </details>

  <details>

  <summary>
  Others
  </summary>

  - [Implementation of "Attention is All You Need" paper](https://github.com/akurniawan/pytorch-transformer)
  - [Implementation of DropBlock: A regularization method for convolutional networks in PyTorch](https://github.com/miguelvr/dropblock)
  - [Kaggle Kuzushiji Recognition: 2nd place solution](https://github.com/lopuhin/kaggle-kuzushiji-2019)
  - [Unsupervised Data Augmentation experiments in PyTorch](https://github.com/vfdev-5/UDA-pytorch)
  - [Hyperparameters tuning with Optuna](https://github.com/optuna/optuna-examples/blob/main/pytorch/pytorch_ignite_simple.py)
  - [Logging with ChainerUI](https://chainerui.readthedocs.io/en/latest/reference/module.html#external-library-support)
  - [FixMatch experiments in PyTorch and Ignite (CTA dataaug policy)](https://github.com/vfdev-5/FixMatch-pytorch)
  - [Kaggle Birdcall Identification Competition: 1st place solution](https://github.com/ryanwongsa/kaggle-birdsong-recognition)
  - [Logging with Aim - An open-source experiment tracker](https://aimstack.readthedocs.io/en/latest/quick_start/integrations.html#integration-with-pytorch-ignite)

  </details>

  See other projects at ["Used by"](https://github.com/pytorch/ignite/network/dependents?package_id=UGFja2FnZS02NzI5ODEwNA%3D%3D)

  If your project implements a paper, represents other use-cases not
  covered in our official tutorials, Kaggle competition's code, or just
  your code presents interesting results and uses Ignite. We would like to
  add your project to this list, so please send a PR with brief
  description of the project.

  <!-- ############################################################################################################### -->



  If you use PyTorch-Ignite in a scientific publication, we would appreciate citations to our project.

  ```
  @misc{pytorch-ignite,
    author = {V. Fomin and J. Anmol and S. Desroziers and J. Kriss and A. Tejani},
    title = {High-level library to help with training neural networks in PyTorch},
    year = {2020},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/pytorch/ignite}},
  }
  ```

  <!-- ############################################################################################################### -->



  PyTorch-Ignite is a [NumFOCUS Affiliated Project](https://www.numfocus.org/), operated and maintained by volunteers in the PyTorch community in their capacities as individuals
  (and not as representatives of their employers). See the ["About us"](https://pytorch-ignite.ai/about/community/#about-us)
  page for a list of core contributors. For usage questions and issues, please see the various channels
  [here](#communication). For all other questions and inquiries, please send an email
  to contact@pytorch-ignite.ai.


pkgId: a34f2a3f2e60e5b181d379256d17785cebb14fed7c2d743cc93a0578c2d14419
name: python-pytorch-lightning
arch: src
version: 2.0.1
epoch: 0
release: 1
url: https://github.com/Lightning-AI/lightning
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45491569-7a6a-47ea-9f92-d0649c86ddb5
location_href: 00009713-python-pytorch-lightning/python-pytorch-lightning-2.0.1-1.src.rpm
checksum_type: sha256
summary:
  PyTorch Lightning is the lightweight PyTorch wrapper for ML researchers. Scale your models. Write less boilerplate.

description:
  <div align="center">

  <img src="https://pl-public-data.s3.amazonaws.com/assets_lightning/pytorch-lightning.png" width="400px">

  **The lightweight PyTorch wrapper for high-performance AI research.
  Scale your models, not the boilerplate.**

  ______________________________________________________________________

  <p align="center">
    <a href="https://www.pytorchlightning.ai/">Website</a> •
    <a href="#key-features">Key Features</a> •
    <a href="#how-to-use">How To Use</a> •
    <a href="https://lightning.ai/docs/pytorch/stable/">Docs</a> •
    <a href="#examples">Examples</a> •
    <a href="#community">Community</a> •
    <a href="https://lightning.ai/">Lightning AI</a> •
    <a href="https://github.com/Lightning-AI/lightning/blob/master/LICENSE">License</a>
  </p>

  <!-- DO NOT ADD CONDA DOWNLOADS... README CHANGES MUST BE APPROVED BY EDEN OR WILL -->

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytorch-lightning)](https://pypi.org/project/pytorch-lightning/)
  [![PyPI Status](https://badge.fury.io/py/pytorch-lightning.svg)](https://badge.fury.io/py/pytorch-lightning)
  [![PyPI Status](https://pepy.tech/badge/pytorch-lightning)](https://pepy.tech/project/pytorch-lightning)
  [![Conda](https://img.shields.io/conda/v/conda-forge/pytorch-lightning?label=conda&color=success)](https://anaconda.org/conda-forge/pytorch-lightning)
  [![DockerHub](https://img.shields.io/docker/pulls/pytorchlightning/pytorch_lightning.svg)](https://hub.docker.com/r/pytorchlightning/pytorch_lightning)
  [![codecov](https://codecov.io/gh/Lightning-AI/lightning/release/2.0.1/graph/badge.svg)](https://codecov.io/gh/Lightning-AI/lightning)

  [![ReadTheDocs](https://readthedocs.org/projects/pytorch-lightning/badge/?version=2.0.1)](https://lightning.ai/docs/pytorch/stable/)[![Discord](https://img.shields.io/discord/1077906959069626439?style=plastic)](https://discord.gg/VptPCZkGNa)
  [![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/Lightning-AI/lightning/blob/master/LICENSE)

  <!--
  [![CodeFactor](https://www.codefactor.io/repository/github/Lightning-AI/lightning/badge)](https://www.codefactor.io/repository/github/Lightning-AI/lightning)
  -->

  </div>



  ______________________________________________________________________



  Lightning disentangles PyTorch code to decouple the science from the engineering.
  ![PT to PL](../../https://github.com/Lightning-AI/lightning/raw/2.0.1/docs/source-app/_static/images/general/pl_quick_start_full_compressed.gif)

  ______________________________________________________________________



  Lightning structures PyTorch code with these principles:

  <div align="center">
    <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/philosophies.jpg" max-height="250px">
  </div>

  Lightning forces the following structure to your code which makes it reusable and shareable:

  - Research code (the LightningModule).
  - Engineering code (you delete, and is handled by the Trainer).
  - Non-essential research code (logging, etc... this goes in Callbacks).
  - Data (use PyTorch DataLoaders or organize them into a LightningDataModule).

  Once you do this, you can train on multiple-GPUs, TPUs, CPUs, IPUs, HPUs and even in 16-bit precision without changing your code!

  [Get started in just 15 minutes](https://lightning.ai/docs/pytorch/latest/starter/introduction.html)

  ______________________________________________________________________



  Lightning is rigorously tested across multiple CPUs, GPUs, TPUs, IPUs, and HPUs and against major Python and PyTorch versions.

  <details>
    <summary>Current build statuses</summary>

  <center>

  |       System / PyTorch ver.        |                                                                                              1.11                                                                                               |                                                                                                              1.12                                                                                                               | 1.13                                                                                                                                                                                                                            | 2.0  |
  | :--------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---- |
  |        Linux py3.9 \[GPUs\]        |                                                                                                -                                                                                                | [![Build Status](<https://dev.azure.com/Lightning-AI/lightning/_apis/build/status/pytorch-lightning%20(GPUs)?branchName=refs%2Ftags%2F2.0.1>)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=24&branchName=master) | [![Build Status](<https://dev.azure.com/Lightning-AI/lightning/_apis/build/status/pytorch-lightning%20(GPUs)?branchName=refs%2Ftags%2F2.0.1>)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=24&branchName=master) | Soon |
  |        Linux py3.9 \[TPUs\]        |                                                                                                -                                                                                                |                     [![Test PyTorch - TPU](https://github.com/Lightning-AI/lightning/actions/workflows/tpu-tests.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/tpu-tests.yml)                     |                                                                                                                                                                                                                                 | Soon |
  |        Linux py3.8 \[IPUs\]        |                                                                                                -                                                                                                |                                                                                                                -                                                                                                                | [![Build Status](<https://dev.azure.com/Lightning-AI/lightning/_apis/build/status/pytorch-lightning%20(IPUs)?branchName=refs%2Ftags%2F2.0.1>)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=25&branchName=master) | Soon |
  |        Linux py3.8 \[HPUs\]        |                                                                                                -                                                                                                |                                                                                                                -                                                                                                                | [![Build Status](<https://dev.azure.com/Lightning-AI/lightning/_apis/build/status/pytorch-lightning%20(HPUs)?branchName=refs%2Ftags%2F2.0.1>)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=26&branchName=master) | Soon |
  |  Linux (multiple Python versions)  | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml) |                 [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                 | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 | Soon |
  |   OSX (multiple Python versions)   | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml) |                 [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                 | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 | Soon |
  | Windows (multiple Python versions) | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml) |                 [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                 | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 | Soon |

  </center>
  </details>

  ______________________________________________________________________





  Simple installation from PyPI

  ```bash
  pip install pytorch-lightning
  ```

  <!--  -->



  ```python
  import os
  import torch
  from torch import nn
  import torch.nn.functional as F
  from torchvision.datasets import MNIST
  from torch.utils.data import DataLoader, random_split
  from torchvision import transforms
  import pytorch_lightning as pl
  ```



  A LightningModule defines a full *system* (ie: a GAN, autoencoder, BERT or a simple Image Classifier).

  ```python
  class LitAutoEncoder(pl.LightningModule):
      def __init__(self):
          super().__init__()
          self.encoder = nn.Sequential(nn.Linear(28 * 28, 128), nn.ReLU(), nn.Linear(128, 3))
          self.decoder = nn.Sequential(nn.Linear(3, 128), nn.ReLU(), nn.Linear(128, 28 * 28))

      def forward(self, x):
          
          embedding = self.encoder(x)
          return embedding

      def training_step(self, batch, batch_idx):
          
          x, y = batch
          x = x.view(x.size(0), -1)
          z = self.encoder(x)
          x_hat = self.decoder(z)
          loss = F.mse_loss(x_hat, x)
          self.log("train_loss", loss)
          return loss

      def configure_optimizers(self):
          optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)
          return optimizer
  ```

  **Note: Training_step defines the training loop. Forward defines how the LightningModule behaves during inference/prediction.**



  ```python
  dataset = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
  train, val = random_split(dataset, [55000, 5000])

  autoencoder = LitAutoEncoder()
  trainer = pl.Trainer()
  trainer.fit(autoencoder, DataLoader(train), DataLoader(val))
  ```



  Lightning has over [40+ advanced features](https://lightning.ai/docs/pytorch/latest/common/trainer.html#trainer-flags) designed for professional AI research at scale.

  Here are some examples:

  <div align="center">
    <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/features_2.jpg" max-height="600px">
  </div>

  <details>
    <summary>Highlighted feature code snippets</summary>

  ```python


  trainer = Trainer(max_epochs=1, accelerator="gpu", devices=8)


  trainer = Trainer(max_epochs=1, accelerator="gpu", devices=8, num_nodes=32)
  ```

  <summary>Train on TPUs without code changes</summary>

  ```python

  trainer = Trainer(accelerator="tpu", devices=8)
  ```

  <summary>16-bit precision</summary>

  ```python

  trainer = Trainer(precision=16)
  ```

  <summary>Experiment managers</summary>

  ```python
  from pytorch_lightning import loggers


  trainer = Trainer(logger=TensorBoardLogger("logs/"))


  trainer = Trainer(logger=loggers.WandbLogger())


  trainer = Trainer(logger=loggers.CometLogger())


  trainer = Trainer(logger=loggers.MLFlowLogger())


  trainer = Trainer(logger=loggers.NeptuneLogger())


  ```

  <summary>EarlyStopping</summary>

  ```python
  es = EarlyStopping(monitor="val_loss")
  trainer = Trainer(callbacks=[es])
  ```

  <summary>Checkpointing</summary>

  ```python
  checkpointing = ModelCheckpoint(monitor="val_loss")
  trainer = Trainer(callbacks=[checkpointing])
  ```

  <summary>Export to torchscript (JIT) (production use)</summary>

  ```python

  autoencoder = LitAutoEncoder()
  torch.jit.save(autoencoder.to_torchscript(), "model.pt")
  ```

  <summary>Export to ONNX (production use)</summary>

  ```python
  autoencoder = LitAutoEncoder()
  input_sample = torch.randn((1, 64))
  with tempfile.NamedTemporaryFile(suffix=".onnx", delete=False) as tmpfile:
      autoencoder.to_onnx(tmpfile.name, input_sample, export_params=True)
  ```

  </details>



  For complex/professional level work, you have optional full control of the optimizers.

  ```python
  class LitAutoEncoder(pl.LightningModule):
      def __init__(self):
          super().__init__()
          self.automatic_optimization = False

      def training_step(self, batch, batch_idx):
          
          opt_a, opt_b = self.optimizers(use_pl_optimizer=True)

          loss_a = ...
          self.manual_backward(loss_a, opt_a)
          opt_a.step()
          opt_a.zero_grad()

          loss_b = ...
          self.manual_backward(loss_b, opt_b, retain_graph=True)
          self.manual_backward(loss_b, opt_b)
          opt_b.step()
          opt_b.zero_grad()
  ```

  ______________________________________________________________________



  - Models become hardware agnostic
  - Code is clear to read because engineering code is abstracted away
  - Easier to reproduce
  - Make fewer mistakes because lightning handles the tricky engineering
  - Keeps all the flexibility (LightningModules are still PyTorch modules), but removes a ton of boilerplate
  - Lightning has dozens of integrations with popular machine learning tools.
  - [Tested rigorously with every new PR](https://github.com/Lightning-AI/lightning/tree/master/tests). We test every combination of PyTorch and Python supported versions, every OS, multi GPUs and even TPUs.
  - Minimal running speed overhead (about 300 ms per epoch compared with pure PyTorch).

  ______________________________________________________________________





  - [CPC transforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#cpc-transforms)
  - [Moco v2 tranforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#moco-v2-transforms)
  - [SimCLR transforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#simclr-transforms)



  - [GPT-2](https://lightning-bolts.readthedocs.io/en/stable/models/convolutional.html#gpt-2)
  - [UNet](https://lightning-bolts.readthedocs.io/en/stable/models/convolutional.html#unet)



  - [DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#dqn-loss)
  - [Double DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#double-dqn-loss)
  - [Per DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#per-dqn-loss)



  - [Basic GAN](https://lightning-bolts.readthedocs.io/en/stable/models/gans.html#basic-gan)
  - [DCGAN](https://lightning-bolts.readthedocs.io/en/stable/models/gans.html#dcgan)



  - [Logistic Regression](https://lightning-bolts.readthedocs.io/en/stable/models/classic_ml.html#logistic-regression)
  - [Linear Regression](https://lightning-bolts.readthedocs.io/en/stable/models/classic_ml.html#linear-regression)

  ______________________________________________________________________



  The PyTorch Lightning community is maintained by

  - [10+ core contributors](https://lightning.ai/docs/pytorch/latest/governance.html) who are all a mix of professional engineers, Research Scientists, and Ph.D. students from top AI labs.
  - 680+ active community contributors.

  Want to help us build Lightning and reduce boilerplate for thousands of researchers? [Learn how to make your first contribution here](https://devblog.pytorchlightning.ai/quick-contribution-guide-86d977171b3a)

  PyTorch Lightning is also part of the [PyTorch ecosystem](https://pytorch.org/ecosystem/) which requires projects to have solid testing, documentation and support.



  If you have any questions please:

  1. [Read the docs](https://lightning.ai/docs/pytorch/latest).
  1. [Search through existing Discussions](https://github.com/Lightning-AI/lightning/discussions), or [add a new question](https://github.com/Lightning-AI/lightning/discussions/new)
  1. [Join our Discord community](https://discord.gg/VptPCZkGNa).


pkgId: deaa6c457785c1ae2f662f32e4b718c09fef21abbaee09efaff798ca736f1744
name: python-pytorch-metric-learning
arch: src
version: 2.1.0
epoch: 0
release: 1
url: https://github.com/KevinMusgrave/pytorch-metric-learning
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f00e9bc3-d669-4876-a76c-977d74541a29
location_href: 00011443-python-pytorch-metric-learning/python-pytorch-metric-learning-2.1.0-1.src.rpm
checksum_type: sha256
summary:
  The easiest way to use deep metric learning in your application. Modular, flexible, and extensible. Written in PyTorch.

description:
  <h1>
  <a href="https://github.com/KevinMusgrave/pytorch-metric-learning">
  <img alt="PyTorch Metric Learning" src="https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/docs/imgs/Logo2.png">
  </a>
  </h1>

  <p align="center">
   <a href="https://pypi.org/project/pytorch-metric-learning">
       <img alt="PyPi version" src="https://img.shields.io/pypi/v/pytorch-metric-learning?color=bright-green">
   </a>



   <a href="https://anaconda.org/conda-forge/pytorch-metric-learning">
       <img alt="Anaconda version" src="https://img.shields.io/conda/v/conda-forge/pytorch-metric-learning?color=bright-green">
   </a>
  </p>



  **January 16**: v1.7.0
  - Fixes an edge case in ArcFaceLoss. See the [release notes](https://github.com/KevinMusgrave/pytorch-metric-learning/releases/tag/v1.7.0).
  - Thanks to contributor [ElisonSherton](https://github.com/ElisonSherton).

  **September 3**: v1.6.0
  - `DistributedLossWrapper` and `DistributedMinerWrapper` now support `ref_emb` and `ref_labels`.
  - Thanks to contributor [NoTody](https://github.com/NoTody).


  - [**View the documentation here**](https://kevinmusgrave.github.io/pytorch-metric-learning/)
  - [**View the installation instructions here**](https://github.com/KevinMusgrave/pytorch-metric-learning#installation)
  - [**View the available losses, miners etc. here**](https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/CONTENTS.md)



  See the [examples folder](https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/examples/README.md) for notebooks you can download or run on Google Colab.



  This library contains 9 modules, each of which can be used independently within your existing codebase, or combined together for a complete train/test workflow.

  ![high_level_module_overview](docs/imgs/high_level_module_overview.png)






  Let’s initialize a plain [TripletMarginLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#tripletmarginloss):
  ```python
  from pytorch_metric_learning import losses
  loss_func = losses.TripletMarginLoss()
  ```

  To compute the loss in your training loop, pass in the embeddings computed by your model, and the corresponding labels. The embeddings should have size (N, embedding_size), and the labels should have size (N), where N is the batch size.

  ```python

  for i, (data, labels) in enumerate(dataloader):
  	optimizer.zero_grad()
  	embeddings = model(data)
  	loss = loss_func(embeddings, labels)
  	loss.backward()
  	optimizer.step()
  ```

  The TripletMarginLoss computes all possible triplets within the batch, based on the labels you pass into it. Anchor-positive pairs are formed by embeddings that share the same label, and anchor-negative pairs are formed by embeddings that have different labels.

  Sometimes it can help to add a mining function:
  ```python
  from pytorch_metric_learning import miners, losses
  miner = miners.MultiSimilarityMiner()
  loss_func = losses.TripletMarginLoss()


  for i, (data, labels) in enumerate(dataloader):
  	optimizer.zero_grad()
  	embeddings = model(data)
  	hard_pairs = miner(embeddings, labels)
  	loss = loss_func(embeddings, labels, hard_pairs)
  	loss.backward()
  	optimizer.step()
  ```
  In the above code, the miner finds positive and negative pairs that it thinks are particularly difficult. Note that even though the TripletMarginLoss operates on triplets, it’s still possible to pass in pairs. This is because the library automatically converts pairs to triplets and triplets to pairs, when necessary.


  Loss functions can be customized using [distances](https://kevinmusgrave.github.io/pytorch-metric-learning/distances/), [reducers](https://kevinmusgrave.github.io/pytorch-metric-learning/reducers/), and [regularizers](https://kevinmusgrave.github.io/pytorch-metric-learning/regularizers/). In the diagram below, a miner finds the indices of hard pairs within a batch. These are used to index into the distance matrix, computed by the distance object. For this diagram, the loss function is pair-based, so it computes a loss per pair. In addition, a regularizer has been supplied, so a regularization loss is computed for each embedding in the batch. The per-pair and per-element losses are passed to the reducer, which (in this diagram) only keeps losses with a high value. The averages are computed for the high-valued pair and element losses, and are then added together to obtain the final loss.

  ![high_level_loss_function_overview](docs/imgs/high_level_loss_function_overview.png)

  Now here's an example of a customized TripletMarginLoss:
  ```python
  from pytorch_metric_learning.distances import CosineSimilarity
  from pytorch_metric_learning.reducers import ThresholdReducer
  from pytorch_metric_learning.regularizers import LpRegularizer
  from pytorch_metric_learning import losses
  loss_func = losses.TripletMarginLoss(distance = CosineSimilarity(),
  				     reducer = ThresholdReducer(high=0.3),
  			 	     embedding_regularizer = LpRegularizer())
  ```
  This customized triplet loss has the following properties:

   - The loss will be computed using cosine similarity instead of Euclidean distance.
   - All triplet losses that are higher than 0.3 will be discarded.
   - The embeddings will be L2 regularized.



  The TripletMarginLoss is an embedding-based or tuple-based loss. This means that internally, there is no real notion of "classes". Tuples (pairs or triplets) are formed at each iteration, based on the labels it receives. The labels don't have to represent classes. They simply need to indicate the positive and negative relationships between the embeddings. Thus, it is easy to use these loss functions for unsupervised or self-supervised learning.

  For example, the code below is a simplified version of the augmentation strategy commonly used in self-supervision. The dataset does not come with any labels. Instead, the labels are created in the training loop, solely to indicate which embeddings are positive pairs.

  ```python

  for i, data in enumerate(dataloader):
  	optimizer.zero_grad()
  	embeddings = your_model(data)
  	augmented = your_model(your_augmentation(data))
  	labels = torch.arange(embeddings.size(0))

  	embeddings = torch.cat([embeddings, augmented], dim=0)
  	labels = torch.cat([labels, labels], dim=0)

  	loss = loss_func(embeddings, labels)
  	loss.backward()
  	optimizer.step()
  ```

  If you're interested in [MoCo](https://arxiv.org/pdf/1911.05722.pdf)-style self-supervision, take a look at the [MoCo on CIFAR10](https://github.com/KevinMusgrave/pytorch-metric-learning/tree/master/examples#simple-examples) notebook. It uses CrossBatchMemory to implement the momentum encoder queue, which means you can use any tuple loss, and any tuple miner to extract hard samples from the queue.




  - For a convenient way to train your model, take a look at the [trainers](https://kevinmusgrave.github.io/pytorch-metric-learning/trainers/).
  - Want to test your model's accuracy on a dataset? Try the [testers](https://kevinmusgrave.github.io/pytorch-metric-learning/testers/).
  - To compute the accuracy of an embedding space directly, use [AccuracyCalculator](https://kevinmusgrave.github.io/pytorch-metric-learning/accuracy_calculation/).

  If you're short of time and want a complete train/test workflow, check out the [example Google Colab notebooks](https://github.com/KevinMusgrave/pytorch-metric-learning/tree/master/examples).

  To learn more about all of the above, [see the documentation](https://kevinmusgrave.github.io/pytorch-metric-learning).





   - ```pytorch-metric-learning >= v0.9.90``` requires ```torch >= 1.6```
   - ```pytorch-metric-learning < v0.9.90``` doesn't have a version requirement, but was tested with ```torch >= 1.2```

  Other dependencies: ```numpy, scikit-learn, tqdm, torchvision```


  ```
  pip install pytorch-metric-learning
  ```

  **To get the latest dev version**:
  ```
  pip install pytorch-metric-learning --pre
  ```

  **To install on Windows**:
  ```
  pip install torch===1.6.0 torchvision===0.7.0 -f https://download.pytorch.org/whl/torch_stable.html
  pip install pytorch-metric-learning
  ```

  **To install with evaluation and logging capabilities**

  (This will install the unofficial pypi version of faiss-gpu, plus record-keeper and tensorboard):
  ```
  pip install pytorch-metric-learning[with-hooks]
  ```

  **To install with evaluation and logging capabilities (CPU)**

  (This will install the unofficial pypi version of faiss-cpu, plus record-keeper and tensorboard):
  ```
  pip install pytorch-metric-learning[with-hooks-cpu]
  ```


  ```
  conda install -c conda-forge pytorch-metric-learning
  ```

  **To use the testing module, you'll need faiss, which can be installed via conda as well. See the [installation instructions for faiss](https://github.com/facebookresearch/faiss/blob/master/INSTALL.md).**

  </details>




  See [powerful-benchmarker](https://github.com/KevinMusgrave/powerful-benchmarker/) to view benchmark results and to use the benchmarking tool.



  Development is done on the ```dev``` branch:
  ```
  git checkout dev
  ```

  Unit tests can be run with the default ```unittest``` library:
  ```bash
  python -m unittest discover
  ```

  You can specify the test datatypes and test device as environment variables. For example, to test using float32 and float64 on the CPU:
  ```bash
  TEST_DTYPES=float32,float64 TEST_DEVICE=cpu python -m unittest discover
  ```

  To run a single test file instead of the entire test suite, specify the file name:
  ```bash
  python -m unittest tests/losses/test_angular_loss.py
  ```

  Code is formatted using ```black``` and ```isort```:
  ```bash
  pip install black isort
  ./format_code.sh
  ```





  Thanks to the contributors who made pull requests!

  | Contributor | Highlights |
  | -- | -- |
  |[mlopezantequera](https://github.com/mlopezantequera) | - Made the [testers](https://kevinmusgrave.github.io/pytorch-metric-learning/testers) work on any combination of query and reference sets <br/> - Made [AccuracyCalculator](https://kevinmusgrave.github.io/pytorch-metric-learning/accuracy_calculation/) work with arbitrary label comparisons |
  |[cwkeam](https://github.com/cwkeam) | - [VICRegLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#vicregloss) <br/> - Added mean reciprocal rank accuracy to [AccuracyCalculator](https://kevinmusgrave.github.io/pytorch-metric-learning/accuracy_calculation/) |
  |[marijnl](https://github.com/marijnl)| - [BatchEasyHardMiner](https://kevinmusgrave.github.io/pytorch-metric-learning/miners/#batcheasyhardminer) <br/> - [TwoStreamMetricLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/trainers/#twostreammetricloss) <br/> - [GlobalTwoStreamEmbeddingSpaceTester](https://kevinmusgrave.github.io/pytorch-metric-learning/testers/#globaltwostreamembeddingspacetester) <br/> - [Example using trainers.TwoStreamMetricLoss](https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/examples/notebooks/TwoStreamMetricLoss.ipynb) |
  | [chingisooinar](https://github.com/chingisooinar) | [SubCenterArcFaceLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#subcenterarcfaceloss) |
  | [elias-ramzi](https://github.com/elias-ramzi) | [HierarchicalSampler](https://kevinmusgrave.github.io/pytorch-metric-learning/samplers/#hierarchicalsampler) |
  | [fjsj](https://github.com/fjsj) | [SupConLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#supconloss) |
  | [AlenUbuntu](https://github.com/AlenUbuntu) | [CircleLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#circleloss) |
  | [interestingzhuo](https://github.com/interestingzhuo) | [**PNPLoss**](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#pnploss) |
  | [wconnell](https://github.com/wconnell) | [Learning a scRNAseq Metric Embedding](https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/examples/notebooks/scRNAseq_MetricEmbedding.ipynb) |
  | [AlexSchuy](https://github.com/AlexSchuy) | optimized ```utils.loss_and_miner_utils.get_random_triplet_indices``` |
  | [JohnGiorgi](https://github.com/JohnGiorgi) | ```all_gather``` in [utils.distributed](https://kevinmusgrave.github.io/pytorch-metric-learning/distributed) |
  | [Hummer12007](https://github.com/Hummer12007) | ```utils.key_checker``` |
  | [vltanh](https://github.com/vltanh) | Made ```InferenceModel.train_indexer``` accept datasets |
  | [btseytlin](https://github.com/btseytlin) | ```get_nearest_neighbors``` in [InferenceModel](https://kevinmusgrave.github.io/pytorch-metric-learning/inference_models) |
  | [mlw214](https://github.com/mlw214) | Added ```return_per_class``` to [AccuracyCalculator](https://kevinmusgrave.github.io/pytorch-metric-learning/accuracy_calculation/) |
  | [layumi](https://github.com/layumi) | [InstanceLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#instanceloss) |
  | [NoTody](https://github.com/NoTody) | Helped add `ref_emb` and `ref_labels` to the distributed wrappers. |
  | [ElisonSherton](https://github.com/ElisonSherton) | Fixed an edge case in ArcFaceLoss. |
  | [z1w](https://github.com/z1w) | |
  | [thinline72](https://github.com/thinline72) | |
  | [tpanum](https://github.com/tpanum) | |
  | [fralik](https://github.com/fralik) | |
  | [joaqo](https://github.com/joaqo) | |
  | [JoOkuma](https://github.com/JoOkuma) | |
  | [gkouros](https://github.com/gkouros) | |
  | [yutanakamura-tky](https://github.com/yutanakamura-tky) | |
  | [KinglittleQ](https://github.com/KinglittleQ) | |
  | [martin0258](https://github.com/martin0258) | |
  | [michaeldeyzel](https://github.com/michaeldeyzel) | |




  Thank you to [Ser-Nam Lim](https://research.fb.com/people/lim-ser-nam/) at [Facebook AI](https://ai.facebook.com/), and my research advisor, [Professor Serge Belongie](https://vision.cornell.edu/se3/people/serge-belongie/). This project began during my internship at Facebook AI where I received valuable feedback from Ser-Nam, and his team of computer vision and machine learning engineers and research scientists. In particular, thanks to [Ashish Shah](https://www.linkedin.com/in/ashish217/) and [Austin Reiter](https://www.linkedin.com/in/austin-reiter-3962aa7/) for reviewing my code during its early stages of development.


  This library contains code that has been adapted and modified from the following great open-source repos:
  - https://github.com/bnu-wangxun/Deep_Metric
  - https://github.com/chaoyuaw/incubator-mxnet/blob/master/example/gluon/embedding_learning
  - https://github.com/facebookresearch/deepcluster
  - https://github.com/geonm/proxy-anchor-loss
  - https://github.com/idstcv/SoftTriple
  - https://github.com/kunhe/FastAP-metric-learning
  - https://github.com/ronekko/deep_metric_learning
  - https://github.com/tjddus9597/Proxy-Anchor-CVPR2020
  - http://kaizhao.net/regularface


  Thanks to [Jeff Musgrave](https://www.designgenius.ca/) for designing the logo.


  If you'd like to cite pytorch-metric-learning in your paper, you can use this bibtex:
  ```latex
  @article{Musgrave2020PyTorchML,
    title={PyTorch Metric Learning},
    author={Kevin Musgrave and Serge J. Belongie and Ser-Nam Lim},
    journal={ArXiv},
    year={2020},
    volume={abs/2008.09164}
  }
  ```


pkgId: f65de20591b5bb3cf2230c389f77cbc31111048587847693a8382fb4c0014cce
name: python-pytube
arch: src
version: 12.1.3
epoch: 0
release: 1
summary: Python 3 library for downloading YouTube Videos.
url: https://github.com/pytube/pytube
rpm_license: The Unlicense (Unlicense)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3823dca5-2294-46aa-beca-1273c2594fd5
location_href: 00010659-python-pytube/python-pytube-12.1.3-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <p>
      <a href="#"><img src="https://assets.nickficano.com/gh-pytube.min.svg" width="456" height="143" alt="pytube logo" /></a>
    </p>
    <p align="center">
  	<a href="https://pypi.org/project/pytube/"><img src="https://img.shields.io/pypi/dm/pytube?style=flat-square" alt="pypi"/></a>
  	<a href="https://pytube.io/en/latest/"><img src="https://readthedocs.org/projects/python-pytube/badge/?version=latest&style=flat-square" /></a>
  	<a href="https://pypi.org/project/pytube/"><img src="https://img.shields.io/pypi/v/pytube?style=flat-square" /></a>
    </p>
  </div>



  Have ideas for how pytube can be improved? Feel free to open an issue or a pull request!



  *pytube* is a genuine, lightweight, dependency-free Python library (and command-line utility) for downloading YouTube videos.



  Detailed documentation about the usage of the library can be found at [pytube.io](https://pytube.io). This is recommended for most cases. If you want to hastily download a single video, the [quick start](#Quickstart) guide below might be what you're looking for.



  YouTube is the most popular video-sharing platform in the world and as a hacker, you may encounter a situation where you want to script something to download videos. For this, I present to you: *pytube*.

  *pytube* is a lightweight library written in Python. It has no third-party
  dependencies and aims to be highly reliable.

  *pytube* also makes pipelining easy, allowing you to specify callback functions for different download events, such as  ``on progress`` or ``on complete``.

  Furthermore, *pytube* includes a command-line utility, allowing you to download videos right from the terminal.



  - Support for both progressive & DASH streams
  - Support for downloading the complete playlist
  - Easily register ``on_download_progress`` & ``on_download_complete`` callbacks
  - Command-line interfaced included
  - Caption track support
  - Outputs caption tracks to .srt format (SubRip Subtitle)
  - Ability to capture thumbnail URL
  - Extensively documented source code
  - No third-party dependencies



  This guide covers the most basic usage of the library. For more detailed information, please refer to [pytube.io](https://pytube.io).



  Pytube requires an installation of Python 3.6 or greater, as well as pip. (Pip is typically bundled with Python [installations](https://python.org/downloads).)

  To install from PyPI with pip:

  ```bash
  $ python -m pip install pytube
  ```

  Sometimes, the PyPI release becomes slightly outdated. To install from the source with pip:

  ```bash
  $ python -m pip install git+https://github.com/pytube/pytube
  ```



  To download a video using the library in a script, you'll need to import the YouTube class from the library and pass an argument of the video URL. From there, you can access the streams and download them.

  ```python
   >>> from pytube import YouTube
   >>> YouTube('https://youtu.be/2lAe1cqCOXo').streams.first().download()
   >>> yt = YouTube('http://youtube.com/watch?v=2lAe1cqCOXo')
   >>> yt.streams
    ... .filter(progressive=True, file_extension='mp4')
    ... .order_by('resolution')
    ... .desc()
    ... .first()
    ... .download()
  ```



  Using the CLI is remarkably straightforward as well. To download a video at the highest progressive quality, you can use the following command:
  ```bash
  $ pytube https://youtube.com/watch?v=2lAe1cqCOXo
  ```

  You can also do the same for a playlist:
  ```bash
  $ pytube https://www.youtube.com/playlist?list=PLS1QulWo1RIaJECMeUT4LFwJ-ghgoSH6n
  ```


pkgId: 5dce93501431c8b077d30b860566ac1cc1b99aeb6a23e62367969573b47a2a75
name: python-pytz
arch: src
version: 2023.3
epoch: 0
release: 1
summary: World timezone definitions, modern and historical
url: http://pythonhosted.org/pytz
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea158e51-9ecb-41b2-8a18-cdf225d0e91f
location_href: 00008903-python-pytz/python-pytz-2023.3-1.src.rpm
checksum_type: sha256
description:
  Introduction
  ~~~~~~~~~~~~
  pytz brings the Olson tz database into Python. This library allows
  accurate and cross platform timezone calculations using Python 2.4
  or higher. It also solves the issue of ambiguous times at the end
  of daylight saving time, which you can read more about in the Python
  Library Reference (``datetime.tzinfo``).
  Almost all of the Olson timezones are supported.
      Projects using Python 3.9 or later should be using the support
      now included as part of the standard library, and third party
      packages work with it such as `tzdata <https://pypi.org/project/tzdata/>`_.
      pytz offers no advantages beyond backwards compatibility with
      code written for earlier versions of Python.
      This library differs from the documented Python API for
      tzinfo implementations; if you want to create local wallclock
      times you need to use the ``localize()`` method documented in this
      document. In addition, if you perform date arithmetic on local
      times that cross DST boundaries, the result may be in an incorrect
      timezone (ie. subtract 1 minute from 2002-10-27 1:00 EST and you get
      2002-10-27 0:59 EST instead of the correct 2002-10-27 1:59 EDT). A
      ``normalize()`` method is provided to correct this. Unfortunately these
      issues cannot be resolved without modifying the Python datetime
      implementation (see PEP-431).
  Installation
  ~~~~~~~~~~~~
  This package can either be installed using ``pip`` or from a tarball using the
  standard Python distutils.
  If you are installing using ``pip``, you don't need to download anything as the
  latest version will be downloaded for you from PyPI::
      pip install pytz
  If you are installing from a tarball, run the following command as an
  administrative user::
      python setup.py install
  pytz for Enterprise
  ~~~~~~~~~~~~~~~~~~~
  Available as part of the Tidelift Subscription.
  The maintainers of pytz and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. `Learn more. <https://tidelift.com/subscription/pkg/pypi-pytz?utm_source=pypi-pytz&utm_medium=referral&utm_campaign=enterprise&utm_term=repo>`_.
  Example & Usage
  ~~~~~~~~~~~~~~~


pkgId: 235ca672de0df2153a3db20a49eee48c1f9d4f68b14ce55579037ef61425e685
name: python-pyu2f
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: U2F host library for interacting with a U2F device over USB.
url: https://github.com/google/pyu2f/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b2563386-83e1-4bbb-99a8-43ef655b40a0
location_href: 00010479-python-pyu2f/python-pyu2f-0.1.5-1.src.rpm
checksum_type: sha256
description:
  pyu2f is a python based U2F host library for Linux, Windows, and MacOS. It provides functionality for interacting with a U2F device over USB.


pkgId: 80fd557600a89a5a2c73333805ab3ea562e57ca7586d2b7824b998dd84ae3a35
name: python-pyudev
arch: src
version: 0.24.0
epoch: 0
release: 1
summary: A libudev binding
url: http://pyudev.readthedocs.org/
rpm_license: LGPL 2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-057ec85c-1055-44ae-9f16-5746351d9690
location_href: 00010025-python-pyudev/python-pyudev-0.24.0-1.src.rpm
checksum_type: sha256
description:
  Usage of pyudev is quite simply thanks to the power of the underlying udev
  library. Getting the labels of all partitions just takes a few lines:
  >>> import pyudev
  >>> context = pyudev.Context()
  >>> for device in context.list_devices(subsystem='block', DEVTYPE='partition'):
  boot
  swap
  system
  The website_ provides a detailed `user guide`_ and a complete `API reference`_.


pkgId: 5f3106062263b8113a90e61b3cb5a6d18ca301921e6a85dd1a8303f08722cb48
name: python-pyutil
arch: src
version: 3.3.6
epoch: 0
release: 1
summary: a collection of utilities for Python programmers
url: https://github.com/tpltnt/pyutil
rpm_license: GPL-2.0-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eae1d843-2c5c-4762-a503-7c03912e32d3
location_href: 00004881-python-pyutil/python-pyutil-3.3.6-1.src.rpm
checksum_type: sha256
description:
  Many of these utilities (or their ancestors) were developed originally
  by Zooko Wilcox-O'Hearn for the Mojo Nation, Mnet, Allmydata.com "Mountain View",
  Tahoe-LAFS, or SimpleGeo's products. Please note that version 2.X is based
  on Python 2. Version 3.X will has support for Python 3.


pkgId: 0e0b6821165c3505cec762dd425fd5ea8407a9ee76c986c29b738d0a16f9bfb4
name: python-pyvex
arch: src
version: 9.2.41
epoch: 0
release: 1
summary: A Python interface to libVEX and VEX IR
url: https://github.com/angr/pyvex
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7498c1d0-4282-4010-b728-f4e7f191670b
location_href: 00004882-python-pyvex/python-pyvex-9.2.41-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  PyVEX can be pip-installed:

  ```bash
  pip install pyvex
  ```



  If you use PyVEX in an academic work, please cite the paper for which it was developed:

  ```bibtex
  @article{shoshitaishvili2015firmalice,
    title={Firmalice - Automatic Detection of Authentication Bypass Vulnerabilities in Binary Firmware},
    author={Shoshitaishvili, Yan and Wang, Ruoyu and Hauser, Christophe and Kruegel, Christopher and Vigna, Giovanni},
    booktitle={NDSS},
    year={2015}
  }
  ```



  PyVEX exposes VEX into Python. To understand VEX, read the "VEX Intermediate Representation" section below.

  ```python
  import pyvex
  import archinfo


  irsb = pyvex.lift(b"\x90\x90\x90\x90\x90", 0x400400, archinfo.ArchAMD64())


  irsb.pp()


  print(irsb.next)


  print(irsb.jumpkind)


  irsb.next.pp()


  for stmt in irsb.statements:
      stmt.pp()


  import pyvex
  for stmt in irsb.statements:
      if isinstance(stmt, pyvex.IRStmt.Store):
          print("Data:", end="")
          stmt.data.pp()
          print("")

          print("Type:", end="")
          print(stmt.data.result_type)
          print("")


  for stmt in irsb.statements:
      if isinstance(stmt, pyvex.IRStmt.Exit):
          print("Condition:", end="")
          stmt.guard.pp()
          print("")

          print("Target:", end="")
          stmt.dst.pp()
          print("")


  print(irsb.tyenv.types)


  print(irsb.tyenv.types[0])
  ```

  Keep in mind that this is a *syntactic* respresentation of a basic block. That is, it'll tell you what the block means, but you don't have any context to say, for example, what *actual* data is written by a store instruction.



  To deal with widely diverse architectures, it is useful to carry out analyses on an intermediate representation.
  An IR abstracts away several architecture differences when dealing with different architectures, allowing a single analysis to be run on all of them:

  - **Register names.** The quantity and names of registers differ between architectures, but modern CPU designs hold to a common theme: each CPU contains several general purpose registers, a register to hold the stack pointer, a set of registers to store condition flags, and so forth. The IR provides a consistent, abstracted interface to registers on different platforms. Specifically, VEX models the registers as a separate memory space, with integer offsets (i.e., AMD64's `rax` is stored starting at address 16 in this memory space).
  - **Memory access.** Different architectures access memory in different ways. For example, ARM can access memory in both little-endian and big-endian modes. The IR must abstracts away these differences.
  - **Memory segmentation.** Some architectures, such as x86, support memory segmentation through the use of special segment registers. The IR understands such memory access mechanisms.
  - **Instruction side-effects.** Most instructions have side-effects. For example, most operations in Thumb mode on ARM update the condition flags, and stack push/pop instructions update the stack pointer. Tracking these side-effects in an *ad hoc* manner in the analysis would be crazy, so the IR makes these effects explicit.

  There are lots of choices for an IR. We use VEX, since the uplifting of binary code into VEX is quite well supported.
  VEX is an architecture-agnostic, side-effects-free representation of a number of target machine languages.
  It abstracts machine code into a representation designed to make program analysis easier.
  This representation has five main classes of objects:

  - **Expressions.** IR Expressions represent a calculated or constant value. This includes memory loads, register reads, and results of arithmetic operations.
  - **Operations.** IR Operations describe a *modification* of IR Expressions. This includes integer arithmetic, floating-point arithmetic, bit operations, and so forth. An IR Operation applied to IR Expressions yields an IR Expression as a result.
  - **Temporary variables.** VEX uses temporary variables as internal registers: IR Expressions are stored in temporary variables between use. The content of a temporary variable can be retrieved using an IR Expression. These temporaries are numbered, starting at `t0`. These temporaries are strongly typed (i.e., "64-bit integer" or "32-bit float").
  - **Statements.** IR Statements model changes in the state of the target machine, such as the effect of memory stores and register writes. IR Statements use IR Expressions for values they may need. For example, a memory store *IR Statement* uses an *IR Expression* for the target address of the write, and another *IR Expression* for the content.
  - **Blocks.** An IR Block is a collection of IR Statements, representing an extended basic block (termed "IR Super Block" or "IRSB") in the target architecture. A block can have several exits. For conditional exits from the middle of a basic block, a special *Exit* IR Statement is used. An IR Expression is used to represent the target of the unconditional exit at the end of the block.

  VEX IR is actually quite well documented in the `libvex_ir.h` file (https://github.com/angr/vex/blob/dev/pub/libvex_ir.h) in the VEX repository. For the lazy, we'll detail some parts of VEX that you'll likely interact with fairly frequently. To begin with, here are some IR Expressions:

  | IR Expression | Evaluated Value | VEX Output Example |
  | ------------- | --------------- | ------- |
  | Constant | A constant value. | 0x4:I32 |
  | Read Temp | The value stored in a VEX temporary variable. | RdTmp(t10) |
  | Get Register | The value stored in a register. | GET:I32(16) |
  | Load Memory | The value stored at a memory address, with the address specified by another IR Expression. | LDle:I32 / LDbe:I64 |
  | Operation | A result of a specified IR Operation, applied to specified IR Expression arguments. | Add32 |
  | If-Then-Else | If a given IR Expression evaluates to 0, return one IR Expression. Otherwise, return another. | ITE |
  | Helper Function | VEX uses C helper functions for certain operations, such as computing the conditional flags registers of certain architectures. These functions return IR Expressions. | function\_name() |

  These expressions are then, in turn, used in IR Statements. Here are some common ones:

  | IR Statement | Meaning | VEX Output Example |
  | ------------ | ------- | ------------------ |
  Write Temp | Set a VEX temporary variable to the value of the given IR Expression. | WrTmp(t1) = (IR Expression) |
  Put Register | Update a register with the value of the given IR Expression. | PUT(16) = (IR Expression) |
  Store Memory | Update a location in memory, given as an IR Expression, with a value, also given as an IR Expression. | STle(0x1000) = (IR Expression) |
  Exit | A conditional exit from a basic block, with the jump target specified by an IR Expression. The condition is specified by an IR Expression. | if (condition) goto (Boring) 0x4000A00:I32 |

  An example of an IR translation, on ARM, is produced below. In the example, the subtraction operation is translated into a single IR block comprising 5 IR Statements, each of which contains at least one IR Expression (although, in real life, an IR block would typically consist of more than one instruction). Register names are translated into numerical indices given to the *GET* Expression and *PUT* Statement.
  The astute reader will observe that the actual subtraction is modeled by the first 4 IR Statements of the block, and the incrementing of the program counter to point to the next instruction (which, in this case, is located at `0x59FC8`) is modeled by the last statement.

  The following ARM instruction:

      subs R2, R2, #8

  Becomes this VEX IR:

      t0 = GET:I32(16)
      t1 = 0x8:I32
      t3 = Sub32(t0,t1)
      PUT(16) = t3
      PUT(68) = 0x59FC8:I32

  Cool stuff!


pkgId: 5fed561eb6a8e1103472af51bf909981b283508f3618e85c01fd6b3f547f19ee
name: python-pyvlx
arch: src
version: 0.2.20
epoch: 0
release: 1
url: https://github.com/Julius2342/pyvlx
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ecc5f4ae-f777-4780-a561-4f8323f36ffe
location_href: 00004885-python-pyvlx/python-pyvlx-0.2.20-1.src.rpm
checksum_type: sha256
summary:
  PyVLX is a wrapper for the Velux KLF 200 API. PyVLX enables you to run scenes and or open and close velux windows.

description:
  [![CI](https://github.com/Julius2342/pyvlx/actions/workflows/ci.yml/badge.svg)](https://github.com/Julius2342/pyvlx/actions/workflows/ci.yml)
  PyVLX uses the Velux KLF 200 interface to control io-Homecontrol devices, e.g. Velux Windows.


pkgId: e422c91f6c9c1b43dd5a618853e14f186eeb9f4875e60e44a77a6666f18fba9e
name: python-pyvmomi
arch: src
version: 8.0.0.1.2
epoch: 0
release: 1
summary: VMware vSphere Python SDK
url: https://github.com/vmware/pyvmomi
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4d05377b-d8fb-4226-a1a8-f9909fa8baf9
location_href: 00009626-python-pyvmomi/python-pyvmomi-8.0.0.1.2-1.src.rpm
checksum_type: sha256
description:
  To get started, see the
  `getting started guide <http://vmware.github.io/pyvmomi-community-samples/#getting-started>`_.
  You'll need `Python <https://www.python.org/downloads/>`_,
  `pip <https://pip.pypa.io/en/latest/installation/>`_, and the
  `samples project <http://vmware.github.io/pyvmomi-community-samples/>`_.


pkgId: 952c707f9c5cfa80ef47ac737f56cf5efd6d487f2ff8e2385f4ace197caaa3c3
name: python-pyvo
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Astropy affiliated package for accessing Virtual Observatory data and services
url: https://github.com/astropy/pyvo
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-38787d92-a4ee-4b66-adc1-364742d6fd18
location_href: 00004886-python-pyvo/python-pyvo-1.4.1-1.src.rpm
checksum_type: sha256
description:
  PyVO is a package providing access to remote data and services of the
  Virtual observatory (VO) using Python.
  Its development was launched by the NSF/NASA-funded Virtual Astronomical
  Observatory (VAO, www.usvao.org) project (formerly under the name
  VAOpy) as part of its initiative to bring VO capabilities to desktop.
  Its goal is to allow astronomers and tool developers to access data and
  services from remote archives and other web resources.  It takes
  advantage of VO standards to give access to thousands of catalogs,
  data archives, information services, and analysis tools.  It also
  takes advantage of the general capabilities of Astopy (and numpy), and
  so a secondary goal is to provide a development platform for migrating
  more VO capabilities into Astropy.
  Source code can be found `on GitHub <http://github.com/astropy/pyvo>`_


pkgId: 16cebf91bed63f1f65df7046b40e278a2b6b5e5be048707060b80aff03273a12
name: python-pywebpush
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: WebPush publication library
url: https://github.com/web-push-libs/pywebpush
rpm_license: MPL2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5fc9512-c4a1-4bbb-b532-f310b52c3767
location_href: 00011190-python-pywebpush/python-pywebpush-1.14.0-1.src.rpm
checksum_type: sha256
description:
  This is a work in progress. This library is available on `pypi as
  pywebpush <https://pypi.python.org/pypi/pywebpush>`__. Source is
  available on `github <https://github.com/mozilla-services/pywebpush>`__.


pkgId: 6fca801937114b75368f6cb9a19ba61744d6d3fe08fc1848a0bef91de14064c8
name: python-pywebview
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: Build GUI for your Python program with JavaScript, HTML, and CSS.
url: https://github.com/r0x0r/pywebview
rpm_license: New BSD license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-24189c8a-6175-4847-829c-b6d0d93a51a0
location_href: 00013894-python-pywebview/python-pywebview-4.0.2-1.src.rpm
checksum_type: sha256
description:
  <p align='center'><img src='logo/logo.png' width=480 alt='pywebview logo'/></p>

  <p align='center'><a href="https://opencollective.com/pywebview" alt="Financial Contributors on Open Collective"><img src="https://opencollective.com/pywebview/all/badge.svg?label=financial+contributors" /></a> <img src="https://badge.fury.io/py/pywebview.svg" alt="PyPI version" /> <img src="https://img.shields.io/pypi/dm/pywebview" alt="PyPI downloads" /> <a href="https://ci.appveyor.com/project/r0x0r/pywebview"><img src="https://ci.appveyor.com/api/projects/status/nu6mbhvbq03wudxd/branch/master?svg=true" alt="Build status" /></a>

  https://pywebview.flowrl.com
  </p>


  _pywebview_ is a lightweight cross-platform wrapper around a webview component that allows to display HTML content in its own native GUI window. It gives you power of web technologies in your desktop application, hiding the fact that GUI is browser based. You can use pywebview either with a lightweight web framework like [Flask](http://flask.pocoo.org/) or [Bottle](http://bottlepy.org/docs/dev/index.html) or on its own with a two way bridge between Python and DOM.

  _pywebview_ uses native GUI for creating a web component window: WinForms on Windows, Cocoa on macOS and QT or GTK on Linux. If you choose to freeze your application, pywebview does not bundle a heavy GUI toolkit or web renderer with it keeping the executable size small. _pywebview_ is compatible with Python 3.

  _pywebview_ is created by [Roman Sirokov](https://github.com/r0x0r/).







  ``` bash
  pip install pywebview
  ```
  - _Currently only python version 3.8 or older supported on Windows._
  - _On Linux you need additional libraries. Refer to the [installation](https://pywebview.flowrl.com/guide/installation.html) page for details._



  ``` python
  import webview
  webview.create_window('Hello world', 'https://pywebview.flowrl.com/hello')
  webview.start()
  ```

  Explore _pywebview_ further by reading [documentation](https://pywebview.flowrl.com/guide), [examples](https://pywebview.flowrl.com/examples) or [contributing](https://pywebview.flowrl.com/contributing). If React is your thing, get started right away with [React boilerplate](https://github.com/r0x0r/pywebview-react-boilerplate).







  This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
  <a href="https://github.com/r0x0r/pywebview/graphs/contributors"><img src="https://opencollective.com/pywebview/contributors.svg?width=890&button=false" /></a>



  Become a financial contributor and help us sustain our community. More donation options are outlined on the [Donating](https://pywebview.flowrl.com/contributing/donating.html) page.




  <a href="https://opencollective.com/pywebview"><img src="https://opencollective.com/pywebview/individuals.svg?width=890"></a>

  <a href="https://www.patreon.com/bePatron?u=13226105" data-patreon-widget-type="become-patron-button"><img src='https://c5.patreon.com/external/logo/become_a_patron_button.png' alt='Become a Patron!'/></a>




  Support this project with your organization. Your logo will show up here with a link to your website. [[Contribute](https://opencollective.com/pywebview/contribute)]

  <a href="https://opencollective.com/pywebview/organization/0/website"><img src="https://opencollective.com/pywebview/organization/0/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/1/website"><img src="https://opencollective.com/pywebview/organization/1/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/2/website"><img src="https://opencollective.com/pywebview/organization/2/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/3/website"><img src="https://opencollective.com/pywebview/organization/3/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/4/website"><img src="https://opencollective.com/pywebview/organization/4/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/5/website"><img src="https://opencollective.com/pywebview/organization/5/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/6/website"><img src="https://opencollective.com/pywebview/organization/6/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/7/website"><img src="https://opencollective.com/pywebview/organization/7/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/8/website"><img src="https://opencollective.com/pywebview/organization/8/avatar.svg"></a>
  <a href="https://opencollective.com/pywebview/organization/9/website"><img src="https://opencollective.com/pywebview/organization/9/avatar.svg"></a>


pkgId: f9530fe6bda2fd78ea24007536d92c91e342a20f2553c6cb78805ded9f4ad836
name: python-pywinauto
arch: src
version: 0.6.8
epoch: 0
release: 1
summary: A set of Python modules to automate the Microsoft Windows GUI
url: http://pywinauto.github.io/
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3575a151-9fb5-4285-876c-3ae7a492fdb3
location_href: 00010260-python-pywinauto/python-pywinauto-0.6.8-1.src.rpm
checksum_type: sha256
description:
  - Home page: http://pywinauto.github.io/
  - Docs Intro: https://pywinauto.readthedocs.io/en/latest/
  - Getting Started Guide: https://pywinauto.readthedocs.io/en/latest/getting_started.html
  - StackOverflow tag: https://stackoverflow.com/questions/tagged/pywinauto


pkgId: 7006a7ae21fcdcc3b31e6027504736fb0cdffc2254d65508fa57a127168f0c66
name: python-pywinrm
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Python library for Windows Remote Management
url: http://github.com/diyan/pywinrm/
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1d5099e-c319-4363-b054-7f2eaa717fd4
location_href: 00010046-python-pywinrm/python-pywinrm-0.4.3-1.src.rpm
checksum_type: sha256
description:
  pywinrm is a Python client for the Windows Remote Management (WinRM)
  service. It allows you to invoke commands on target Windows machines
  from any machine that can run Python.
  |License| |Test workflow| |Coverage| |PyPI|
  WinRM allows you to perform various management tasks remotely. These
  include, but are not limited to: running batch scripts, powershell
  scripts, and fetching WMI variables.
  Used by `Ansible <https://www.ansible.com/>`__ for Windows support.
  For more information on WinRM, please visit `Microsoft’s WinRM
  site <http://msdn.microsoft.com/en-us/library/aa384426.aspx>`__.


pkgId: 371277fda74fab9638afe8183f77887346652bb4322cf6b73c51412ff7b98922
name: python-pywizlight
arch: src
version: 0.5.14
epoch: 0
release: 1
summary: A python connector for WiZ light bulbs (e.g SLV Play)
url: https://github.com/sbidy/pywizlight
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2ef0a409-50bd-4e39-9d34-68e71d73273e
location_href: 00004889-python-pywizlight/python-pywizlight-0.5.14-1.src.rpm
checksum_type: sha256
description:
  ![Upload Python Package](https://github.com/sbidy/pywizlight/workflows/Upload%20Python%20Package/badge.svg)

  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  [![All Contributors](https://img.shields.io/badge/all_contributors-18-orange.svg?style=flat-square)](#contributors-)
  <!-- ALL-CONTRIBUTORS-BADGE:END -->

  ![Update Docs](https://github.com/sbidy/pywizlight/workflows/Update%20Docs/badge.svg)
  [![Lint](https://github.com/sbidy/pywizlight/actions/workflows/lint.yml/badge.svg)](https://github.com/sbidy/pywizlight/actions/workflows/lint.yml)
  [![codecov][code-cover-shield]][code-coverage]




  A Python connector for [WiZ](https://www.wizconnected.com/en/consumer/) devices.



  ```bash
  pip install pywizlight
  ```

  **Note:** Requires Python version `>=3.7`.



  On a Fedora-based system or on a CentOS/RHEL 8 machine which has EPEL enabled, as
  [`pywizlight`](https://src.fedoraproject.org/rpms/python-pywizlight) is present in the
  Fedora Package Collection.

  ```bash
  sudo dnf -y install python3-pywizlight
  ```



  For NixOS and Nix the latest release of `pywizlight` is usually available in the [`unstable`](https://search.nixos.org/packages?channel=unstable&query=pywizlight)
  channel. Stable releases might ship older versions of `pywizlight`.

  ```bash
  nix-env -iA nixos.python37Packages.pywizlight
  ```



  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="http://mtnspring.org"><img src="https://avatars.githubusercontent.com/u/223277?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Seth Nickell</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=snickell" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/daanzu"><img src="https://avatars.githubusercontent.com/u/4319503?v=4?s=100" width="100px;" alt=""/><br /><sub><b>David Zurow</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=daanzu" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/eibanez"><img src="https://avatars.githubusercontent.com/u/438494?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Eduardo Ibanez</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=eibanez" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/angadsingh"><img src="https://avatars.githubusercontent.com/u/1623026?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Angad Singh</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=angadsingh" title="Code">💻</a></td>
      <td align="center"><a href="http://fabian-affolter.ch/blog/"><img src="https://avatars.githubusercontent.com/u/116184?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Fabian Affolter</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=fabaff" title="Documentation">📖</a> <a href="https://github.com/sbidy/pywizlight/commits?author=fabaff" title="Code">💻</a></td>
      <td align="center"><a href="https://redaxmedia.com"><img src="https://avatars.githubusercontent.com/u/1835397?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Henry Ruhs</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=redaxmedia" title="Code">💻</a></td>
      <td align="center"><a href="https://www.panu.it/"><img src="https://avatars.githubusercontent.com/u/2248402?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Alberto Panu</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=bigjohnson" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/skitterrusty"><img src="https://avatars.githubusercontent.com/u/71942600?v=4?s=100" width="100px;" alt=""/><br /><sub><b>skitterrusty</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=skitterrusty" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/mots"><img src="https://avatars.githubusercontent.com/u/26517?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mathias Roth</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=mots" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/durnezj"><img src="https://avatars.githubusercontent.com/u/11504333?v=4?s=100" width="100px;" alt=""/><br /><sub><b>durnezj</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=durnezj" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/Dirty-No"><img src="https://avatars.githubusercontent.com/u/54525684?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Noëlle</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=Dirty-No" title="Documentation">📖</a></td>
      <td align="center"><a href="https://linkedin.com/in/scriptsrc"><img src="https://avatars.githubusercontent.com/u/8009126?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Patrick Kelley</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=scriptsrc" title="Documentation">📖</a></td>
      <td align="center"><a href="http://ellismichael.com"><img src="https://avatars.githubusercontent.com/u/1312141?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ellis Michael</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=emichael" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/SvbZ3r0"><img src="https://avatars.githubusercontent.com/u/57280279?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Gughan Ravikumar</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=SvbZ3r0" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/CharlotteCross1998"><img src="https://avatars.githubusercontent.com/u/29734551?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Charlotte</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=CharlotteCross1998" title="Code">💻</a></td>
      <td align="center"><a href="https://akx.github.io/"><img src="https://avatars.githubusercontent.com/u/58669?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Aarni Koskela</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=akx" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/UH-60"><img src="https://avatars.githubusercontent.com/u/4968133?v=4?s=100" width="100px;" alt=""/><br /><sub><b>UH-60</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=UH-60" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/bdraco"><img src="https://avatars.githubusercontent.com/u/663432?v=4?s=100" width="100px;" alt=""/><br /><sub><b>J. Nick Koston</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=bdraco" title="Code">💻</a></td>
    </tr>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->



  To find bulbs via cli you can use the following:
  ```bash
  python -m pywizlight.cli discover
  ```



  ```python
  import asyncio

  from pywizlight import wizlight, PilotBuilder, discovery

  async def main():
      """Sample code to work with bulbs."""
      
      
      bulbs = await discovery.discover_lights(broadcast_space="192.168.1.255")
      
      print(f"Bulb IP address: {bulbs[0].ip}")

      
      for bulb in bulbs:
          print(bulb.__dict__)
          
          

      
      light = wizlight("192.168.1.27")
      
      

      
      
      

      
      await light.turn_on(PilotBuilder())
      
      await light.turn_on(PilotBuilder(brightness = 255))

      
      timeout = 10
      await asyncio.wait_for(light.turn_on(PilotBuilder(brightness = 255)), timeout)

      
      await light.turn_on(PilotBuilder(warm_white = 255))

      
      
      await light.turn_on(PilotBuilder(rgb = (0, 128, 255)))

      
      state = await light.updateState()
      print(state.get_colortemp())
      red, green, blue = state.get_rgb()
      print(f"red {red}, green {green}, blue {blue}")

      
      await light.turn_on(PilotBuilder(scene = 4)) # party

      
      state = await light.updateState()
      print(state.get_scene())

      
      bulb_type = await bulbs[0].get_bulbtype()
      print(bulb_type.features.brightness) # returns True if brightness is supported
      print(bulb_type.features.color) # returns True if color is supported
      print(bulb_type.features.color_tmp) # returns True if color temperatures are supported
      print(bulb_type.features.effect) # returns True if effects are supported
      print(bulb_type.kelvin_range.max) # returns max kelvin in INT
      print(bulb_type.kelvin_range.min) # returns min kelvin in INT
      print(bulb_type.name) # returns the module name of the bulb

      
      await light.turn_off()

      
      
      
      
      
      
      
      
      
      
      

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  ```



  `wizlight` is a command-line tool to perform basic interactions with bulbs.

  ```console
  $ wizlight
  Usage: wizlight [OPTIONS] COMMAND [ARGS]...

    Simple command-line tool to interact with Wizlight bulbs.

  Options:
    --version  Show the version and exit.
    --help     Show this message and exit.

  Commands:
    discover  Discover bulb in the local network.
    off       Turn the bulb off.
    on        Turn the bulb on.
    state     Get the current state from the given bulb.
  ```



  The discovery works with a UDP Broadcast request and collects all bulbs in the network.



  - **sceneId** - calls one of the predefined scenes (int from 1 to 32) [List of names in code](https://github.com/sbidy/pywizlight/blob/master/pywizlight/scenes.py)
  - **speed** - sets the color changing speed in percent
  - **dimming** - sets the dimmer of the bulb in percent
  - **temp** - sets the color temperature in kelvins
  - **r** - red color range 0-255
  - **g** - green color range 0-255
  - **b** - blue color range 0-255
  - **c** - cold white range 0-255
  - **w** - warm white range 0-255
  - **id** - the bulb id
  - **state** - whether it's on or off
  - **schdPsetId** - rhythm id of the room



  For async I/O this component uses Python's built-in asyncio DatagramTransport, which allows completely non-blocking UDP transport.



  `wizlight(ip)`: Creates an instance of a WiZ Light Bulb. Constructed with the IP addCancel changesress of the bulb.



  First you need to fetch the state by calling `light.updateState()`.
  After that all states can be fetched from `light.state`, which is a `PilotParser` object.

  `PilotParser.get_brightness()`gets the value of the brightness 0-255

  `PilotParser.get_rgb()` gets the rgbW color state of the bulb

  `PilotParser.get_colortemp()` gets the color temperature of the bulb

  `PilotParser.get_warm_white/get_cold_white()` gets the current warm/cold setting (not supported by original Philips Wiz bulbs)

  `PilotParser.get_scene()` gets the current scene name

  `PilotParser.get_state()` returns True/False. True = on, False = off



  `getBulbConfig(self)` returns the hardware configuration of the bulb

  `updateState(self)` gets the current bulb state from the light using `sendUDPMessage` and sets it to `self.state`

  `lightSwitch(self)` toggles the light bulb on or off like a switch

  `getMAC(self)` returns the MAC address of the bulb. Can be used as a unique ID

  `sendUDPMessage(self, message, timeout = 60, send_interval = 0.5, max_send_datagrams = 100):` sends the UDP message to the bulb. Since UDP can lose packets, and your light might be a long distance away from the router, we continuously keep sending the UDP command datagram until there is a response from the bulb. In tests this worked way better than just sending once and waiting for a timeout. You can set the async operation timeout using `timeout`, set the time interval to sleep between continuous UDP sends using `send_interval` and the maximum number of continuous pings to send using `max_send_datagrams`. It is already hardcoded to a lower value for `setPilot` (set light state) vs `getPilot` (fetch light state) to avoid flickering the light.

  `turn_off(self)` turns the light off

  `turn_on(PilotBuilder)` turns the light on. This takes a `PilotBuilder` object, which can be used to set all the parameters programmatically - rgb, color temperature, brightness, etc. To set the light to rhythm mode, create an empty `PilotBuilder`.



  - **getSystemConfig** - gets the current system configuration - no parameters required
  - **syncPilot** - sent by the bulb as heartbeats
  - **getPilot** - gets the current bulb state - no parameters required
  - **setPilot** - used to tell the bulb to change color/temp/state
  - **Pulse** - uncertain of purpose
  - **Registration** - used to "register" with the bulb: This notifies the bulb if you want it to send you heartbeat sync packets



  - syncUserConfig
  - syncPilot - {"method":"syncPilot","env":"pro","params":{"mac":"ABCABCABC","rssi":-71,"src":"udp","state":true,"sceneId":0,"temp":6500,"dimming":62}}
  - syncSchdPset
  - syncBroadcastPilot
  - syncSystemConfig
  - syncConfig
  - syncAlarm



  - pulse - {"method":"pulse", "params":{"delta":-15,"duration":300}}
  - registration - {"method":"registration","id":105, "params":{"phoneIp":"10.0.0.0","phoneMac":"aaaaaaaaaaaa","register":true}}
  - setUserConfig
  - setSystemConfig
  - setDevInfo
  - setSchd
  - setSchdPset
  - setWifiConfig
  - reset
  - setFavs
  - setState
  - setPilot



  - getPilot
  - getUserConfig
  - getSystemConfig
  - getWifiConfig
  - reboot
  - getDevInfo



  - Parse error
  - Invalid Request
  - Method not found
  - Invalid params
  - Internal error
  - Success



  Send message to the bulb:
  `{"method":"setPilot","params":{"r":255,"g":255,"b":255,"dimming":50}}`
  Response: `{"method":"setPilot","env":"pro","result":{"success":true}}`

  Get state of the bulb:
  `{"method":"getPilot","params":{}}`
  Responses:

  custom color mode:

  `{'method': 'getPilot', 'env': 'pro', 'result': {'mac': 'a8bb50a4f94d', 'rssi': -60, 'src': '', 'state': True, 'sceneId': 0, 'temp': 5075, 'dimming': 47}}`

  scene mode:

  `{'method': 'getPilot', 'env': 'pro', 'result': {'mac': 'a8bb50a4f94d', 'rssi': -65, 'src': '', 'state': True, 'sceneId': 12, 'speed': 100, 'temp': 4200, 'dimming': 47}}`

  rhythm mode:

  `{'method': 'getPilot', 'env': 'pro', 'result': {'mac': 'a8bb50a4f94d', 'rssi': -63, 'src': '', 'state': True, 'sceneId': 14, 'speed': 100, 'dimming': 100, 'schdPsetId': 9}}`

  [code-coverage]: https://codecov.io/gh/sbidy/pywizlight
  [code-cover-shield]: https://codecov.io/gh/sbidy/pywizlight/branch/master/graph/badge.svg


pkgId: 10e57b6054f1f5f92cdf9a5176e8f8e577a9af47c3c6e9ab5abefbc380d6a40c
name: python-pyxero
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: Python API for accessing the REST API of the Xero accounting tool.
url: http://github.com/freakboy3742/pyxero
rpm_license: New BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-771e45ed-68a6-4f63-905b-c80c06454b45
location_href: 00013036-python-pyxero/python-pyxero-0.9.3-1.src.rpm
checksum_type: sha256
description:
  [![Python Versions](https://img.shields.io/pypi/pyversions/pyxero.svg)](https://pypi.python.org/pypi/pyxero) [![PyPI Version](https://img.shields.io/pypi/v/pyxero.svg)](https://pypi.python.org/pypi/pyxero) [![Maturity](https://img.shields.io/pypi/status/pyxero.svg)](https://pypi.python.org/pypi/pyxero) [![BSD License](https://img.shields.io/pypi/l/pyxero.svg)](https://github.com/freakboy3742/pyxero/blob/master/LICENSE) [![Build Status](https://github.com/freakboy3742/pyxero/workflows/Build%20status/badge.svg)](https://github.com/freakboy3742/pyxero/actions)
  PyXero is a Python API for accessing the REST API provided by the [Xero](https://developer.xero.com)
  accounting tool. It allows access to both Public, Private and Partner applications.

  Install this library using the python package manager:
  ```
  pip install pyxero
  ```
  You'll need to follow the [Xero Developer documentation](https://developer.xero.com/documentation/) to register your application. Do that as follows:

  Public applications use a 3-step OAuth process.
  When you [register your public application with Xero](https://developer.xero.com/documentation/auth-and-limits/public-applications/), you'll be given a
  **Consumer Key** and a **Consumer secret**. These are both strings.
  To access the Xero API you must first create some credentials:
  ```python
  >>> from xero.auth import PublicCredentials
  >>> credentials = PublicCredentials(<consumer_key>, <consumer_secret>)
  >>> print credentials.url
  'http://my.xero.com/.....'
  ```
  You now direct the user to visit the URL described by `credentials.url`. They
  will be asked to log into their Xero account, and then shown a request to
  authenticate your request to access the user's account. When the allow access,
  they will be directed to a page that gives them a 6-digit verification number.
  Put this verifier number into a string, and call `verify()` on the credentials
  object::
  ```python
  >>> credentials.verify(<verifier string>)
  ```
  This will verify your credentials, and retrieve an access token. You can
  then use your credentials to instantiate an instance of the Xero API::
  ```python
  >>> from xero import Xero
  >>> xero = Xero(credentials)
  ```

  Public applications can also be validated using a callback URI. If this
  approach is used, the user won't be given a verification number. Instead,
  when they authorize the OAuth request, their browser will be redirected to
  a pre-configured callback URI, which will deliver the validation token
  directly to your application.
  To use a callback, you must provide a domain as part of your Xero application
  registration; then, you provide a URL under that domain as the third argument
  when creating the credentials::
  ```python
  >>> credentials = PublicCredentials(<consumer_key>, <consumer_secret>, <callback_uri>)
  >>> print credentials.url
  'http://my.xero.com/.....'
  ```
  When the user authorizes access to their Xero account, the `callback_url`
  will be called with three GET arguments:
  * `oauth_token`: The oauth_token that this request belongs to
  * `oauth_verifier`: The verifier string
  * `org`: An identifier for the organization that is allowing access.
  The verifier can then be used to verify the credentials, as with the manual
  process.

  Public Applications use a 3-step OAuth process, and if you're doing this in a
  web application, you will usually lose the credentials object over the
  verification step. This means you need to be able to restore the credentials
  object when verification has been provided.
  The `state` attribute of a credentials object contains all the details needed
  to reconstruct an instance of the credentials::
  ```python
  >>> saved_state = credentials.state
  >>> print saved_state
  {'consumer_key': '...', 'consumer_secret': '...', ...}
  >>> new_credentials = PublicCredentials(**saved_state)
  ```

  *Private Applications are deprecated by Xero*. An alternative is to use the machine-to-machine method. This is fundamentally an OAuth2 flow, but Xero provides a helper executable to get tokens from a local machine without needing a server to host a callback. See [Xero Machine to Machine authentication](https://developer.xero.com/documentation/api-guides/machine-2-machine)
  If using a Private application, you will need to install `PyCrypto`, a pure
  Python cryptographic module. You'll also need to generate an signed RSA
  certificate, and submit that certificate as part of registering your
  application with Xero. See the [Xero Developer documentation](https://developer.xero.com/) for more
  details.
  When you [register your private application with Xero](https://developer.xero.com/documentation/auth-and-limits/private-applications/), you'll be given a
  **Consumer Key**. You'll also be given a **Consumer secret** - this can be
  ignored.
  Using the Private credentials is much simpler than the Public credentials,
  because there's no verification step -- verification is managed using RSA
  signed API requests::
  ```python
  >>> from xero import Xero
  >>> from xero.auth import PrivateCredentials
  >>> with open(<path to rsa key file>) as keyfile:
  >>> credentials = PrivateCredentials(<consumer_key>, rsa_key)
  >>> xero = Xero(credentials)
  ```
  [Follow these steps](https://developer.xero.com/documentation/api-guides/create-publicprivate-key/) to generate a public/private key pair to sign your requests.  You'll upload your public key when you create your Xero Private app at https://app.xero.com.  You'll use the private key (aka RSA key) to generate your oAuth signature.


pkgId: 129b57350ddfa69e0e43f0316d47651b7863db48d49d5c97f400555b0b203e9c
name: python-pyxid
arch: src
version: 1.0
epoch: 0
release: 1
summary: Pure python library for communicating with Cedrus XID and StimTracker devices.
url: http://www.github.com/cedrus-opensource/pyxid/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5e7ab254-67f7-4d2c-adc0-1403ca4f34d7
location_href: 00004891-python-pyxid/python-pyxid-1.0-1.src.rpm
checksum_type: sha256
description:
  Python library for interfacing with Cedrus XID and StimTracker devices

  XID (eXperiment Interface Device) devices are used in software such as
  SuperLab, Presentation, and ePrime for receiving input as part of
  stimulus/response testing experiments.

  This handles all of the low level device handling for XID devices in
  python projects.  The developer using this library must poll the
  attached device(s) for responses.  Here's an example of how to do so:

      import pyxid

      
      devices = pyxid.get_xid_devices()

      dev = devices[0] # get the first device to use
      if dev.is_response_device():
          dev.reset_base_timer()
          dev.reset_rt_timer()

          while True:
              dev.poll_for_response()
              if dev.response_queue_size() > 0:
                  response = dev.get_next_response()
                  


  The response is a python dict with the following keys:

      pressed: True if the key was pressed, False if it was released
      key: Response pad key pressed by the subject
      port: Device port the response was from (typically 0)
      time: value of the Response Time timer when the key was hit/released


  StimTracker

  Support for Cedrus StimTracker devices is now included.  On StimTracker
  devices, there are the following methods:

      set_pulse_duration()
      activate_line()
      clear_line()

  See the docstring for activate_line() for documentation on how to use it.

  These methods are not available if the device is a response pad.

  StimTracker is used in software such as SuperLab, Presentation and ePrime
  for sending event markers.


  Timers

  Each Cedrus XID device has an internal timer a Base Timer and a
  Response Time Timer.  The Base Timer should be reset at the start of
  an experiment.  The Response Time timer should be reset whenever a
  stimulus is presented.

  At the time of this library release, there is a known issue with clock
  drift in XID devices.  Our hardware/firmware developer is currently
  looking into the issue.

  Given the issue, use of the response timer built into the response
  pads is optional.  If you wish to use the time reported from the
  response pads, do the following after importing the pyxid library:

      import pyxid
      pyxid.use_response_pad_timer = True

  This will return the time in the 'time' field of the dict returned by
  XidDevice.get_next_response(), otherwise, the 'time' field will
  contain 0.

  Windows Specific Issues

  Sometimes, windows fails at detecting XID devices.  Running
  detect_xid_devices() a second time should result in finding the
  devices.


pkgId: 0c2359de126a893485bed92419bc1555a22456e366ad0d736b04b3c118f42379
name: python-pyxlsb
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Excel 2007-2010 Binary Workbook (xlsb) parser
url: https://github.com/willtrnr/pyxlsb
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a34a6f2-5c4c-46f4-94d3-244e00117060
location_href: 00010371-python-pyxlsb/python-pyxlsb-1.0.10-1.src.rpm
checksum_type: sha256
description:
  |PyPI|
  ``pyxlsb`` is an Excel 2007-2010 Binary Workbook (xlsb) parser for
  Python. The library is currently extremely limited, but functional
  enough for basic data extraction.


pkgId: 331f8d6b6f4f882fe75b749985efa3cea93270232c51d4018134721242b68d14
name: python-pyxlsx
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/fortfall/pyxlsx
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7962076b-6ce4-4fcb-93e4-c970f64f4d5e
location_href: 00009624-python-pyxlsx/python-pyxlsx-1.1.3-1.src.rpm
checksum_type: sha256
description:
  A package to read/write xlsx worksheet like dictionary, based on openpyxl.


  * from pip
  ```python
  pip install pyxlsx
  ```
  * download package and run setup.py
  ```python
  python setup.py install
  ```


  * Create a new xlsx file and write to it
  ```python
  from pyxlsx import new_xlsx

  with new_xlsx(filename) as wb:
      ws = wb.create_sheet('sheet1')
      


  wb = new_xlsx()
  ws = wb.creat_sheet('sheet1')  # create a new sheet with name 'sheet1'

  wb.save(filename)
  ```
  * Open an existing xlsx file
  ```python
  from pyxlsx import open_xlsx

  with open_xlsx(filename) as wb:
      ws1 = wb.active  # get active sheet
      ws2 = wb['sheet2']
      


  wb = open_xlsx(filename)
  ws = wb['sheet2']

  wb.save()

  wb.save(another_filename)
  ```
  * Append rows to a worksheet
  ```python
  ws = wb['sheet1']
  ws.append(
      ["", "", "str('Unknown')", "float(4.5)", "int(500)"]
  )

  content1 = {
      'id': '001',
      'productName': 'pork',
      'productType': 'meat',
      'price': 2.5,
      'weight': 1000,
  }
  content2 = {
      'id': '002',
      'productName': 'beef',
      'productType': 'meat',
      'price': 4.5,
      'weight': 1000,
      'origin': 'Australia'
  }

  ws.append_by_header(content1)

  ws.append_by_header(content2)

  ```
  ||A|B|C|D|E|F|
  |:---:|:---:|:---:|:---:|:---:|:---:|:---|
  |1|||str('Unknown')|float(30)|int(0)|
  |2|id|productName|productType|price|weight|origin
  |3|001|pork|meat|2.5|1000|
  |4|002|beef|meat|4.5|1000|Australia
  * Read from / write to a worksheet by row
    Note: if there are duplicate header names, only the first would be used.
  ```python
  ws = wb['sheet1']
  assert ws.header is None
  ws.header_row = 2  # set the second row as worksheet header row
  assert ws.header is not None

  for row in ws.content_rows:  # starting from row just below header row
      print(row[1])  # row cell value can accessed by column number, if key is of type int
      print(row['productName'])  # row cell value can be accessed by header name, if key is of type of str
      print(row['price'])
      if row['productName'] == 'pork':
          row[1] = '003'  # change pork id to '003'
          row['price'] = 3.5  # change pork price to 3.5







  ```
  * Read from a worksheet by column
  ```python
  ws = wb['sheet1']
  ws.header_row = 2

  column_cells = ws['B']
  for c in column_cells:
      print(c.data)  # 'pork', 'beef'



  name_column = ws.get_content_column('productName')
  for c in name_column:
      print(c.data)  # 'pork', 'beef'



  name_column = ws.get_content_column(2)
  for c in name_column:
      print(c.data)  # 'pork', 'beef'
  ```
  * Read cell directly from Worksheet, Header, ContentRow
  ```python
  ws = wb['sheet1']
  ws.header_row = 2

  cell = ws.cell(2, 2)
  print(cell.data)  # 'productName'


  cell = ws.header.cell('productName')
  print(cell.data)  # 'productName'

  cell = ws.header.cell(1)
  print(cell.data)  # 'id'

  for row in ws.content_rows:
      cell = row.cell(1)  # '001', '002'
      print(cell.data)
      cell = row.cell('productName')
      print(cell.data)  # 'pork', 'beef'
  ```

  * Read adjacent cells of a certain cell
  ```python
  cell = ws.cell(2, 2)
  print(cell.top.data)  # "str('Unknown')"
  print(cell.left.data)  # 'id'
  print(cell.right.data)  # 'productType'
  print(cell.bottom.data)  # 'pork'

  for c in cell.vertical:
      print(c.data)  # 'productName', 'pork', 'beef'

  for c in cell.horizontal:
      print(c.data)  # 'productName', 'productType', 'price', 'weigth', 'origin'
  ```


pkgId: f0a0b7cabbfff4551634ab11fb4b14142358d7e831f08da46242171740309562
name: python-pyxs
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Pure Python bindings to XenStore.
url: https://github.com/selectel/pyxs
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d40e669c-4097-4e02-82a2-d7c84fd58bc1
location_href: 00004892-python-pyxs/python-pyxs-0.4.1-1.src.rpm
checksum_type: sha256
description:
  It's a pure Python XenStore client implementation, which covers all of
  the ``libxs`` features and adds some nice Pythonic sugar on top. Here's
  a shortlist:
  * ``pyxs`` supports both Python 2 and 3,
  * works over a Unix socket or XenBus,
  * has a clean and well-documented API,
  * is writen in easy to understand Python,
  * can be used with `gevent <http://www.gevent.org>`_ or
    `eventlet <http://eventlet.net>`_.


pkgId: eab3cca48233ecb63a56b155aefd2142aeed101135b1f4831b86cf1d8272aba3
name: python-pyyaml-include
arch: src
version: 1.3
epoch: 0
release: 1
summary: Extending PyYAML with a custom constructor for including YAML files within YAML files
url: https://github.com/tanbro/pyyaml-include
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1372730f-5c67-4f74-9a54-cd9583d23aa5
location_href: 00014047-python-pyyaml-include/python-pyyaml-include-1.3-1.src.rpm
checksum_type: sha256
description:
  [![GitHub tag](https://img.shields.io/github/tag/tanbro/pyyaml-include.svg)](https://github.com/tanbro/pyyaml-include)
  [![Python Package](https://github.com/tanbro/pyyaml-include/workflows/Python%20package/badge.svg)](https://github.com/tanbro/pyyaml-include/actions?query=workflow%3A%22Python+package%22)
  [![Documentation Status](https://readthedocs.org/projects/pyyaml-include/badge/?version=stable)](https://pyyaml-include.readthedocs.io/en/stable/?badge=stable)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=tanbro_pyyaml-include&metric=alert_status)](https://sonarcloud.io/dashboard?id=tanbro_pyyaml-include)
  [![PyPI](https://img.shields.io/pypi/v/pyyaml-include.svg)](https://pypi.org/project/pyyaml-include/)
  [![PyPI - License](https://img.shields.io/pypi/l/pyyaml-include.svg)](https://pypi.org/project/pyyaml-include/)
  [![PyPI - Format](https://img.shields.io/pypi/format/pyyaml-include.svg)](https://pypi.org/project/pyyaml-include/)
  [![PyPI - Status](https://img.shields.io/pypi/status/pyyaml-include.svg)](https://pypi.org/project/pyyaml-include/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyyaml-include.svg)](https://pypi.org/project/pyyaml-include/)
  [![PyPI - Implementation](https://img.shields.io/pypi/implementation/pyyaml-include.svg)](https://pypi.org/project/pyyaml-include/)

  An extending constructor of [PyYAML][]: include [YAML][] files into [YAML][] document.



  ```sh
  pip install pyyaml-include
  ```



  Consider we have such [YAML] files:

  ```text
  ├── 0.yml
  └── include.d
      ├── 1.yml
      └── 2.yml
  ```

  - `1.yml` 's content:

    ```yaml
    name: "1"
    ```

  - `2.yml` 's content:

    ```yaml
    name: "2"
    ```

  To include `1.yml`, `2.yml` in `0.yml`, we shall add `YamlIncludeConstructor` to [PyYAML]'s loader, then add an `!include` tag in `0.yaml`:

  ```python
  import yaml
  from yamlinclude import YamlIncludeConstructor

  YamlIncludeConstructor.add_to_loader_class(loader_class=yaml.FullLoader, base_dir='/your/conf/dir')

  with open('0.yml') as f:
      data = yaml.load(f, Loader=yaml.FullLoader)

  print(data)
  ```



  If `0.yml` was:

  ```yaml
  file1: !include include.d/1.yml
  file2: !include include.d/2.yml
  ```

  We'll get:

  ```yaml
  file1:
    name: "1"
  file2:
    name: "2"
  ```



  If `0.yml` was:

  ```yaml
  files:
    - !include include.d/1.yml
    - !include include.d/2.yml
  ```

  We'll get:

  ```yaml
  files:
    - name: "1"
    - name: "2"
  ```

  > ℹ **Note**:
  >
  > File name can be either absolute (like `/usr/conf/1.5/Make.yml`) or relative (like `../../cfg/img.yml`).



  File name can contain shell-style wildcards. Data loaded from the file(s) found by wildcards will be set in a sequence.

  That is to say, a list will be returned when including file name contains wildcards.
  Length of the returned list equals number of matched files:

  - when only 1 file matched, length of list will be 1
  - when there are no files matched, an empty list will be returned

  If `0.yml` was:

  ```yaml
  files: !include include.d/*.yml
  ```

  We'll get:

  ```yaml
  files:
    - name: "1"
    - name: "2"
  ```

  > ℹ **Note**:
  >
  > - For `Python>=3.5`, if `recursive` argument of `!include` [YAML] tag is `true`, the pattern `“**”` will match any files and zero or more directories and subdirectories.
  > - Using the `“**”` pattern in large directory trees may consume an inordinate amount of time because of recursive search.

  In order to enable `recursive` argument, we shall set it in `Mapping` or `Sequence` arguments mode:

  - Arguments in `Sequence` mode:

    ```yaml
    !include [tests/data/include.d/**/*.yml, true]
    ```

  - Arguments in `Mapping` mode:

    ```yaml
    !include {pathname: tests/data/include.d/**/*.yml, recursive: true}
    ```



  This extending constructor can now load data from non YAML files, supported file types are:

  - `json`
  - `toml` (only available when [toml](https://pypi.org/project/toml/) installed)
  - `ini`

  The constructor read non YAML files by different readers according to a pattern table defined in `src/yamlinclude/readers.py`.

  Default reader table can be replaced by a custom `reader_map` when call `add_to_loader_class`.

  [YAML]: http://yaml.org/
  [PyYaml]: https://pypi.org/project/PyYAML/



  * Liu Xue Yan (<liu_xue_yan@foxmail.com>)

    [![liu_xue_yan@foxmail.com](https://www.gravatar.com/avatar/049d2fae1fd2df6439e87d1383d0276b)](mailto:liu_xue_yan@foxmail.com)





  Date: 2022-04-24

  - New:
    - PyYAML 6.0 supported

  - Misc:
    - Better CI processes



  Date: 2019-02-03

  - New:
    - non YAML file including

  - Misc:
    - adjust docs
    - add pip and conda configure file of development environment

  - Fix:
    - add `PlainTextReader` into `__all__` list of `reders` module



  Date: 2019-03-18

  - Change:
    - Update PyYAML to 5.*
    - Rename: Argument `loader_class` of `YamlIncludeConstructor.add_to_loader_class()` (former: `loader_cls`)



  Date: 2019-01-07

  - Change:

    - rename: `TAG` ==> `DEFAULT_TAG_NAME`
    - add: `encoding` argument

  - Fix:

    - A wrong logging text format

  - Misc:

    - add: `.pylintrc`



  Date: 2018-12-04

  - New Feature:

    - Add `base_dir` argument

  - Misc:

    - Add some new unit-test
    - Add Python3.7 in CircleCI



  Date: 2018-07-11

  - Add:

    - `encoding` argument

  - Bug fix:

    - encoding error if non-ascii characters on non-utf8 os.



  Date: 2018-07-03

  - Add:

    - Old Python2.6 and new Python3.7 compatibilities

    - class method `add_to_loader_class`

      A class method to add the constructor itself into YAML loader class

    - Sphinx docs

  - Change:

    - Rename module file `include.py` to `constructor.py`

    - Rename class data member `DEFAULT_TAG` to `TAG`



  Date: 2018-06-08


pkgId: cdf5e103c9e25f8b670351b385b87a61e9515fa3f42bf734611026d13d0ff35e
name: python-pyyaml_env_tag
arch: src
version: 0.1
epoch: 0
release: 1
summary: A custom YAML tag for referencing environment variables in YAML files.
url: https://github.com/waylan/pyyaml-env-tag
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2894b261-39b0-4b19-9e89-3313c6544166
location_href: 00009994-python-pyyaml-env-tag/python-pyyaml_env_tag-0.1-1.src.rpm
checksum_type: sha256
description:
  A custom YAML tag for referencing environment variables in YAML files.



  Install `PyYAML` and the `pyyaml_env_tag` package with pip:

  ```bash
  pip install pyyaml pyyaml_env_tag
  ```



  To enable the tag, import and add the `construct_env_tag` constructor to your YAML
  loader of choice.

  ```python
  import yaml
  from yaml_env_tag import construct_env_tag

  yaml.Loader.add_constructor('!ENV', construct_env_tag)
  ```

  Then you may use the loader as per usual. For example:

  ```python
  yaml.load(data, Loader=yaml.Loader)
  ```



  Include the tag `!ENV` followed by the name of an environment variable in a YAML
  file and the value of the environment variable will be used in its place.

  ```yaml
  key: !ENV SOME_VARIABLE
  ```

  If `SOME_VARIABLE` is set to `A string!`, then the above YAML would result in the
  following Python object:

  ```python
  {'key': 'A string!'}
  ```

  The content of the variable is parsed using YAML's implicit scalar types, such as
  string, bool, integer, float, datestamp and null. More complex types are not
  recognized and simply passed through as a string. For example, if `SOME_VARIABLE`
  was set to the string `true`, then the above YAML would result in the following:

  ```python
  {'key': True}
  ```

  If the variable specified is not set, then a `null` value is assigned as a default.
  You may define your own default as the last item in a sequence.

  ```yaml
  key: !ENV [SOME_VARIABLE, default]
  ```

  In the above example, if `SOME_VARIABLE` is not defined, the string `default` would
  be used instead, as follows:

  ```python
  {'key': 'default'}
  ```

  You may list multiple variables as fallbacks. The first variable which is set is
  used. In any sequance with more than one item, the last item must always be a
  default value and will not be resolved as an environment variable.

  ```yaml
  key: !ENV [SOME_VARIABLE, FALLBACK, default]
  ```

  As with variable contents, the default is resolved to a Python object of the
  implied type (string, bool, integer, float, datestamp and null).

  When `SOME_VARIABLE` is not set, all four of the following items will resolve to
  the same value (`None`):

  ```yaml
  - !ENV SOME_VARIABLE
  - !ENV [SOME_VARIABLE]
  - !ENV [SOME_VARIABLE, ~]
  - !ENV [SOME_VARIABLE, null]
  ```



  pyyaml_env_tag was inspired by the Ruby package [yaml-env-tag].

  An alternate method of referencing environment variables in YAML files is
  implemented by [pyyaml-tags] and [python_yaml_environment_variables].
  Each of those libraries use a template string and replace the template tag with
  the content of the variable. While this allows a single value to reference
  multiple variables and to contain additional content, it restricts all values
  to strings only and does not provide a way to define defaults.

  [yaml-env-tag]: https://github.com/jirutka/yaml-env-tag
  [pyyaml-tags]: https://github.com/meiblorn/pyyaml-tags
  [python_yaml_environment_variables]: https://gist.github.com/mkaranasou/ba83e25c835a8f7629e34dd7ede01931



  pyyaml_env_tag is licensed under the [MIT License] as defined in `LICENSE`.

  [MIT License]: https://opensource.org/licenses/MIT





  The initial release.


pkgId: cff453c4d07f5e7e86fc0183193722eab7ef5d74bda741b47acb6a4b5115bf5c
name: python-pyyml
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Use python in yaml
url: https://github.com/q1394168335/pyyml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0d3a405f-94a4-498a-926a-f4896260d4ee
location_href: 00010153-python-pyyml/python-pyyml-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Use python in yaml

  在python中使用：
  ```python
  from pyyml import load

  with open('conf.yml') as f:
      raw_conf = f.read()
  config = load(raw_conf)
  print(config)
  ```
  在yaml中 `${...}` 中的内容将会被python执行：

  yaml内容
  ```yaml
  sum: ${1 + 1}
  ```
  实际解析内容
  ```python
  {'sum': 2}
  ```
  通过在文件开头第一行注释来导入所需的包：

  ```yaml

  ```
  通过 [包名]:[别名] 取别名导入包

  `'os.path:path' 等同于 python 中的 from os import path`

  例如yaml文件内容
  ```yaml

  os_name: ${os.name}
  base_dir: ${path.abspath(path.dirname(__file__))}
  ```


pkgId: 77f8488340dc82a15382f2e0a8029318d01686832bd98d337d9487e903dbae44
name: python-pyzabbix
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Zabbix API Python interface
url: http://github.com/lukecyca/pyzabbix
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5df849b2-0eff-4f6d-b800-9296a05c947d
location_href: 00004893-python-pyzabbix/python-pyzabbix-1.2.1-1.src.rpm
checksum_type: sha256
description:
  **PyZabbix** is a Python module for working with the [Zabbix API](https://www.zabbix.com/documentation/current/manual/api/reference).

  [![CI](https://github.com/lukecyca/pyzabbix/actions/workflows/ci.yml/badge.svg)](https://github.com/lukecyca/pyzabbix/actions/workflows/ci.yml)
  [![PyPI Package Version](https://img.shields.io/pypi/v/pyzabbix.svg)](https://pypi.org/project/pyzabbix/)
  [![PyPI Python Versions](https://img.shields.io/pypi/pyversions/pyzabbix.svg)](https://pypi.org/project/pyzabbix/)



  - Tested against Zabbix 4.0 LTS, 5.0 LTS, 6.0 LTS and 6.2.





  Install PyZabbix using pip:

  ```bash
  $ pip install pyzabbix
  ```

  You can now import and use pyzabbix like so:

  ```python
  from pyzabbix import ZabbixAPI

  zapi = ZabbixAPI("http://zabbixserver.example.com")
  zapi.login("zabbix user", "zabbix pass")


  print("Connected to Zabbix API Version %s" % zapi.api_version())

  for h in zapi.host.get(output="extend"):
      print(h['hostid'])
  ```

  Refer to the [Zabbix API Documentation](https://www.zabbix.com/documentation/current/manual/api/reference) and the [PyZabbix Examples](https://github.com/lukecyca/pyzabbix/tree/master/examples) for more information.



  PyZabbix uses the [requests](https://requests.readthedocs.io/en/master/) library for HTTP. You can customize the request parameters by configuring the [requests Session](https://requests.readthedocs.io/en/master/user/advanced/#session-objects) object used by PyZabbix.

  This is useful for:

  - Customizing headers
  - Enabling HTTP authentication
  - Enabling Keep-Alive
  - Disabling SSL certificate verification

  ```python
  from pyzabbix import ZabbixAPI

  zapi = ZabbixAPI("http://zabbixserver.example.com")


  zapi.session.auth = ("http user", "http password")


  zapi.session.verify = False


  zapi.timeout = 5.1


  zapi.login("http user", "http password")



  ```



  If you need to debug some issue with the Zabbix API, you can enable the output of logging, pyzabbix already uses the default python logging facility but by default, it logs to "Null", you can change this behavior on your program, here's an example:

  ```python
  import sys
  import logging
  from pyzabbix import ZabbixAPI

  stream = logging.StreamHandler(sys.stdout)
  stream.setLevel(logging.DEBUG)
  log = logging.getLogger('pyzabbix')
  log.addHandler(stream)
  log.setLevel(logging.DEBUG)


  zapi = ZabbixAPI("http://zabbixserver.example.com")
  zapi.login('admin','password')




  ```

  The expected output is as following:

  ```
  Sending: {
      "params": {
          "password": "password",
          "user": "admin"
      },
      "jsonrpc": "2.0",
      "method": "user.login",
      "id": 2
  }
  Response Code: 200
  Response Body: {
      "jsonrpc": "2.0",
      "result": ".................",
      "id": 2
  }
  >>>
  ```



  To develop this project, start by reading the `Makefile` to have a basic understanding of the possible tasks.

  Install the project and the dependencies in a virtual environment:

  ```sh
  make install
  source .venv/bin/activate
  ```



  To release a new version, first bump the version number in `setup.py` by hand and run the release target:

  ```sh
  make release
  ```

  Finally, push the release commit and tag to publish them to Pypi:

  ```sh
  git push --follow-tags
  ```



  LGPL 2.1 http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html

  Zabbix API Python Library.

  Original Ruby Library is Copyright (C) 2009 Andrew Nelson nelsonab(at)red-tux(dot)net

  Original Python Library is Copyright (C) 2009 Brett Lentz brett.lentz(at)gmail(dot)com

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

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA


pkgId: 19a9a27394598dcb0c29c0f2ae7dc8bf44954fccd261ad558d9d40ced6d2bc7a
name: python-pyzipcode
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: query zip codes and location data
url: https://github.com/vangheem/pyzipcode
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b0843f9-b694-47fc-a2ac-59bd76a1cdbc
location_href: 00012205-python-pyzipcode/python-pyzipcode-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This package will allow you to get zip code information. The data used in this
  package can be retrieved from
  https://web.archive.org/web/20101126192032/http://pablotron.org/files/zipcodes-csv-10-Aug-2004.zip
  `pyzipcode` uses a local sqlite database to run. You can replace it with your
  own other storage mechanism with a little effort.
  Here is some basic usage...
  ```pycon
  >>> from pyzipcode import ZipCodeDatabase
  >>> zcdb = ZipCodeDatabase()
  >>> zcdb[54115]
  ZipCode(zip='54115', city='De Pere', state='WI', longitude=-88.07896, latitude=44.42042, timezone=-6, dst=1)
  >>> zcdb[210]
  ZipCode(zip='00210', city='Portsmouth', state='NH', longitude=-71.013202, latitude=43.005895, timezone=-5, dst=1)
  ```
  Search zip codes...
  ```pycon
  >>> from pyzipcode import ZipCodeDatabase
  >>> zcdb = ZipCodeDatabase()
  >>> len(zcdb.find_zip(city="Oshkosh"))
  7
  >>> len(zcdb.find_zip(city="O%"))  # all cities starting with "O" using SQL wildcard
  60
  >>> len(zcdb.find_zip(city="Doesn't Exist"))  # returns None
  >>>
  ```
  Get a list of zipcodes around a radius of a zipcode (this actually searches a square area)
  ```pycon
  >>> from pyzipcode import ZipCodeDatabase
  >>> zcdb = ZipCodeDatabase()
  >>> [z.zip for z in zcdb.get_zipcodes_around_radius('54901', 10)]
  ['54901', '54902', '54903', '54904', '54906', '54927', '54952', '54956', '54957', '54979', '54985']
  ```


pkgId: 8e73271f7093401eee638e534df00b7586873eb36b0ab96298245006aaf27339
name: python-pyzipper
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: AES encryption for zipfile.
url: https://github.com/danifus/pyzipper
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50486b3d-09e5-4c11-8a95-32aa198425c9
location_href: 00010852-python-pyzipper/python-pyzipper-0.3.6-1.src.rpm
checksum_type: sha256
description:
  A replacement for Python's ``zipfile`` that can read and write AES encrypted
  zip files. Forked from Python 3.7's ``zipfile`` module, it features the same
  ``zipfile`` API from that time (most notably, lacking support for
  ``pathlib``-compatible wrappers that were introduced in Python 3.8).


pkgId: bd3549abda22e593dd3dee1af613388d93dd6341efc9e93463cb4371a92d8d1b
name: python-pyzolib
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Utilities for the Pyzo environment.
url: http://bitbucket.org/pyzo/pyzolib
rpm_license: (new) BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76a35fd5-2eec-4a29-b6d0-5bcb4d4978d2
location_href: 00004894-python-pyzolib/python-pyzolib-0.3.4-1.src.rpm
checksum_type: sha256
description:
  Package pyzolib

  The pyzolib package provides basic functionality for the Pyzo environment.
  It contains a collection of modules and small packages that should be
  imported as "from pyzolib import xxx"

  The packages currently are:
    * path - object oriented path processing (no more os.path.x)
    * paths - Get paths to useful directories in a cross platform manner.
    * qt - Proxy for importing QtCore et al. from PySide or PyQt4
    * ssdf - the Simple Structured Data Format (for config files and
      scientific databases)
    * insertdocs - a sphynx pre-processor to include docstrings in the text,
      allowing readthedocs.org to host the docs without requiring importing code.
    * pyximport - for easy on the fly compilation of Cython, using the Pyzo
      environment to establish the location of a gcc compiler.
    * gccutils - used by the above to manage the gcc compiler.
    * interprerers - list the Python interpreters available on this system.
    * dllutils - utilities to set the RPATH in dynamic libararies and
      remove depndencies on the MSVCR from the embedded manifest.
    * shebang - for making shebangs in pyzo distro absolute.


pkgId: ab30c809c281fa6c6877f01de4d8bd473b8bbfe89a23a1c19a04bf91a2a13d6b
name: python-pyzstd
arch: src
version: 0.15.6
epoch: 0
release: 1
url: https://github.com/animalize/pyzstd
rpm_license: The 3-Clause BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-840ae91b-44b7-4624-af62-f210c3005345
location_href: 00010467-python-pyzstd/python-pyzstd-0.15.6-1.src.rpm
checksum_type: sha256
summary:
  Python bindings to Zstandard (zstd) compression library, the API style is similar to Python's bz2/lzma/zlib modules.

description:
  Pyzstd module provides classes and functions for compressing and decompressing data, using Facebook's `Zstandard <http://www.zstd.net>`_ (or zstd as short name) algorithm.
  The API style is similar to Python's bz2/lzma/zlib modules.
  * Includes zstd v1.5.5 source code
  * Can also dynamically link to zstd library provided by system, see `this note <https://pyzstd.readthedocs.io/en/latest/#build-pyzstd>`_.
  * Has a CFFI implementation that can work with PyPy
  * Has a command line interface: ``python -m pyzstd --help``


pkgId: abf37f1246cb94aabfaf979932078d55e1068b123ba352d0f4e1c2bb4852dac2
name: python-pyzstd-debuginfo
arch: aarch64
version: 0.15.6
epoch: 0
release: 1
summary: Debug information for package python-pyzstd
url: https://github.com/animalize/pyzstd
rpm_license: The 3-Clause BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-840ae91b-44b7-4624-af62-f210c3005345
rpm_sourcerpm: python-pyzstd-0.15.6-1.src.rpm
location_href: 00010467-python-pyzstd/python-pyzstd-debuginfo-0.15.6-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyzstd.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 8f81adc3de6e6b02d3763142be83ae5cb5651cd54e8701258e66e9eb121126a0
name: python-pyzstd-debugsource
arch: aarch64
version: 0.15.6
epoch: 0
release: 1
summary: Debug sources for package python-pyzstd
url: https://github.com/animalize/pyzstd
rpm_license: The 3-Clause BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-840ae91b-44b7-4624-af62-f210c3005345
rpm_sourcerpm: python-pyzstd-0.15.6-1.src.rpm
location_href: 00010467-python-pyzstd/python-pyzstd-debugsource-0.15.6-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyzstd.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e56e9b61b7710fd83f6a873adb4888537ec76e7ced47cd75f08307be6f977cb1
name: python-qcelemental
arch: src
version: 0.25.1
epoch: 0
release: 1
summary: Essentials for Quantum Chemistry.
url: https://github.com/MolSSI/QCElemental
rpm_license: BSD-3C
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-07181aa9-66a3-406c-a81b-d0f98893c057
location_href: 00004896-python-qcelemental/python-qcelemental-0.25.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/MolSSI/QCElemental/workflows/CI/badge.svg?branch=master)](https://github.com/MolSSI/QCElemental/actions?query=workflow%3ACI)
  [![codecov](https://img.shields.io/codecov/c/github/MolSSI/QCElemental.svg?logo=Codecov&logoColor=white)](https://codecov.io/gh/MolSSI/QCElemental)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/MolSSI/QCElemental.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/MolSSI/QCElemental/context:python)
  [![Documentation Status](https://img.shields.io/github/workflow/status/MolSSI/QCElemental/CI/master?label=docs&logo=readthedocs&logoColor=white)](http://docs.qcarchive.molssi.org/projects/qcelemental/en/latest/)
  [![Chat on Slack](https://img.shields.io/badge/chat-on_slack-green.svg?longCache=true&style=flat&logo=slack)](https://join.slack.com/t/qcarchive/shared_invite/enQtNDIzNTQ2OTExODk0LTE3MWI0YzBjNzVhNzczNDM0ZTA5MmQ1ODcxYTc0YTA1ZDQ2MTk1NDhlMjhjMmQ0YWYwOGMzYzJkZTM2NDlmOGM)
  ![python](https://img.shields.io/badge/python-3.6+-blue.svg)

  QCElemental is a resource module for quantum chemistry containing physical
  constants and periodic table data from NIST and molecule handlers.

  Periodic Table and Physical Constants data are pulled from NIST srd144 and
  srd121, respectively ([details](raw_data/README.md)) in a renewable manner
  (class around NIST-published JSON file).

  This project also contains a generator, validator, and translator for [Molecule
  QCSchema](https://molssi-qc-schema.readthedocs.io/en/latest/auto_topology.html).

  It is intended to keep the QCElemental code compatible with Python 3.6+
  as long as dependencies allow. Packages are assured for Python 3.8+.




  A variety of periodic table quantities are available using virtually any alias:

  ```python
  >>> import qcelemental as qcel
  >>> qcel.periodictable.to_E('KRYPTON')
  'Kr'
  >>> qcel.periodictable.to_element(36)
  'Krypton'
  >>> qcel.periodictable.to_Z('kr84')
  36
  >>> qcel.periodictable.to_A('Kr')
  84
  >>> qcel.periodictable.to_A('D')
  2
  >>> qcel.periodictable.to_mass('kr', return_decimal=True)
  Decimal('83.9114977282')
  >>> qcel.periodictable.to_mass('kr84')
  83.9114977282
  >>> qcel.periodictable.to_mass('Kr86')
  85.9106106269
  ```



  Physical constants can be acquired directly from the [NIST CODATA](https://physics.nist.gov/cuu/Constants/Table/allascii.txt):

  ```python
  >>> import qcelemental as qcel
  >>> qcel.constants.Hartree_energy_in_eV
  27.21138602
  >>> qcel.constants.get('hartree ENERGY in ev')
  27.21138602
  >>> pc = qcel.constants.get('hartree ENERGY in ev', return_tuple=True)
  >>> pc.label
  'Hartree energy in eV'
  >>> pc.data
  Decimal('27.21138602')
  >>> pc.units
  'eV'
  >>> pc.comment
  'uncertainty=0.000 000 17'
  ```

  Alternatively, with the use of the [Pint unit conversion package](https://pint.readthedocs.io/en/latest/), arbitrary
  conversion factors can be obtained:

  ```python
  >>> qcel.constants.conversion_factor("bohr", "miles")
  3.2881547429884475e-14
  ```



  Covalent radii are accessible for most of the periodic table from [Alvarez, Dalton Transactions (2008) doi:10.1039/b801115j](https://doi.org/10.1039/b801115j) ([details](qcelemental/data/alvarez_2008_covalent_radii.py.py)).
  ```python
  >>> import qcelemental as qcel
  >>> qcel.covalentradii.get('I')
  2.626719314386381
  >>> qcel.covalentradii.get('I', units='angstrom')
  1.39
  >>> qcel.covalentradii.get(116)
  Traceback (most recent call last):
  ...
  qcelemental.exceptions.DataUnavailableError: ('covalent radius', 'Lv')
  >>> qcel.covalentradii.get(116, missing=4.0)
  4.0
  >>> qcel.covalentradii.get('iodine', return_tuple=True).dict()
  {'numeric': True, 'label': 'I', 'units': 'angstrom', 'data': Decimal('1.39'), 'comment': 'e.s.d.=3 n=451', 'doi': 'DOI: 10.1039/b801115j'}
  ```



  Van der Waals radii are accessible for tmost of the periodic table from [Mantina, J. Phys. Chem. A (2009) doi: 10.1021/jp8111556](https://pubs.acs.org/doi/10.1021/jp8111556) ([details](qcelemental/data/mantina_2009_vanderwaals_radii.py)).
  ```python
  >>> import qcelemental as qcel
  >>> qcel.vdwradii.get('I')
  3.7416577284064996
  >>> qcel.vdwradii.get('I', units='angstrom')
  1.98
  >>> qcel.vdwradii.get(116)
  Traceback (most recent call last):
  ...
  qcelemental.exceptions.DataUnavailableError: ('vanderwaals radius', 'Lv')
  >>> qcel.vdwradii.get('iodine', return_tuple=True).dict()
  {'numeric': True, 'label': 'I', 'units': 'angstrom', 'data': Decimal('1.98'), 'doi': 'DOI: 10.1021/jp8111556'}
  ```


pkgId: 41ebb293c0b0d5f6cb237dd71d5409410d96b63bcf68414585557db141c3bfd3
name: python-qiskit
arch: src
version: 0.42.1
epoch: 0
release: 1
summary: Software for developing quantum computing programs
url: https://qiskit.org/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b9d868b-045d-448e-a4c9-01455dfb2ff1
location_href: 00012445-python-qiskit/python-qiskit-0.42.1-1.src.rpm
checksum_type: sha256
description:
  ![Image](https://raw.githubusercontent.com/Qiskit/qiskit/master/images/qiskit_header.png)

  [![License](https://img.shields.io/github/license/Qiskit/qiskit.svg?)](https://opensource.org/licenses/Apache-2.0)
  ![Build Status](https://github.com/Qiskit/qiskit/actions/workflows/main.yml/badge.svg?branch=master)
  ![Build Status](https://github.com/Qiskit/qiskit/actions/workflows/docs.yml/badge.svg?branch=master)
  [![](https://img.shields.io/github/release/Qiskit/qiskit.svg)](https://github.com/Qiskit/qiskit/releases)
  [![Downloads](https://pepy.tech/badge/qiskit)](https://pypi.org/project/qiskit/)
  [![DOI](https://zenodo.org/badge/161550823.svg)](https://zenodo.org/badge/latestdoi/161550823)

  **Qiskit** is an open-source SDK for working with quantum computers at the level of circuits, algorithms, and application modules.

  Qiskit is made up of elements that work together to enable quantum computing. This is a simple meta-package to install the elements of Qiskit altogether.



  The best way of installing `qiskit` is by using `pip`:

  ```bash
  $ pip install qiskit
  ```

  See [install](https://qiskit.org/documentation/getting_started.html) Qiskit for detailed instructions, how to use virtual environments, and
  build from source standalone versions of the individual Qiskit elements and components.



  The Qiskit project used to be made up of many components. However, in the future the Qiskit metapackage will only install [**Qiskit Terra**](https://github.com/Qiskit/qiskit-terra):

  | Build   | Version | Contribute |
  | ---     | --- | --- |
  | [**Qiskit Terra**](https://github.com/Qiskit/qiskit-terra) | [![](https://img.shields.io/github/release/Qiskit/qiskit-terra.svg?)](https://github.com/Qiskit/qiskit-terra/releases)  | [![](https://img.shields.io/github/forks/Qiskit/qiskit-terra.svg?)](https://github.com/Qiskit/qiskit-terra) |

  <table>
    <tr>
      <td colspan="3" align="center">:warning: WARNING :warning:</br> <b>For the time being, two other packages are installed, but these components will be removed from the metapackage in a future release.</b></td>
    </tr>
  <tr>
  <th>Build</th>
  <th>Version</th>
  <th>Contribute</th>
  </tr>
  <tr>
  <td><a href="https://github.com/Qiskit/qiskit-aer"><strong>Qiskit Aer</strong></a></td>
  <td><a href="https://github.com/Qiskit/qiskit-aer/releases"><img src="https://camo.githubusercontent.com/7b4ebed2975693dc2d18233e49b7f9141838c1e86f22ac36f465fcd3886821b6/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f72656c656173652f5169736b69742f7169736b69742d6165722e7376673f" alt="" data-canonical-src="https://img.shields.io/github/release/Qiskit/qiskit-aer.svg?"></a></td>
  <td><a href="https://github.com/Qiskit/qiskit-aer"><img src="https://camo.githubusercontent.com/ced831707852701ae4c21b1455d6c2d2a03fa54dffe09fcf5208970112023a05/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f666f726b732f5169736b69742f7169736b69742d6165722e7376673f" alt="" data-canonical-src="https://img.shields.io/github/forks/Qiskit/qiskit-aer.svg?"></a></td>
  </tr>
  <tr>
  <td><a href="https://github.com/Qiskit/qiskit-ibmq-provider"><strong>Qiskit IBM Quantum Provider</strong></a></td>
  <td><a href="https://github.com/Qiskit/qiskit-ibmq-provider/releases"><img src="https://camo.githubusercontent.com/daa12aee2f03d2d310bd6ad1a5c5babe99b038fc08ad9f0309f5e1c7420c9ffe/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f72656c656173652f5169736b69742f7169736b69742d69626d712d70726f76696465722e7376673f" alt="" data-canonical-src="https://img.shields.io/github/release/Qiskit/qiskit-ibmq-provider.svg?"></a></td>
  <td><a href="https://github.com/Qiskit/qiskit-ibmq-provider"><img src="https://camo.githubusercontent.com/49f1938883f91358a594feeddecdd59b3188a353a9a20721a6fefcd64c32f6ce/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f666f726b732f5169736b69742f7169736b69742d69626d712d70726f76696465722e7376673f" alt="" data-canonical-src="https://img.shields.io/github/forks/Qiskit/qiskit-ibmq-provider.svg?"></a></td>
  </tr>
  </table>



  These components are part of the Qiskit ecosystem but are built on top of
  `qiskit` and are not installed by default with the meta-package. You can either
  install them manually, as an optional extra
  (ie `pip install "qiskit[finance,experiments]"`), or all together with
  `pip install "qiskit[all]"`.

  | Build | Version | Contribute |
  | ---   | --- | --- |
  | [**Qiskit Optimization**](https://github.com/Qiskit/qiskit-optimization) | [![](https://img.shields.io/github/release/Qiskit/qiskit-optimization.svg?)](https://github.com/Qiskit/qiskit-optimization/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-optimization.svg?)](https://github.com/Qiskit/qiskit-optimization) |
  | [**Qiskit Finance**](https://github.com/Qiskit/qiskit-finance) |  [![](https://img.shields.io/github/release/Qiskit/qiskit-finance.svg?)](https://github.com/Qiskit/qiskit-finance/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-finance.svg?)](https://github.com/Qiskit/qiskit-finance) |
  | [**Qiskit Machine Learning**](https://github.com/Qiskit/qiskit-machine-learning) | [![](https://img.shields.io/github/release/Qiskit/qiskit-machine-learning.svg?)](https://github.com/Qiskit/qiskit-machine-learning/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-machine-learning.svg?)](https://github.com/Qiskit/qiskit-machine-learning) |
  | [**Qiskit Nature**](https://github.com/Qiskit/qiskit-nature) |  [![](https://img.shields.io/github/release/Qiskit/qiskit-nature.svg?)](https://github.com/Qiskit/qiskit-nature/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-nature.svg?)](https://github.com/Qiskit/qiskit-nature) |
  | [**Qiskit Experiments**](https://github.com/Qiskit/qiskit-experiments) |  [![](https://img.shields.io/github/release/Qiskit/qiskit-experiments.svg?)](https://github.com/Qiskit/qiskit-experiments/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-experiments.svg?)](https://github.com/Qiskit/qiskit-experiments) |



  If you are interested in using quantum services (i.e. using a real quantum
  computer, not a simulator) you can look at the Qiskit Partners program for
  partner organizations that have provider packages available for their offerings:

  https://qiskit.org/documentation/partners/



  If you'd like to contribute to Qiskit, please take a look at our
  [contribution guidelines](https://qiskit.org/documentation/contributing_to_qiskit.html). This project adheres to Qiskit's [code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.

  We use [GitHub issues](https://github.com/Qiskit/qiskit/issues) for tracking requests and bugs. Please use our [Slack](https://qisk.it/join-slack) for discussion and simple questions. For questions that are more suited for a forum we use the Qiskit tag in the [Stack Exchange](https://quantumcomputing.stackexchange.com/questions/tagged/qiskit).



  Now you're set up and ready to check out our
  [Qiskit Tutorials](https://github.com/Qiskit/qiskit-tutorials) repository.



  Qiskit is the work of [many people](AUTHORS) who contribute to the project at
  different levels. If you use Qiskit, please cite as per the included
  [BibTeX file](Qiskit.bib).



  [Apache License 2.0](LICENSE.txt)


pkgId: 5b2d5d6aee4ce4afdfce2d4ddca517add87ac539dcc1be69e1fa81b3787ba421
name: python-qiskit-ibmq-provider
arch: src
version: 0.20.2
epoch: 0
release: 1
summary: Qiskit provider for accessing the quantum devices and simulators at IBMQ
url: https://github.com/Qiskit/qiskit-ibmq-provider
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8a61671-6453-4c92-be90-f4f088ba0069
location_href: 00012813-python-qiskit-ibmq-provider/python-qiskit-ibmq-provider-0.20.2-1.src.rpm
checksum_type: sha256
description:
  **_PLEASE NOTE:_** _As of version 0.20.0, released in January 2023, `qiskit-ibmq-provider` has been deprecated
  with its support ending and eventual archival being no sooner than 3 months from that date. The
  function provided by `qiskit-ibmq-provider` is not going away rather it has being split out to separate repositories.
  Please see the [Migration Guides](#migration-guides) section below for more detail. We encourage you


pkgId: becfddb8fa132426b2efaedb80ff4170b16c78965718c51050e57b939cdbcf87
name: python-qiskit-ignis
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Qiskit tools for quantum information science
url: https://github.com/Qiskit/qiskit-ignis
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d1c7b7e-10dc-44f6-89a2-2381b57123a2
location_href: 00013531-python-qiskit-ignis/python-qiskit-ignis-0.7.1-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/Qiskit/qiskit-ignis.svg?style=popout-square)](https://opensource.org/licenses/Apache-2.0)[![Build Status](https://img.shields.io/travis/com/Qiskit/qiskit-ignis/master.svg?style=popout-square)](https://travis-ci.com/Qiskit/qiskit-ignis)[![](https://img.shields.io/github/release/Qiskit/qiskit-ignis.svg?style=popout-square)](https://github.com/Qiskit/qiskit-ignis/releases)[![](https://img.shields.io/pypi/dm/qiskit-ignis.svg?style=popout-square)](https://pypi.org/project/qiskit-ignis/)

  **_NOTE_** _As of the version 0.7.0 Qiskit Ignis is deprecated and has been
  superseded by the
  [Qiskit Experiments](https://github.com/Qiskit/qiskit-experiments) project.
  Active development on the project has stopped and only compatibility fixes
  and other critical bugfixes will be accepted until the project is officially
  retired and archived._

  **Qiskit** is an open-source framework for working with noisy quantum computers at the level of pulses, circuits, and algorithms.

  Qiskit is made up of elements that each work together to enable quantum computing. This element is **Ignis**, which provides tools for quantum hardware verification, noise characterization, and error correction.



  As of version 0.7.0, Qiskit Ignis has been deprecated and some of its functionality
  was migrated into the `qiskit-experiments` package and into `qiskit-terra`.

  * Ignis characterization module

    * This module was partly migrated to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments) and split into two different modules:
    `qiskit_experiments.library.calibration`
    `qiskit_experiments.library.characterization`
    * `AmpCal` is now replaced by `FineAmplitude`.
    * `ZZFitter` was not migrated yet.

  * Ignis discriminator module

    * This module is in the process of migration to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments)

  * Ignis mitigation module

    * The readout mitigator will be soon added to [`qiskit-terra`](https://github.com/Qiskit/qiskit-terra).
    * Experiments for generating the readout mitigators will be added to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments)
    * For use of mitigators with `qiskit.algorithms` and the [`QuantumInstance` class](https://qiskit.org/documentation/stubs/qiskit.utils.QuantumInstance.html?highlight=quantuminstance#qiskit.utils.QuantumInstance)
      this has been integrated into `qiskit-terra` directly with the `QuantumInstance`.

  * Ignis verification module

    * Randomized benchmarking, Quantum Volume and State and Process Tomography were migrated to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments).
    * Migration of Gate-set tomography to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments) is in progress.
    * `topological_codes` will continue development under [NCCR-SPIN](https://github.com/NCCR-SPIN/topological_codes/blob/master/README.md), while the functionality is reintegrated into Qiskit. Some additional functionality can also be found in the offshoot project [qtcodes](https://github.com/yaleqc/qtcodes).
    * Currently the Accredition and Entanglement modules have not been migrated.
  The following table gives a more detailed breakdown that relates the function, as it existed in Ignis,
  to where it now lives after this move.

  | Old | New | Library |
  | :---: | :---: | :---: |
  | qiskit.ignis.characterization.calibrations | qiskit_experiments.library.calibration | qiskit-experiments |
  | qiskit.ignis.characterization.coherence | qiskit_experiments.library.characterization | qiskit-experiments |
  | qiskit.ignis.mitigation | qiskit_terra.mitigation | qiskit-terra |
  | qiskit.ignis.verification.quantum_volume | qiskit_experiments.library.quantum_volume | qiskit-experiments |
  | qiskit.ignis.verification.randomized_benchmarking | qiskit_experiments.library.randomized_benchmarking | qiskit-experiments |
  | qiskit.ignis.verification.tomography | qiskit_experiments.library.tomography | qiskit-experiments |



  We encourage installing Qiskit via the pip tool (a python package manager). The following command installs the core Qiskit components, including Ignis.

  ```bash
  pip install qiskit
  ```

  Pip will handle all dependencies automatically for us and you will always install the latest (and well-tested) version.

  To install from source, follow the instructions in the [contribution guidelines](./CONTRIBUTING.md).



  Some functionality has extra optional requirements. If you're going to use any
  visualization functions for fitters you'll need to install matplotlib. You
  can do this with `pip install matplotlib` or when you install ignis with
  `pip install qiskit-ignis[visualization]`. If you're going to use a cvx fitter
  for running tomogography you'll need to install cvxpy. You can do this with
  `pip install cvxpy` or when you install ignis with
  `pip install qiskit-ignis[cvx]`. When performing expectation value measurement
  error mitigation using the CTMP method performance can be improved using
  just-in-time compiling if Numbda is installed. You can do this with
  `pip install numba` or when you install ignis with
  `pip install qiskit-ignis[jit]`. For using the discriminator classes in
  `qiskit.ignis.measurement` scikit-learn needs to be installed. You can do this with
  `pip install scikit-learn` or when you install ignis with
  `pip install qiskit-ignis[iq]`. If you want to install all extra requirements
  when you install ignis you can run `pip install qiskit-ignis[visualization,cvx,jit,iq]`.


  Now that you have Qiskit Ignis installed, you can start creating experiments, to reveal information about the device quality. Here is a basic example:

  ```
  $ python
  ```

  ```python

  import qiskit
  from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
  from qiskit.providers.aer import noise # import AER noise model


  from qiskit.ignis.mitigation.measurement import (complete_meas_cal,
                                                   CompleteMeasFitter,
                                                   MeasurementFilter)


  noise_model = noise.NoiseModel()
  for qi in range(5):
      read_err = noise.errors.readout_error.ReadoutError([[0.75, 0.25],[0.1, 0.9]])
      noise_model.add_readout_error(read_err, [qi])



  qr = QuantumRegister(5)
  meas_cals, state_labels = complete_meas_cal(qubit_list=[2,3,4], qr=qr)


  backend = qiskit.Aer.get_backend('qasm_simulator')
  job = qiskit.execute(meas_cals, backend=backend, shots=1000, noise_model=noise_model)
  cal_results = job.result()


  meas_fitter = CompleteMeasFitter(cal_results, state_labels)


  cr = ClassicalRegister(3)
  ghz = QuantumCircuit(qr, cr)
  ghz.h(qr[2])
  ghz.cx(qr[2], qr[3])
  ghz.cx(qr[3], qr[4])
  ghz.measure(qr[2],cr[0])
  ghz.measure(qr[3],cr[1])
  ghz.measure(qr[4],cr[2])


  job = qiskit.execute(ghz, backend=backend, shots=1000, noise_model=noise_model)
  results = job.result()


  raw_counts = results.get_counts()
  print("Results without mitigation:", raw_counts)


  meas_filter = meas_fitter.filter


  mitigated_counts = meas_filter.apply(raw_counts)
  print("Results with mitigation:", {l:int(mitigated_counts[l]) for l in mitigated_counts})
  ```

  ```
  Results without mitigation: {'000': 181, '001': 83, '010': 59, '011': 65, '100': 101, '101': 48, '110': 72, '111': 391}

  Results with mitigation: {'000': 421, '001': 2, '011': 1, '100': 53, '110': 13, '111': 510}
  ```



  If you'd like to contribute to Qiskit Ignis, please take a look at our
  [contribution guidelines](./CONTRIBUTING.md). This project adheres to Qiskit's [code of conduct](./CODE_OF_CONDUCT.md). By participating, you are expect to uphold to this code.

  We use [GitHub issues](https://github.com/Qiskit/qiskit-ignis/issues) for tracking requests and bugs. Please use our [slack](https://qiskit.slack.com) for discussion and simple questions. To join our Slack community use the [link](https://join.slack.com/t/qiskit/shared_invite/enQtNDc2NjUzMjE4Mzc0LTMwZmE0YTM4ZThiNGJmODkzN2Y2NTNlMDIwYWNjYzA2ZmM1YTRlZGQ3OGM0NjcwMjZkZGE0MTA4MGQ1ZTVmYzk). For questions that are more suited for a forum we use the Qiskit tag in the [Stack Exchange](https://quantumcomputing.stackexchange.com/questions/tagged/qiskit).



  Now you're set up and ready to check out some of the other examples from our
  [Qiskit Tutorials](https://github.com/Qiskit/qiskit-iqx-tutorials/tree/master/qiskit/advanced/ignis) repository.



  Qiskit Ignis is the work of [many people](https://github.com/Qiskit/qiskit-ignis/graphs/contributors) who contribute
  to the project at different levels. If you use Qiskit, please cite as per the included [BibTeX file](https://github.com/Qiskit/qiskit/blob/master/Qiskit.bib).



  [Apache License 2.0](LICENSE.txt)


pkgId: 745de1e8352fe8f3e30d155f8f8c63447abb9e32ae9e2cc9e42e900346464c50
name: python-qmp
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: QEMU Monitor Protocol client
url: https://gitlab.com/abogdanenko/qmp
rpm_license: GNU General Public License v2 (GPLv2)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aab289fa-8751-4462-8a79-0b32a00899a3
location_href: 00011804-python-qmp/python-qmp-0.0.1-1.src.rpm
checksum_type: sha256
description:
  QEMU Monitor Protocol (QMP) is a JSON-based protocol that allows applications to
  communicate with a QEMU instance.
  This project packages an exact copy of `python/qemu/qmp.py` from the QEMU source
  tree.
  For a brief introduction to QMP, see
  <https://github.com/qemu/qemu/blob/master/docs/interop/qmp-intro.txt>.
  For detailed information about the protocol, see
  <https://github.com/qemu/qemu/blob/master/docs/interop/qmp-spec.txt>.
  For the full list of commands supported by QMP see *qemu-qmp-ref* man page,
  which is available at
  <https://manpages.debian.org/unstable/qemu-system-common/qemu-qmp-ref.7.en.html>.


pkgId: b21326b50c301794f10586576604eafbd962039454f7455d44df0ec432c3c38b
name: python-qtconsole
arch: src
version: 5.4.0
epoch: 0
release: 1
summary: Jupyter Qt console
url: http://jupyter.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f7a9d30-a8ce-465f-b7c3-e7861298aa53
location_href: 00004914-python-qtconsole/python-qtconsole-5.4.0-1.src.rpm
checksum_type: sha256
description:
  ![Windows tests](https://github.com/jupyter/qtconsole/workflows/Windows%20tests/badge.svg)
  ![Macos tests](https://github.com/jupyter/qtconsole/workflows/Macos%20tests/badge.svg)
  ![Linux tests](https://github.com/jupyter/qtconsole/workflows/Linux%20tests/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/jupyter/qtconsole/badge.svg?branch=master)](https://coveralls.io/github/jupyter/qtconsole?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/qtconsole/badge/?version=stable)](https://qtconsole.readthedocs.io/en/stable/)
  [![Google Group](https://img.shields.io/badge/-Google%20Group-lightgrey.svg)](https://groups.google.com/forum/#!forum/jupyter)

  A rich Qt-based console for working with Jupyter kernels,
  supporting rich media output, session export, and more.

  The Qtconsole is a very lightweight application that largely feels like a terminal, but
  provides a number of enhancements only possible in a GUI, such as inline
  figures, proper multiline editing with syntax highlighting, graphical calltips,
  and more.

  ![qtconsole](https://raw.githubusercontent.com/jupyter/qtconsole/master/docs/source/_images/qtconsole.png)


  The Qtconsole requires Python bindings for Qt, such as [PyQt5](http://www.riverbankcomputing.com/software/pyqt/intro),
  [PyQt4](https://www.riverbankcomputing.com/software/pyqt/download),
  or [PySide](http://pyside.github.io/docs/pyside).

  Although [pip](https://pypi.python.org/pypi/pip) and
  [conda](http://conda.pydata.org/docs) may be used to install the Qtconsole, conda
  is simpler to use since it automatically installs PyQt5. Alternatively,
  the Qtconsole installation with pip needs additional steps since pip doesn't install
  the Qt requirement.


  To install:

      conda install qtconsole

  **Note:** If the Qtconsole is installed using conda, it will **automatically**
  install the Qt requirement as well.


  To install:

      pip install qtconsole

  **Note:** Make sure that Qt is installed. Unfortunately, Qt is not
  installed when using pip. The next section gives instructions on doing it.


  You can install PyQt5 with pip using the following command:

      pip install pyqt5

  or with a system package manager on Linux. For Windows, PyQt binary packages may be
  used.

  **Note:** Additional information about using a system package manager may be
  found in the [qtconsole documentation](https://qtconsole.readthedocs.io).

  More installation instructions for PyQt can be found in the [PyQt5 documentation](http://pyqt.sourceforge.net/Docs/PyQt5/installation.html) and [PyQt4 documentation](http://pyqt.sourceforge.net/Docs/PyQt4/installation.html)

  Source packages for Windows/Linux/MacOS can be found here: [PyQt5](https://www.riverbankcomputing.com/software/pyqt/download5) and [PyQt4](https://riverbankcomputing.com/software/pyqt/download).



  To run the Qtconsole:

      jupyter qtconsole


  - [Project Jupyter website](https://jupyter.org)
  - Documentation for the Qtconsole
    * [latest version](https://qtconsole.readthedocs.io/en/latest/) [[PDF](https://media.readthedocs.org/pdf/qtconsole/latest/qtconsole.pdf)]
    * [stable version](https://qtconsole.readthedocs.io/en/stable/) [[PDF](https://media.readthedocs.org/pdf/qtconsole/stable/qtconsole.pdf)]
  - [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) [[PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)]
  - [Issues](https://github.com/jupyter/qtconsole/issues)
  - [Technical support - Jupyter Google Group](https://groups.google.com/forum/#!forum/jupyter)


pkgId: a442254f613c510abaaa9572431e66bb9a5d65dcc266c853cb3c155950eddfb4
name: python-qtsass
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Compile SCSS files to valid Qt stylesheets.
url: https://github.com/spyder-ide/qtsass
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-39e51460-3bc1-426d-8b26-41f7b6f7117b
location_href: 00004915-python-qtsass/python-qtsass-0.3.2-1.src.rpm
checksum_type: sha256
description:
  [![License - MIT](https://img.shields.io/github/license/spyder-ide/qtsass.svg)](./LICENSE.txt)
  [![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
  [![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public)<br>
  [![Github build status](https://github.com/spyder-ide/qtsass/workflows/Tests/badge.svg)](https://github.com/spyder-ide/qtsass/actions)
  [![Codecov coverage](https://img.shields.io/codecov/c/github/spyder-ide/qtsass/master.svg)](https://codecov.io/gh/spyder-ide/qtsass)
  [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/spyder-ide/qtsass/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/spyder-ide/qtsass/?branch=master)

  *Copyright © 2015 Yann Lanthony*

  *Copyright © 2017–2018 Spyder Project Contributors*




  [SASS](http://sass-lang.com/) brings countless amazing features to CSS.
  Besides being used in web development, CSS is also the way to stylize Qt-based desktop applications.
  However, Qt's CSS has a few variations that prevent the direct use of SASS compiler.

  The purpose of this tool is to fill the gap between SASS and Qt-CSS by handling those variations.




  The goal of QtSASS is to be able to generate a Qt-CSS stylesheet based on a 100% valid SASS file.
  This is how it deals with Qt's specifics and how you should modify your CSS stylesheet to use QtSASS.


  Qt allows to define the style of a widget according to its states, like this:

  ```css
  QLineEdit:enabled {
  ...
  }
  ```

  However, a "not" state is problematic because it introduces an exclamation mark in the selector's name, which is not valid SASS/CSS:

  ```css
  QLineEdit:!editable {
  ...
  }
  ```

  QtSASS allows "!" in selectors' names; the SASS file is preprocessed and any occurence of `:!` is replaced by `:_qnot_` (for "Qt not").
  However, using this feature prevents from having a 100% valid SASS file, so this support of `!` might change in the future.
  This can be replaced by the direct use of the `_qnot_` keyword in your SASS file:

  ```css
  QLineEdit:_qnot_editable { /* will generate QLineEdit:!editable { */
  ...
  }
  ```


  The qlineargradient function also has a non-valid CSS syntax.

  ```css
  qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0.1 blue, stop: 0.8 green)
  ```

  To support qlineargradient QtSASS provides a preprocessor and a SASS implementation of the qlineargradient function. The above QSS syntax will be replaced with the following:

  ```css
  qlineargradient(0, 0, 0, 1, (0.1 blue, 0.8 green))
  ```

  You may also use this syntax directly in your QtSASS.

  ```
  qlineargradient(0, 0, 0, 1, (0.1 blue, 0.8 green))

  $stops = 0.1 blue, 0.8 green
  qlineargradient(0, 0, 0, 0, $stops)
  ```


  Qt's rgba:

  ```css
  rgba(255, 128, 128, 50%)
  ```

  is replaced by CSS rgba:

  ```css
  rgba(255, 128, 128, 0.5)
  ```




  To compile your SASS stylesheet to a Qt compliant CSS file:

  ```bash

  qtsass style.scss -o style.css
  ```

  To use the watch mode and get your stylesheet auto recompiled on each file save:

  ```bash

  qtsass style.scss -o style.css -w
  ```

  To compile a directory containing SASS stylesheets to Qt compliant CSS files:

  ```bash
  qtsass ./static/scss -o ./static/css
  ```

  You can also use watch mode to watch the entire directory for changes.

  ```bash
  qtsass ./static/scss -o ./static/css -w
  ```

  Set the Environment Variable QTSASS_DEBUG to 1 or pass the --debug flag to enable logging.

  ```bash
  qtsass ./static/scss -o ./static/css --debug
  ```





  Conform and Compile QtSASS source code to CSS.

  This function conforms QtSASS to valid SCSS before passing it to
  sass.compile. Any keyword arguments you provide will be combined with
  qtsass's default keyword arguments and passed to sass.compile.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile("QWidget {background: rgb(0, 0, 0);}")
  QWidget {background:black;}
  ```

  Arguments:
  - string: QtSASS source code to conform and compile.
  - kwargs: Keyword arguments to pass to sass.compile

  Returns:
  - Qt compliant CSS string



  Compile and save QtSASS file as Qt compliant CSS.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile_filename('dummy.scss', 'dummy.css')
  ```

  Arguments:
  - input_file: Path to QtSass file.
  - dest_file: Path to destination Qt compliant CSS file.
  - kwargs: Keyword arguments to pass to sass.compile



  Compile and save QtSASS file as Qt compliant CSS.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile_filename('dummy.scss', 'dummy.css')
  ```

  Arguments:
  - input_file: Path to QtSass file.
  - output_file: Path to write Qt compliant CSS.
  - kwargs: Keyword arguments to pass to sass.compile



  Compiles QtSASS files in a directory including subdirectories.

  ```bash
  >>> import qtsass
  >>> qtsass.compile_dirname("./scss", "./css")
  ```

  Arguments:
  - input_dir: Path to directory containing QtSass files.
  - output_dir: Directory to write compiled Qt compliant CSS files to.
  - kwargs: Keyword arguments to pass to sass.compile


  Enable logging for qtsass.

  Sets the qtsass logger's level to:
      1. the provided logging level
      2. logging.DEBUG if the QTSASS_DEBUG envvar is a True value
      3. logging.WARNING

  ```bash
  >>> import logging
  >>> import qtsass
  >>> handler = logging.StreamHandler()
  >>> formatter = logging.Formatter('-8s: s> s')
  >>> handler.setFormatter(formatter)
  >>> qtsass.enable_logging(level=logging.DEBUG, handler=handler)
  ```

  Arguments:
  - level: Optional logging level
  - handler: Optional handler to add


  Watches a source file or directory, compiling QtSass files when modified.

  The compiler function defaults to compile_filename when source is a file
  and compile_dirname when source is a directory.

  Arguments:
  - source: Path to source QtSass file or directory.
  - destination: Path to output css file or directory.
  - compiler: Compile function (optional)
  - Watcher: Defaults to qtsass.watchers.Watcher (optional)

  Returns:
  - qtsass.watchers.Watcher instance



  Everyone is welcome to contribute!




  Spyder and its subprojects are funded thanks to the generous support of

  [![Quansight](https://static.wixstatic.com/media/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png/v1/crop/x_0,y_9,w_915,h_329/fill/w_380,h_128,al_c,usm_0.66_1.00_0.01/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png)](https://www.quansight.com/)[![Numfocus](https://i2.wp.com/numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png?fit=320%2C148&ssl=1)](https://numfocus.org/)


  and the donations we have received from our users around the world through [Open Collective](https://opencollective.com/spyder/):

  [![Sponsors](https://opencollective.com/spyder/sponsors.svg)](https://opencollective.com/spyder#support)

  Please consider becoming a sponsor!


pkgId: 840ae4b60c3c590ada67cdb7d0971a341c4adf52cd694ecf5b97f3f15542ece7
name: python-qtsass
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Compile SCSS files to valid Qt stylesheets.
url: https://github.com/spyder-ide/qtsass
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-91bda14e-e306-4b6a-a604-ae56f89ed0d4
location_href: 00008245-python-qtsass/python-qtsass-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![License - MIT](https://img.shields.io/github/license/spyder-ide/qtsass.svg)](./LICENSE.txt)
  [![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
  [![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public)<br>
  [![Github build status](https://github.com/spyder-ide/qtsass/workflows/Tests/badge.svg)](https://github.com/spyder-ide/qtsass/actions)
  [![Codecov coverage](https://img.shields.io/codecov/c/github/spyder-ide/qtsass/master.svg)](https://codecov.io/gh/spyder-ide/qtsass)
  [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/spyder-ide/qtsass/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/spyder-ide/qtsass/?branch=master)

  *Copyright © 2015 Yann Lanthony*

  *Copyright © 2017–2018 Spyder Project Contributors*




  [SASS](http://sass-lang.com/) brings countless amazing features to CSS.
  Besides being used in web development, CSS is also the way to stylize Qt-based desktop applications.
  However, Qt's CSS has a few variations that prevent the direct use of SASS compiler.

  The purpose of this tool is to fill the gap between SASS and Qt-CSS by handling those variations.




  The goal of QtSASS is to be able to generate a Qt-CSS stylesheet based on a 100% valid SASS file.
  This is how it deals with Qt's specifics and how you should modify your CSS stylesheet to use QtSASS.


  Qt allows to define the style of a widget according to its states, like this:

  ```css
  QLineEdit:enabled {
  ...
  }
  ```

  However, a "not" state is problematic because it introduces an exclamation mark in the selector's name, which is not valid SASS/CSS:

  ```css
  QLineEdit:!editable {
  ...
  }
  ```

  QtSASS allows "!" in selectors' names; the SASS file is preprocessed and any occurence of `:!` is replaced by `:_qnot_` (for "Qt not").
  However, using this feature prevents from having a 100% valid SASS file, so this support of `!` might change in the future.
  This can be replaced by the direct use of the `_qnot_` keyword in your SASS file:

  ```css
  QLineEdit:_qnot_editable { /* will generate QLineEdit:!editable { */
  ...
  }
  ```


  The qlineargradient function also has a non-valid CSS syntax.

  ```css
  qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0.1 blue, stop: 0.8 green)
  ```

  To support qlineargradient QtSASS provides a preprocessor and a SASS implementation of the qlineargradient function. The above QSS syntax will be replaced with the following:

  ```css
  qlineargradient(0, 0, 0, 1, (0.1 blue, 0.8 green))
  ```

  You may also use this syntax directly in your QtSASS.

  ```
  qlineargradient(0, 0, 0, 1, (0.1 blue, 0.8 green))

  $stops = 0.1 blue, 0.8 green
  qlineargradient(0, 0, 0, 0, $stops)
  ```


  Qt's rgba:

  ```css
  rgba(255, 128, 128, 50%)
  ```

  is replaced by CSS rgba:

  ```css
  rgba(255, 128, 128, 0.5)
  ```




  To compile your SASS stylesheet to a Qt compliant CSS file:

  ```bash

  qtsass style.scss -o style.css
  ```

  To use the watch mode and get your stylesheet auto recompiled on each file save:

  ```bash

  qtsass style.scss -o style.css -w
  ```

  To compile a directory containing SASS stylesheets to Qt compliant CSS files:

  ```bash
  qtsass ./static/scss -o ./static/css
  ```

  You can also use watch mode to watch the entire directory for changes.

  ```bash
  qtsass ./static/scss -o ./static/css -w
  ```

  Set the Environment Variable QTSASS_DEBUG to 1 or pass the --debug flag to enable logging.

  ```bash
  qtsass ./static/scss -o ./static/css --debug
  ```





  Conform and Compile QtSASS source code to CSS.

  This function conforms QtSASS to valid SCSS before passing it to
  sass.compile. Any keyword arguments you provide will be combined with
  qtsass's default keyword arguments and passed to sass.compile.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile("QWidget {background: rgb(0, 0, 0);}")
  QWidget {background:black;}
  ```

  Arguments:
  - string: QtSASS source code to conform and compile.
  - kwargs: Keyword arguments to pass to sass.compile

  Returns:
  - Qt compliant CSS string



  Compile and return a QtSASS file as Qt compliant CSS. Optionally save to a file.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile_filename("dummy.scss", "dummy.css")
  >>> css = qtsass.compile_filename("dummy.scss")
  ```

  Arguments:
  - input_file: Path to QtSass file.
  - output_file: Path to write Qt compliant CSS.
  - kwargs: Keyword arguments to pass to sass.compile

  Returns:
  - Qt compliant CSS string



  Compiles QtSASS files in a directory including subdirectories.

  ```bash
  >>> import qtsass
  >>> qtsass.compile_dirname("./scss", "./css")
  ```

  Arguments:
  - input_dir: Path to directory containing QtSass files.
  - output_dir: Directory to write compiled Qt compliant CSS files to.
  - kwargs: Keyword arguments to pass to sass.compile


  Enable logging for qtsass.

  Sets the qtsass logger's level to:
      1. the provided logging level
      2. logging.DEBUG if the QTSASS_DEBUG envvar is a True value
      3. logging.WARNING

  ```bash
  >>> import logging
  >>> import qtsass
  >>> handler = logging.StreamHandler()
  >>> formatter = logging.Formatter('-8s: s> s')
  >>> handler.setFormatter(formatter)
  >>> qtsass.enable_logging(level=logging.DEBUG, handler=handler)
  ```

  Arguments:
  - level: Optional logging level
  - handler: Optional handler to add


  Watches a source file or directory, compiling QtSass files when modified.

  The compiler function defaults to compile_filename when source is a file
  and compile_dirname when source is a directory.

  Arguments:
  - source: Path to source QtSass file or directory.
  - destination: Path to output css file or directory.
  - compiler: Compile function (optional)
  - Watcher: Defaults to qtsass.watchers.Watcher (optional)

  Returns:
  - qtsass.watchers.Watcher instance



  Everyone is welcome to contribute!




  Spyder and its subprojects are funded thanks to the generous support of

  [![Quansight](https://static.wixstatic.com/media/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png/v1/crop/x_0,y_9,w_915,h_329/fill/w_380,h_128,al_c,usm_0.66_1.00_0.01/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png)](https://www.quansight.com/)[![Numfocus](https://i2.wp.com/numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png?fit=320%2C148&ssl=1)](https://numfocus.org/)


  and the donations we have received from our users around the world through [Open Collective](https://opencollective.com/spyder/):

  [![Sponsors](https://opencollective.com/spyder/sponsors.svg)](https://opencollective.com/spyder#support)

  Please consider becoming a sponsor!


pkgId: e6838189d0d4dcde6a7637010d948fb9b119e9e3fc1f7645821334f083681eee
name: python-quantconnect-stubs
arch: src
version: 15366
epoch: 0
release: 1
summary: Type stubs for QuantConnect's Lean
url: https://github.com/QuantConnect/quantconnect-stubs-generator
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-60680e97-9b05-4cf5-b604-dd453d65a8ab
location_href: 00012074-python-quantconnect-stubs/python-quantconnect-stubs-15366-1.src.rpm
checksum_type: sha256
description:
  This package contains type stubs for QuantConnect's [Lean](https://github.com/QuantConnect/Lean) algorithmic trading engine and for parts of the .NET library that are used by Lean.

  These stubs can be used by editors to provide type-aware features like autocomplete and auto-imports in QuantConnect strategies written in Python.

  After installing the stubs, you can copy the following line to the top of every Python file to have the same imports as the ones that are added by default in the cloud:
  ```py
  from AlgorithmImports import *
  ```

  This line imports [all common QuantConnect members](https://github.com/QuantConnect/Lean/blob/master/Common/AlgorithmImports.py) and provides autocomplete for them.


pkgId: d2ed8ddfc1c7539de8caa4ea33f0fb3dd0e942c98c4d92d0881ff51e7f8c5fa8
name: python-quantities
arch: src
version: 0.14.1
epoch: 0
release: 1
summary: Support for physical quantities with units, based on numpy
url: https://pypi.org/project/quantities/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1dd06250-7807-4c08-b450-d4617d823c08
location_href: 00004916-python-quantities/python-quantities-0.14.1-1.src.rpm
checksum_type: sha256
rpm_license:
  .. _license:  *********************************************** License ***********************************************   Quantities only uses BSD compatible code.  See the Open Source Initiative `licenses page <http://www.opensource.org/licenses>`_ for details on individual licenses.  License Agreement for Quantities ================================  Copyright (c) 2012, Darren Dale <dsdale24@gmail.com> All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.   License Agreement for Scimath =============================  This software is OSI Certified Open Source Software. OSI Certified is a certification mark of the Open Source Initiative.  Copyright (c) 2006, Enthought, Inc. 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 Enthought, Inc. 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 OWNER 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: 20a9a68ccfe698379c31b50ef0ac5d25603d2c0ed8090042910dc1cd0ad9c8df
name: python-quart
arch: src
version: 0.18.4
epoch: 0
release: 1
summary: A Python ASGI web microframework with the same API as Flask
url: https://github.com/pallets/quart/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aebd8db3-e527-42bc-8b73-e14cd5f823f0
location_href: 00009158-python-quart/python-quart-0.18.4-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |docs| |pypi| |python| |license| |chat|
  Quart is an async Python web microframework. Using Quart you can,
  * render and serve HTML templates,
  * write (RESTful) JSON APIs,
  * serve WebSockets,
  * stream request and response data,
  * do pretty much anything over the HTTP or WebSocket protocols.


pkgId: 172084d493bee0bd905ec5c86b4757ea960660b25aa45d8f172cd3f612259f1c
name: python-query-string
arch: src
version: 2020.12.3
epoch: 0
release: 1
summary: get url query string dict
url: https://github.com/andrewp-as-is/query-string.py
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2acbf1e4-8a92-42ef-888f-0ed395b11eff
location_href: 00013279-python-query-string/python-query-string-2020.12.3-1.src.rpm
checksum_type: sha256
description:
  <!--
  https://readme42.com
  -->


  [![](https://img.shields.io/pypi/v/query-string.svg?maxAge=3600)](https://pypi.org/project/query-string/)
  [![](https://img.shields.io/badge/License-Unlicense-blue.svg?longCache=True)](https://unlicense.org/)


  ```bash
  $ [sudo] pip install query-string
  ```


  +   Python 2/3 compatible


  ```python
  >>> import query_string

  >>> query_string.parse('https://site.org/index.php?k=v&k2=v2&k3=v3#anchor')
  {'k': 'v','k2': 'v2', 'k3': 'v3'}

  >>> query_string.parse('k=v&k2=v2&k3=v3')
  {'k': 'v','k2': 'v2', 'k3': 'v3'}
  ```


  +   [Query string - Wikipedia](https://en.wikipedia.org/wiki/Query_string)

  <p align="center">
      <a href="https://readme42.com/">readme42.com</a>
  </p>


pkgId: d451a9b08462e727e48c4d8cbc8799f8230a42cc1492b76671baeb45d2ffff62
name: python-questionary
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: Python library to build pretty command line user prompts ⭐️
url: https://github.com/tmbo/questionary
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fa389a4-7b3a-4173-9b31-9d56d46d39d0
location_href: 00009997-python-questionary/python-questionary-1.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/questionary.svg)](https://pypi.org/project/questionary/)
  [![License](https://img.shields.io/pypi/l/questionary.svg)](#)
  [![Continuous Integration](https://github.com/tmbo/questionary/workflows/Continuous%20Integration/badge.svg)](#)
  [![Coverage](https://coveralls.io/repos/github/tmbo/questionary/badge.svg?branch=master)](https://coveralls.io/github/tmbo/questionary?branch=master)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/questionary.svg)](https://pypi.python.org/pypi/questionary)
  [![Documentation](https://readthedocs.org/projects/questionary/badge/?version=latest)](https://questionary.readthedocs.io/en/latest/?badge=latest)

  ✨ Questionary is a Python library for effortlessly building pretty command line interfaces ✨

  * [Features](#features)
  * [Installation](#installation)
  * [Usage](#usage)
  * [Documentation](#documentation)
  * [Support](#support)


  ![Example](https://raw.githubusercontent.com/tmbo/questionary/master/docs/images/example.gif)

  ```python3
  import questionary

  questionary.text("What's your first name").ask()
  questionary.password("What's your secret?").ask()
  questionary.confirm("Are you amazed?").ask()

  questionary.select(
      "What do you want to do?",
      choices=["Order a pizza", "Make a reservation", "Ask for opening hours"],
  ).ask()

  questionary.rawselect(
      "What do you want to do?",
      choices=["Order a pizza", "Make a reservation", "Ask for opening hours"],
  ).ask()

  questionary.checkbox(
      "Select toppings", choices=["foo", "bar", "bazz"]
  ).ask()

  questionary.path("Path to the projects version file").ask()
  ```

  Used and supported by

  [<img src="https://raw.githubusercontent.com/tmbo/questionary/master/docs/images/rasa-logo.svg" width="200">](https://github.com/RasaHQ/rasa)



  Questionary supports the following input prompts:

   * [Text](https://questionary.readthedocs.io/en/stable/pages/types.html#text)
   * [Password](https://questionary.readthedocs.io/en/stable/pages/types.html#password)
   * [File Path](https://questionary.readthedocs.io/en/stable/pages/types.html#file-path)
   * [Confirmation](https://questionary.readthedocs.io/en/stable/pages/types.html#confirmation)
   * [Select](https://questionary.readthedocs.io/en/stable/pages/types.html#select)
   * [Raw select](https://questionary.readthedocs.io/en/stable/pages/types.html#raw-select)
   * [Checkbox](https://questionary.readthedocs.io/en/stable/pages/types.html#checkbox)
   * [Autocomplete](https://questionary.readthedocs.io/en/stable/pages/types.html#autocomplete)

  There is also a helper to [print formatted text](https://questionary.readthedocs.io/en/stable/pages/types.html#printing-formatted-text)
  for when you want to spice up your printed messages a bit.



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install Questionary:

  ```bash
  $ pip install questionary
  ✨🎂✨
  ```



  ```python
  import questionary

  questionary.select(
      "What do you want to do?",
      choices=[
          'Order a pizza',
          'Make a reservation',
          'Ask for opening hours'
      ]).ask()  # returns value of selection
  ```

  That's all it takes to create a prompt! Have a [look at the documentation](https://questionary.readthedocs.io/)
  for some more examples.



  Documentation for Questionary is available [here](https://questionary.readthedocs.io/).



  Please [open an issue](https://github.com/tmbo/questionary/issues/new)
  with enough information for us to reproduce your problem.
  A [minimal, reproducible example](https://stackoverflow.com/help/minimal-reproducible-example)
  would be very helpful.



  Contributions are very much welcomed and appreciated. Head over to the documentation on [how to contribute](https://questionary.readthedocs.io/en/stable/pages/contributors.html#steps-for-submitting-code).



  Questionary is written and maintained by Tom Bocklisch and Kian Cross.

  It is based on the great work by [Oyetoke Toby](https://github.com/CITGuru/PyInquirer)
  and [Mark Fink](https://github.com/finklabs/whaaaaat).


  Licensed under the [MIT License](https://github.com/tmbo/questionary/blob/master/LICENSE). Copyright 2021 Tom Bocklisch.


pkgId: 16b166da66fec1492a697de4ed5a994c53896a1bc1647af4d771ecccb429e7d4
name: python-queueman
arch: src
version: 0.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/ludeeus/queueman
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-01c56f73-11bd-4b2a-a853-ce1fcb32b826
location_href: 00010209-python-queueman/python-queueman-0.5-1.src.rpm
checksum_type: sha256
description:
  [![codecov][codecov_img]][codecov_url]
  [![Test action][github_action_test]][github_actions]

  WIP

  ```bash
  python3 -m pip install queueman
  ```

  <!-- LINKS -->
  [codecov_url]: https://codecov.io/gh/ludeeus/queueman
  [codecov_img]: https://codecov.io/gh/ludeeus/queueman/branch/master/graph/badge.svg
  [github_actions]: https://github.com/ludeeus/queueman/actions
  [github_action_test]: https://github.com/ludeeus/queueman/workflows/Test/badge.svg
  <!-- LINKS -->


pkgId: 7aef0eab8fb52e7dd8bae67aa72bf3f0715c013e216f35b5d3320cc885455615
name: python-quilt3
arch: src
version: 5.2.1
epoch: 0
release: 1
summary: Quilt: where data comes together
url: https://github.com/quiltdata/quilt
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d6deca31-801b-43ab-b520-ea23ad7a723e
location_href: 00011625-python-quilt3/python-quilt3-5.2.1-1.src.rpm
checksum_type: sha256
description:
  Quilt manages data like code (with packages, repositories, browsing and
  revision history) so that teams can experiment faster in machine learning,
  biotech, and other data-driven domains.

  The `quilt3` PyPI package allows you to build, push, and install data packages.
  Visit the `documentation quickstart <https://docs.quiltdata.com/quickstart>`_
  to learn more.


pkgId: 519cce1af58ae4d6c411b46264a593839fe7585333dbec67e6f4b41247218d83
name: python-quinn
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Pyspark helper methods to maximize developer efficiency
url: https://github.com/MrPowers/quinn/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-db3244a9-9b44-49bc-95ad-101f932118f1
location_href: 00010059-python-quinn/python-quinn-0.10.0-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/MrPowers/quinn/workflows/CI/badge.svg?branch=master)

  Pyspark helper methods to maximize developer productivity.

  Quinn validates DataFrames, extends core classes, defines DataFrame transformations, and provides SQL functions.

  ![quinn](https://github.com/MrPowers/quinn/blob/master/quinn.png)



  Quinn is [uploaded to PyPi](https://pypi.org/project/quinn/) and can be installed with this command:

  ```
  pip install quinn
  ```



  ```
  from quinn.extensions import *
  ```



  **isFalsy()**

  ```python
  source_df.withColumn("is_stuff_falsy", F.col("has_stuff").isFalsy())
  ```

  Returns `True` if `has_stuff` is `None` or `False`.

  **isTruthy()**

  ```python
  source_df.withColumn("is_stuff_truthy", F.col("has_stuff").isTruthy())
  ```

  Returns `True` unless `has_stuff` is `None` or `False`.

  **isNullOrBlank()**

  ```python
  source_df.withColumn("is_blah_null_or_blank", F.col("blah").isNullOrBlank())
  ```

  Returns `True` if `blah` is `null` or blank (the empty string or a string that only contains whitespace).

  **isNotIn()**

  ```python
  source_df.withColumn("is_not_bobs_hobby", F.col("fun_thing").isNotIn(bobs_hobbies))
  ```

  Returns `True` if `fun_thing` is not included in the `bobs_hobbies` list.

  **nullBetween()**

  ```python
  source_df.withColumn("is_between", F.col("age").nullBetween(F.col("lower_age"), F.col("upper_age")))
  ```

  Returns `True` if `age` is between `lower_age` and `upper_age`.  If `lower_age` is populated and `upper_age` is `null`, it will return `True` if `age` is greater than or equal to `lower_age`.  If `lower_age` is `null` and `upper_age` is populate, it will return `True` if `age` is lower than or equal to `upper_age`.



  **create_df()**

  ```python
  spark.create_df(
      [("jose", "a"), ("li", "b"), ("sam", "c")],
      [("name", StringType(), True), ("blah", StringType(), True)]
  )
  ```

  Creates DataFrame with a syntax that's less verbose than the built-in `createDataFrame` method.



  **transform()**

  ```python
  source_df\
      .transform(lambda df: with_greeting(df))\
      .transform(lambda df: with_something(df, "crazy"))
  ```

  Allows for multiple DataFrame transformations to be run and executed.



  ```python
  import quinn
  ```



  **validate_presence_of_columns()**

  ```python
  quinn.validate_presence_of_columns(source_df, ["name", "age", "fun"])
  ```

  Raises an exception unless `source_df` contains the `name`, `age`, and `fun` column.

  **validate_schema()**

  ```python
  quinn.validate_schema(source_df, required_schema)
  ```

  Raises an exception unless `source_df` contains all the `StructFields` defined in the `required_schema`.

  **validate_absence_of_columns()**

  ```python
  quinn.validate_absence_of_columns(source_df, ["age", "cool"])
  ```

  Raises an exception if `source_df` contains `age` or `cool` columns.



  **single_space()**

  ```python
  actual_df = source_df.withColumn(
      "words_single_spaced",
      quinn.single_space(col("words"))
  )
  ```


  Replaces all multispaces with single spaces (e.g. changes `"this has   some"` to `"this has some"`.

  **remove_all_whitespace()**

  ```python
  actual_df = source_df.withColumn(
      "words_without_whitespace",
      quinn.remove_all_whitespace(col("words"))
  )
  ```

  Removes all whitespace in a string (e.g. changes `"this has some"` to `"thishassome"`.

  **anti_trim()**

  ```python
  actual_df = source_df.withColumn(
      "words_anti_trimmed",
      quinn.anti_trim(col("words"))
  )
  ```

  Removes all inner whitespace, but doesn't delete leading or trailing whitespace (e.g. changes `" this has some "` to `" thishassome "`.

  **remove_non_word_characters()**

  ```python
  actual_df = source_df.withColumn(
      "words_without_nonword_chars",
      quinn.remove_non_word_characters(col("words"))
  )
  ```

  Removes all non-word characters from a string (e.g. changes `"si%$#@!#$!@#mpsons"` to `"simpsons"`.

  **exists()**

  ```python
  source_df.withColumn(
      "any_num_greater_than_5",
      quinn.exists(lambda n: n > 5)(col("nums"))
  )
  ```

  `nums` contains lists of numbers and `exists()` returns `True` if any of the numbers in the list are greater than 5.  It's similar to the Python `any` function.

  **forall()**

  ```python
  source_df.withColumn(
      "all_nums_greater_than_3",
      quinn.forall(lambda n: n > 3)(col("nums"))
  )
  ```

  `nums` contains lists of numbers and `forall()` returns `True` if all of the numbers in the list are greater than 3.  It's similar to the Python `all` function.

  **multi_equals()**

  ```python
  source_df.withColumn(
      "are_s1_and_s2_cat",
      quinn.multi_equals("cat")(col("s1"), col("s2"))
  )
  ```

  `multi_equals` returns true if `s1` and `s2` are both equal to `"cat"`.



  **snake_case_col_names()**

  ```python
  quinn.snake_case_col_names(source_df)
  ```

  Converts all the column names in a DataFrame to snake_case.  It's annoying to write SQL queries when columns aren't snake cased.

  **sort_columns()**

  ```python
  quinn.sort_columns(source_df, "asc")
  ```

  Sorts the DataFrame columns in alphabetical order.  Wide DataFrames are easier to navigate when they're sorted alphabetically.



  **column_to_list()**

  ```python
  quinn.column_to_list(source_df, "name")
  ```

  Converts a column in a DataFrame to a list of values.

  **two_columns_to_dictionary()**

  ```python
  quinn.two_columns_to_dictionary(source_df, "name", "age")
  ```

  Converts two columns of a DataFrame into a dictionary.  In this example, `name` is the key and `age` is the value.

  **to_list_of_dictionaries()**

  ```python
  quinn.to_list_of_dictionaries(source_df)
  ```

  Converts an entire DataFrame into a list of dictionaries.



  We are actively looking for feature requests, pull requests, and bug fixes.

  Any developer that demonstrates excellence will be invited to be a maintainer of the project.


pkgId: 49dbac8926c8b3b74b5f1ded7aaf29d10af7e811248611958bda1dde38b89e48
name: python-qutepart
arch: src
version: 3.3.3
epoch: 0
release: 1
summary: Code editor component for PyQt5
url: https://github.com/andreikop/qutepart
rpm_license: GNU Lesser General Public License v2 or later (LGPLv2+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e88bafe-80f3-41c2-820f-7a646f0a379c
location_href: 00004918-python-qutepart/python-qutepart-3.3.3-1.src.rpm
checksum_type: sha256
description:
  **NOTE** wheels released on PyPi doesn't contain C extension which speedups long file hihglighting.
  Build Qutepart from sources if speed is critical for your project. You can help releasing binary parser by implementing [this issue](https://github.com/andreikop/qutepart/issues/85)

  Component has been created for [Enki editor](http://enki-editor.org)

  [API documentation](https://qutepart.readthedocs.org/en/latest/)


  * Syntax highlighting for 196 languages
  * Smart indentation for many languages
  * Line numbers
  * Bookmarks
  * Advanced edit operations
  * Matching braces highlighting
  * Autocompletion based on document content
  * Marking too long lines with red line
  * Rectangular selection and copy-paste
  * Vim mode


  [Kate](http://kate-editor.org/) and Katepart (an editor component) is really cool software. The Kate authors and community have created, probably, the biggest set of highlighters and indenters for programming languages.

  * Qutepart uses Kate syntax highlighters (XML files)
  * Qutepart contains a port from Javascript to Python of Kate indenters (12% of the code base in version 1.0.0)
  * Qutepart doesn't contain Katepart code.

  Nothing is wrong with Katepart. Qutepart has been created to enable reusing highlighters and indenters in projects where a KDE dependency is not acceptable.


  Andrei Kopats
  [andrei.kopats@gmail.com](mailto:andrei.kopats@gmail.com)


  [Github page](https://github.com/andreikop/qutepart)


  LGPL v2


pkgId: c25a632e84c2ebda2287ee9e557fb165ea5928483d300e72c62ef30a3becd01b
name: python-rabbitpy
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A pure python, thread-safe, minimalistic and pythonic RabbitMQ client library
url: https://rabbitpy.readthedocs.io
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b396e4d5-cb94-45de-95e8-d64632208e33
location_href: 00010723-python-rabbitpy/python-rabbitpy-2.0.1-1.src.rpm
checksum_type: sha256
description:
  A pure python, thread-safe, minimalistic and Pythonic BSD Licensed
  AMQP/RabbitMQ library that supports Python 2.7+ and Python 3.4+.
  rabbitpy aims to provide a simple and easy to use API for interfacing with
  RabbitMQ, minimizing the programming overhead often found in other libraries.
  |Version| |Downloads| |Status| |Coverage| |License|


pkgId: cfaed9ab19456bf58efe6525bd09b779e03d6f39c9510c83f80d8e0802e5816b
name: python-radish-bdd
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Behaviour-Driven-Development tool for Python
url: http://radish-bdd.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f474d741-13dc-42a0-bd63-f5896d282743
location_href: 00014197-python-radish-bdd/python-radish-bdd-0.15.0-1.src.rpm
checksum_type: sha256
description:
  <img align="right" src="https://raw.githubusercontent.com/radish-bdd/radish/master/artwork/radish-bdd-logo-trans-bg.png">


  > Awesome python BDD tool http://radish-bdd.io

  ***

  [![PyPI License](https://img.shields.io/pypi/l/radish-bdd.svg)](https://github.com/radish-bdd/radish/blob/master/LICENSE)
  [![Gitter](https://badges.gitter.im/radish-bdd/radish.svg)](https://gitter.im/radish-bdd/radish?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
  <br>
  [![Actions Status](https://github.com/radish-bdd/radish/workflows/CI/badge.svg)](https://github.com/radish-bdd/radish/actions?branch=stable)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  <br>
  [![PyPI version](https://badge.fury.io/py/radish-bdd.svg)](https://badge.fury.io/py/radish-bdd)
  [![PyPI](https://img.shields.io/pypi/pyversions/radish-bdd.svg)](https://pypi.python.org/pypi/radish-bdd)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/radish-bdd)](https://pypi.python.org/pypi/radish-bdd)
  [![PyPI](https://img.shields.io/pypi/wheel/radish-bdd.svg)](https://pypi.python.org/pypi/radish-bdd)

  ***



  radish is a Behavior Driven Development tool completely written in python.
  It supports all *gherkin* language features.
  In addition to that, radish implements a few *unconventional* BDD features such as **Preconditions**, **Scenario Loops**, **Constants** and **Expressions**.



  radish is supported on Windows, Mac and Linux



  radish is available as `pip` package:

  ```bash
  pip install radish-bdd
  ```
  **Note**: Make sure you have enough privileges to install radish on your system.



  radish is very easy to use. Take the 5 minutes and follow the *Getting started* instruction on the radish website: http://radish-bdd.io/#gettingstarted



  The whole documentation of radish is available on [Read The Docs](http://radish.readthedocs.org).



  Yes, we are looking for some contributors and people who spread out a word about radish.
  Help us to improve these piece of software. You don't know what to do?
  Just have a look at the Issues or create a new one.
  Please have a look at the [Contributing Guidelines](https://github.com/radish-bdd/radish/blob/master/CONTRIBUTING.md), too.



  ```
  vim CHANGELOG.md docs/conf.py radish/__init__.py
  git commit -am "release: x.x.x" && git tag x.x.x
  rm -rf dist
  python3 setup.py sdist bdist_wheel
  python3 -m twine upload dist/*
  ```



  A special thanks goes to [Hassan Ashraf](mailto:info@cyberavanza.com) from the company [Cyber Avanza](http://www.cyberavanza.com) for creating an awesome logo for free! I really appreciate their work and time!

  ***

  *<p align="center">This project is published under [MIT](LICENSE).<br>A [Timo Furrer](https://tuxtimo.me) project.<br>- :tada: -</p>*


pkgId: 0e8a7661a1e739d5cefc18b3e916814345b490faa365144fb56d276b686d72d3
name: python-rake-nltk
arch: src
version: 1.0.6
epoch: 0
release: 1
url: https://csurfer.github.io/rake-nltk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6413682a-b263-4411-b4a5-49c3f36cd4f2
location_href: 00010311-python-rake-nltk/python-rake-nltk-1.0.6-1.src.rpm
checksum_type: sha256
summary:
  RAKE short for Rapid Automatic Keyword Extraction algorithm, is a domain independent keyword extraction algorithm which tries to determine key phrases in a body of text by analyzing the frequency of word appearance and its co-occurance with other words in the text.

description:
  |pypiv| |pyv| |Licence| |Build Status| |Coverage Status|
  RAKE short for Rapid Automatic Keyword Extraction algorithm, is a domain
  independent keyword extraction algorithm which tries to determine key
  phrases in a body of text by analyzing the frequency of word appearance
  and its co-occurance with other words in the text.
  |Demo|


pkgId: dfa71fb5c2ce36d0bb6469ff893bbe811a51876c5abaffb9e63e5c153a43f1e0
name: python-random-password-generator
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Simple and custom random password generator for python
url: https://github.com/suryasr007/random-password-generator
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-768c0921-123b-476b-9298-4ee53e5a8b9a
location_href: 00010512-python-random-password-generator/python-random-password-generator-2.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/badge/PYPI-V%202.2.0-blue.svg)](https://pypi.org/project/random-password-generator)
  [![Build Status](https://travis-ci.org/suryasr007/random-password-generator.svg?branch=master)](https://travis-ci.org/suryasr007/random-password-generator)


   * No dependencies.
   * Generate a simple password of default length 6-16.
   * Generate a password with custom properties.
   * Generate a password from given characters.
   * Generate Non Duplicate Password.
   * Available at https://random-pg.herokuapp.com/ (API and WEB versions are available @ https://github.com/suryasr007/rpg-web repo)




   * Install the package.
   * Import the package.
   * Create an instance
   * Modify the default properties. (Optional)
   * Generate the password (Default length of password 6-16 unless specified via properties).

  ``` bash
    pip install random-password-generator
  ```

  ``` python
    from password_generator import PasswordGenerator

    pwo = PasswordGenerator()
    pwo.generate()
  ```




  | property   |                          Description                 | Default |
  | ---------- |------------------------------------------------------| ------- |
  | minlen     |   Minimum length of the password                     | 6 |
  | maxlen     |   Maximum length of the password                     | 16 |
  | minuchars  |   Minimum upper case characters required in password | 1 |
  | minlchars  |   Minimum lower case characters required in password | 1 |
  | minnumbers |   Minimum numbers required in password               | 1 |
  | minschars  |   Minimum special characters in the password         | 1 |



  Application is now minimal(No dependencies). The API and WEB version are moved to https://github.com/suryasr007/rpg-web


  Application uses [secrets](https://docs.python.org/3/library/secrets.html) module instead of `random` module on Python environments above 3.6.


  From version 1.1.0, Characters can be excluded from the required password by setting the properties on PasswordGenerator object

  example:
  ``` python
    pwo = PasswordGenerator()

    pwo.excludeuchars = "ABCDEFTUVWXY" # (Optional)
    pwo.excludelchars = "abcdefghijkl" # (Optional)
    pwo.excludenumbers = "012345" # (Optional)
    pwo.excludeschars = "!$%^" # (Optional)
  ```



  ``` python
    pwo = PasswordGenerator()

    
    pwo.minlen = 30 # (Optional)
    pwo.maxlen = 30 # (Optional)
    pwo.minuchars = 2 # (Optional)
    pwo.minlchars = 3 # (Optional)
    pwo.minnumbers = 1 # (Optional)
    pwo.minschars = 1 # (Optional)

    pwo.generate()
  ```


  ``` python
    pwo = PasswordGenerator()

    
    
    pwo.shuffle_password('sdafasdf#@&^#&234u8', 20)
  ```


  ``` python
    pwo = PasswordGenerator()

    
    pwo.non_duplicate_password(20)
  ```


  Contributions are welcomed via PR.


   * [MIT](LICENSE)


pkgId: 8b6471eb197874ddf1b6f62fa8057fec550e7c1056bcb4a2da31a4c2ca4e678c
name: python-rangehttpserver
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: SimpleHTTPServer with support for Range requests
url: https://github.com/danvk/RangeHTTPServer/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f69bec2-5de7-4dfe-ad64-3002ddec099e
location_href: 00004923-python-rangehttpserver/python-rangehttpserver-1.3.3-1.src.rpm
checksum_type: sha256
description:
  SimpleHTTPServer with support for Range requests

  Quickstart:

      $ pip install rangehttpserver
      $ python -m RangeHTTPServer
      Serving HTTP on 0.0.0.0 port 8000 ...

  See the GitHub repo for more information:
  https://github.com/danvk/RangeHTTPServer


pkgId: 0337f938f433684242ba3bac16be2a6a6bfc84aa4b94ac5f8dd34a569d8628f3
name: python-rarfile
arch: src
version: 4.0
epoch: 0
release: 1
summary: RAR archive reader for Python
url: https://github.com/markokr/rarfile
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c82f9a87-cb2f-474b-ae33-f9b2015f5c68
location_href: 00004925-python-rarfile/python-rarfile-4.0-1.src.rpm
checksum_type: sha256
description:
  This is Python module for RAR_ archive reading.
  The interface follows the style of zipfile_.
  Licensed under ISC_ license.
  Features:
  * Supports both RAR3 and RAR5 format archives.
  * Supports multi volume archives.
  * Supports Unicode filenames.
  * Supports password-protected archives.
  * Supports archive and file comments.
  * Archive parsing and non-compressed files are handled in pure Python code.
  * Compressed files are extracted by executing external tool:
    unrar_ (preferred), unar_ or bsdtar_.
  * Works with Python 3.6+.
  Links:
  - `Documentation`_
  - `Downloads`_
  - `Git`_ repo


pkgId: e590c916cc31be81eb3b5a897d8e03f85d1310a05bfca9f72625304f6d1638f3
name: python-ratelim
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Makes it easy to respect rate limits.
url: http://github.com/themiurgo/ratelim
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d67968b0-5de0-447f-8c29-2824c9a44216
location_href: 00010143-python-ratelim/python-ratelim-0.1.6-1.src.rpm
checksum_type: sha256
description:
  Ratelim is a simple Python library that limits the number of times a function can be called during a time interval. It is particularly useful when using online APIs, which commonly enforce rate limits.


pkgId: 1a01108635988183d01198a20536935deca08a00e003156dc546ed39c008922e
name: python-ratelimit
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: API rate limit decorator
url: https://github.com/tomasbasham/ratelimit
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4394cee4-d757-4cf8-973a-f4e96965ded3
location_href: 00009661-python-ratelimit/python-ratelimit-2.2.1-1.src.rpm
checksum_type: sha256
description:
  APIs are a very common way to interact with web services. As the need to
  consume data grows, so does the number of API calls necessary to remain up to
  date with data sources. However many API providers constrain developers from
  making too many API calls. This is know as rate limiting and in a worst case
  scenario your application can be banned from making further API calls if it
  abuses these limits.
  This packages introduces a function decorator preventing a function from being
  called more often than that allowed by the API provider. This should prevent
  API providers from banning your applications by conforming to their rate
  limits.


pkgId: 435bf67cd69f8b12c24f50946c4fea3b4fca7d96115bf729b82e919be83ce372
name: python-ratelimiter
arch: src
version: 1.2.0.post0
epoch: 0
release: 1
summary: Simple python rate limiting object
url: https://github.com/RazerM/ratelimiter
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1e9838d-e173-45f7-8a18-869a3f0b9bd8
location_href: 00004927-python-ratelimiter/python-ratelimiter-1.2.0.post0-1.src.rpm
checksum_type: sha256
description:
  |PyPI Version| |Build Status| |Python Version| |License|
  Simple Python module providing rate limiting.


pkgId: fb7f384c258653fbbd9903ed2ffd9b0df53716dd950b740db1dc80c0b5242304
name: python-ratelimitingfilter
arch: src
version: 1.5
epoch: 0
release: 1
summary: A rate limiting filter for the Python logging system
url: https://github.com/wkeeling/ratelimitingfilter
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2c66ab69-ae93-46bc-92d1-c5d8a057d13f
location_href: 00004928-python-ratelimitingfilter/python-ratelimitingfilter-1.5-1.src.rpm
checksum_type: sha256
description:
  The ``RateLimitingFilter`` is a filter for the Python logging system
  that allows you to restrict the rate at which messages can pass through
  your logging handlers.
  The filter can be useful if you're using a handler such as Python's
  ``logging.handlers.SMTPHandler`` to send error notification emails.
  Error notification emails provide a useful means of keeping an eye on
  the health of a running system, but these emails have the potential to
  overload a mailbox if they start arriving in quick succession due to
  some kind of critical failure.
  The ``RateLimitingFilter`` can help prevent mailbox overload by
  throttling messages based on a configurable rate, whilst allowing for
  periodic bursts of messages which can be a useful indicator that
  something somewhere has broken.


