# packages

pkgId: 7fb569e1ba9de0afcfc24bdd9fbff043ce3d7a8ac2baee1bb4cad8a7d069f39c
name: python-pysimdjson-debuginfo
arch: x86_64
version: 5.0.2
epoch: 0
release: 1
summary: Debug information for package python-pysimdjson
url: https://github.com/TkTech/pysimdjson
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f9aeeb01-1b15-4759-9608-c4f7d4f63b79
rpm_sourcerpm: python-pysimdjson-5.0.2-1.src.rpm
location_href: 00011853-python-pysimdjson/python-pysimdjson-debuginfo-5.0.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pysimdjson.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 69d967fbeb14d1428abfa58959fd3839df1df0dd71036eca661449f7d1ae0cd2
name: python-pysimdjson-debugsource
arch: x86_64
version: 5.0.2
epoch: 0
release: 1
summary: Debug sources for package python-pysimdjson
url: https://github.com/TkTech/pysimdjson
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f9aeeb01-1b15-4759-9608-c4f7d4f63b79
rpm_sourcerpm: python-pysimdjson-5.0.2-1.src.rpm
location_href: 00011853-python-pysimdjson/python-pysimdjson-debugsource-5.0.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pysimdjson.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 80ed38bb796fdbe6fc9f7968bc5553a11adaeb38da539c74bbd3348f4e54a8be
name: python-pysmb
arch: src
version: 1.2.9.1
epoch: 0
release: 1
url: https://miketeo.net/projects/pysmb
rpm_license: zlib/libpng
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e839501f-bce0-4e6a-9d99-499f2e337f62
location_href: 00004806-python-pysmb/python-pysmb-1.2.9.1-1.src.rpm
checksum_type: sha256
summary:
  pysmb is an experimental SMB/CIFS library written in Python to support file sharing between Windows and Linux machines

description:
  pysmb is an experimental SMB/CIFS library written in Python. It implements the client-side SMB/CIFS protocol which allows your Python application to access and transfer files to/from SMB/CIFS shared folders like your Windows file sharing and Samba folders.


pkgId: f33a3ab9c266974ba37d345023340d522ad05beb1dfb384146c3e1216d519808
name: python-pysnmp
arch: src
version: 4.4.12
epoch: 0
release: 1
summary: SNMP library for Python
url: https://github.com/etingof/pysnmp
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-434c6af7-5c4c-4cee-992f-bbd814f81d4e
location_href: 00004808-python-pysnmp/python-pysnmp-4.4.12-1.src.rpm
checksum_type: sha256
description:
  SNMP v1/v2c/v3 engine and Standard Applications suite written in pure-Python.
  Supports Manager/Agent/Proxy roles, Manager/Agent-side MIBs, asynchronous
  operation and multiple network transports.


pkgId: 2e938361e534e1cda208035adcf157c1d5b50430e88e613f1ad615208f758742
name: python-pyspark
arch: src
version: 3.3.2
epoch: 0
release: 1
summary: Apache Spark Python API
url: https://github.com/apache/spark/tree/master/python
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b68c33a-90ec-4e35-b420-ef1d9b1dec13
location_href: 00009025-python-pyspark/python-pyspark-3.3.2-1.src.rpm
checksum_type: sha256
description:
  Spark is a unified analytics engine for large-scale data processing. It provides
  high-level APIs in Scala, Java, Python, and R, and an optimized engine that
  supports general computation graphs for data analysis. It also supports a
  rich set of higher-level tools including Spark SQL for SQL and DataFrames,
  pandas API on Spark for pandas workloads, MLlib for machine learning, GraphX for graph processing,
  and Structured Streaming for stream processing.

  <https://spark.apache.org/>



  You can find the latest Spark documentation, including a programming
  guide, on the [project web page](https://spark.apache.org/documentation.html)




  This README file only contains basic information related to pip installed PySpark.
  This packaging is currently experimental and may change in future versions (although we will do our best to keep compatibility).
  Using PySpark requires the Spark JARs, and if you are building this from source please see the builder instructions at
  ["Building Spark"](https://spark.apache.org/docs/latest/building-spark.html).

  The Python packaging for Spark is not intended to replace all of the other use cases. This Python packaged version of Spark is suitable for interacting with an existing cluster (be it Spark standalone, YARN, or Mesos) - but does not contain the tools required to set up your own standalone Spark cluster. You can download the full version of Spark from the [Apache Spark downloads page](https://spark.apache.org/downloads.html).


  **NOTE:** If you are using this with a Spark standalone cluster you must ensure that the version (including minor version) matches or you may experience odd errors.



  At its core PySpark depends on Py4J, but some additional sub-packages have their own extra requirements for some features (including numpy, pandas, and pyarrow).
  See also [Dependencies](https://spark.apache.org/docs/latest/api/python/getting_started/install.html#dependencies) for production, and [dev/requirements.txt](https://github.com/apache/spark/blob/master/dev/requirements.txt) for development.


pkgId: c7f003f7e4177b99fb12ff659348a8ca19b2efc0a6bc6798634e10cd9b212836
name: python-pyspark-stubs
arch: src
version: 3.0.0.post3
epoch: 0
release: 1
summary: A collection of the Apache Spark stub files
url: https://github.com/zero323/pyspark-stubs
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-23a6a057-9d72-496c-a1df-ac85f9413466
location_href: 00010388-python-pyspark-stubs/python-pyspark-stubs-3.0.0.post3-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |PyPI version| |Conda Forge version|
  A collection of the Apache Spark `stub
  files <https://www.python.org/dev/peps/pep-0484/#stub-files>`__. These
  files were generated by
  `stubgen <https://github.com/python/mypy/blob/master/mypy/stubgen.py>`__
  and manually edited to include accurate type hints.
  Tests and configuration files have been originally contributed to the
  `Typeshed project <https://github.com/python/typeshed/>`__. Please refer
  to its `contributors
  list <https://github.com/python/typeshed/graphs/contributors>`__ and
  `license <https://github.com/python/typeshed/blob/master/LICENSE>`__ for
  details.


pkgId: 620530bab1cc2229977fe770e971441783ba2a0005eed721290453922263260e
name: python-pyspf
arch: src
version: 2.0.14
epoch: 0
release: 1
summary: SPF (Sender Policy Framework) implemented in Python.
url: https://github.com/sdgathman/pyspf/
rpm_license: Python Software Foundation License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e240780-0ad6-4719-b4ca-17f182768b7b
location_href: 00004811-python-pyspf/python-pyspf-2.0.14-1.src.rpm
checksum_type: sha256
description:
  This package requires either the dns (dnspython) or DNS (PyDNS/Py3DNS modules
  and either the ipaddr module or python3.3 and later.  It does not work with
  the ipaddress module backport.  For dnspython, at least version 1.16.0 is
  required.  The authres module is required to process and generate RFC 7601
  Authentication Results headers.  These can all be installed from pypi via pip.
  Additionally, they are also available via many distribution packaging systems.
  pyspf uses traditional python distutils, so dependencies are not installed
  automatically.  pyspf can be installed from pypi via pip or manually:
  After unpacking the source distribution, install this in your site-
  specific Python extension directory::
  	% python setup.py build
  	% su
  	
  The minimum Python version required is python2.6.  The spf module in this
  version has been tested with python3 versions through python3.8.


pkgId: 1b1c46985054205398360a3de5bdf148f69dfc3d9e9f7ac993bcc08dd5613f0c
name: python-pyspiflash
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: SPI data flash device drivers (pure Python)
url: http://github.com/eblot/pyspiflash
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b1103a77-794f-45dc-b37e-1be85be3a948
location_href: 00004812-python-pyspiflash/python-pyspiflash-0.6.3-1.src.rpm
checksum_type: sha256
description:
  SPI data flash device drivers (pure Python)
  SPI flash devices, also known as *DataFlash* are commonly found in embedded
  products, to store firmware, microcode or configuration parameters.
  PySpiFlash_ comes with several pure Python drivers for those flash devices, that
  demonstrate use of SPI devices with PyFtdi_. It could also be useful to dump
  flash contents or recover from a bricked devices.


pkgId: 8160fca39255b6b5d95f06226676039afcd5be96c66fe3649e752c3f3bdae0ce
name: python-pysqueezebox
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Asynchronous library to control Logitech Media Server
url: https://github.com/rajlaud/pysqueezebox
rpm_license: apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aa0f3e6e-971c-433c-ac2c-6a98d15e31a5
location_href: 00004813-python-pysqueezebox/python-pysqueezebox-0.6.1-1.src.rpm
checksum_type: sha256
description:
  This a library to control a Logitech Media Server asynchronously, intended for
  integration with Home Assistant.

  Much of the code was adapted from the Home Assistant squeezebox integration.
  The current convention is for all API-specific code to be part of a third
  party library hosted on PyPi, so I created a separate library.

  The function names track the terms used by the LMS API, so they do not all
  match the old Home Assistant squeezebox integration.

  Thank you to the original author of the squeezebox integration. If it is you,
  please let me know so I can credit you here.


  Install pysqueezebox from github, or using PyPi via pip.
  ```sh
  $ pip3 install pysqueezebox
  ```


  Import the Server() and Player() classes from this module. You will also need
  to create an aiohttp.ClientSession() that the module will use to communicate
  with the Logitech Media Server.

  You can use Server.async_get_players() to retrieve a list of connected players,
  or get a specific player using Server.async_get_player(name="PlayerName").
  Remember that any method starting with "async_" is a coroutine that must be
  preceded by an await to run.

  For more information on using aiohttp.ClientSession(), see
  https://aiohttp.readthedocs.io/en/stable/client_reference.html.
  ```Python
  from pysqueezebox import Server, Player
  import aiohttp
  import asyncio
  SERVER = '192.168.1.2' # ip address of Logitech Media Server

  async def main():
      async with aiohttp.ClientSession() as session:
          lms = Server(session, SERVER)
          player = await lms.async_get_player(name="Bedroom")
  	await player.async_update()
  	print(player.album)
  	await player.async_play()

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  ```


  The Player object stores information about the current status of the player.
  This allows you to retrieve the player's properties without any I/O. Remember
  to call Player.async_update() prior to retrieving properties if you want the
  most up-to-date information.


  Most of the useful functions are in the Player class. More documentation to
  follow, but in the meantime, the docstrings should be instructive.


pkgId: e6da0b7a9ecac162e59efd75215b95dcae68a6fdc20e89e40115072ec62962a9
name: python-pystache
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Mustache for Python
url: https://github.com/sarnold/pystache
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-96bbe5d8-fa0b-41ab-a598-f79a5cdb2f39
location_href: 00009554-python-pystache/python-pystache-0.6.0-1.src.rpm
checksum_type: sha256
description:
  |CI| |Conda| |Coverage| |Security check - Bandit| |Release|
  |pre-commit| |Maintainability|
  |Latest release| |License| |Python|
  This updated fork of Pystache is currently tested on Python 3.6+ and in
  Conda, on Linux, Macos, and Windows (Python 2.7 support has been
  removed).
  `Pystache <http://PennyDreadfulMTG.github.com/pystache>`__ is a Python
  implementation of `Mustache <http://mustache.github.com/>`__. Mustache
  is a framework-agnostic, logic-free templating system inspired by
  `ctemplate <https://code.google.com/p/google-ctemplate/>`__ and et by
  Ivan Formichev. Like ctemplate, Mustache "emphasizes separating logic
  from presentation: it is impossible to embed application logic in this
  template language."
  The `mustache(5) <https://mustache.github.com/mustache.5.html>`__ man
  page provides a good introduction to Mustache's syntax. For a more
  complete (and more current) description of Mustache's behavior, see the
  official `Mustache spec <https://github.com/mustache/spec>`__.
  Pystache is `semantically versioned <http://semver.org>`__ and older
  versions can still be found on
  `PyPI <http://pypi.python.org/pypi/pystache>`__. This version of
  Pystache now passes all tests in `version
  1.1.3 <https://github.com/mustache/spec/tree/v1.1.3>`__ of the spec.


pkgId: 8c8aec93803e7bed14f97703715bc31addc342e4b35960e33da665745e24d736
name: python-pystalk
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Very simple beanstalkd client
url: https://github.com/easypost/pystalk
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-767136d8-cfbc-499e-bd2c-38899b6987e1
location_href: 00004815-python-pystalk/python-pystalk-0.7.0-1.src.rpm
checksum_type: sha256
description:
  **`pystalk`** is an extremely simple Python client for [beanstalkd](http://kr.github.io/beanstalkd/).

  This project was initially created for [beancmd](https://github.com/EasyPost/beancmd). You may also be interested in that tool!

  [![CI](https://github.com/EasyPost/pystalk/workflows/CI/badge.svg)](https://github.com/EasyPost/pystalk/actions?query=workflow%3ACI)
  [![ReadTheDocs](https://readthedocs.org/projects/pip/badge/?version=latest)](http://pystalk.readthedocs.io/en/latest/)

  Note that _none_ of the objects in this package are inherently synchronized (thread-safe), and if you are going to use
  them from multiple threads, you should always protect them with a mutex. Clients are also not fork-safe, and should be
  initialized after any forking.



  This software works with Python 3.6+. It should work PyPy3 but has not been tested extensively.

  It does not support any asynchronous event loops and has not been tested with gevent. It's designed for simple,
  synchronous use.

  You should be able to install it from [PyPI](https://pypi.python.org) with `pip install pystalk`.





  ```python


  import json

  from pystalk import BeanstalkClient

  client = BeanstalkClient('10.0.0.1', 11300)
  client.put_job(json.dumps({"foo": "bar"}), delay=30)
  ```

  This will create a job with a 30-second delay on it. Note that the data for a job must be UTF-8 encodable.



  Beanstalk has a notion of `tube`s (which is to say, named queues). There are several ways to put a
  job into a specific tube using pystalk:

  ```python


  from pystalk import BeanstalkClient

  client = BeanstalkClient('10.0.0.1', 11300)


  client.use("some_tube")
  client.put_job("some message")


  with client.using("some_tube") as inserter:
      inserter.put_job("some message")



  client.put_job_into("some_tube", "some message")
  ```



  The following script will walk through all currently-READY jobs and then exit:

  ```python


  from pystalk import BeanstalkClient

  client = BeanstalkClient('10.0.0.1', 11300)
  for job in client.reserve_iter():
      try:
          execute_job(job)
      except Exception:
          client.release_job(job.job_id)
          raise
      client.delete_job(job.job_id)
  ```

  Note that, even though we require that job data be UTF-8 encodeable in the `put_job` method, we do not decode for you -- the job data that comes out is a byte-string in Python 3.5. You should call `.decode("utf-8")` on it if you want to get the input data back out. If you would like that behavior, pass `auto_decode=True` to the `BeanstalkClient` constructor; note that this might make it difficult for you to consume data injected by other systems which don't assume UTF-8.



  This library includes the `ProductionPool` class, which will insert jobs into beanstalk servers, rotating between them
  when an error occurs. Example usage:

  ```python
  from pystalk import BeanstalkClient, ProductionPool

  pool = ProductionPool.from_uris(
      ['beanstalkd://10.0.0.1:10300', 'beanstalkd://10.0.0.2:10300'],
      socket_timeout=10
  )
  pool.put_job_into('some tube', 'some job')
  ```

  The Pool **only** supports the `put_job` and `put_job_into` methods and makes no fairness guarantees; you should not use
  it for consumption.



  The following will reserve jobs from a group of Beanstalk servers, fairly rotating between them.

  ```python


  from myapp import execute_job
  from pystalk import BeanstalkClient, BeanstalkTimedOutError

  hosts = ('10.0.0.1', '10.0.0.2')
  clients = dict((h, BeanstalkClient(h, 11300)) for h in hosts)

  i = 0
  while True:
      i += 1
      client = clients[hosts[i % len(hosts)]]
      try:
          job = client.reserve_job(1)
      except BeanstalkError as e:
          if e.message == 'TIMED_OUT':
              continue
          else:
              raise
      execute_job(job)
      client.delete_job(job.job_id)
  ```



  Pretty straightforward. Develop in branches, send PRs, land on master. All tests must pass before landing.



     1. Land all requisite changes
     1. Bump the version in `setup.py` and `pystalk/__init__.py` to the stable version (e.g., `0.2`)
     1. Update [`CHANGES.rst`](docs/source/CHANGES.rst) with the changes and the new version number
     1. Update [`conf.py`](docs/source/conf.py) with the new version number
     1. Commit
     1. Tag the version (e.g., `git tag -s pystalk-0.2`)
     1. Push up to Github
     1. Upload to PyPI with `python setup.py sdist upload`


pkgId: dd18060b2d1454eb9f24fe825b4b9a47ce815ca2366f6971e2a652ded4b0b8cb
name: python-pystan
arch: src
version: 3.6.0
epoch: 0
release: 1
summary: Python interface to Stan, a package for Bayesian inference
url: https://mc-stan.org
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ac7ecb83-ff2e-4bc7-8263-40543bf39b31
location_href: 00009450-python-pystan/python-pystan-3.6.0-1.src.rpm
checksum_type: sha256
description:
  Install PyStan with ``pip install pystan``. PyStan runs on Linux and macOS. You will also need a C++ compiler such as gcc ≥9.0 or clang ≥10.0.
  The following block of code shows how to use PyStan with a model which studied coaching effects across eight schools (see Section 5.5 of Gelman et al (2003)). This hierarchical model is often called the "eight schools" model.
      import stan
      schools_code = """
      data {
        int<lower=0> J;         // number of schools
        real y[J];              // estimated treatment effects
        real<lower=0> sigma[J]; // standard error of effect estimates
      }
      parameters {
        real mu;                // population treatment effect
        real<lower=0> tau;      // standard deviation in treatment effects
        vector[J] eta;          // unscaled deviation from mu by school
      }
      transformed parameters {
        vector[J] theta = mu + tau * eta;        // school treatment effects
      }
      model {
        target += normal_lpdf(eta | 0, 1);       // prior log-density
        target += normal_lpdf(y | theta, sigma); // log-likelihood
      }
      """
      schools_data = {"J": 8,
                      "y": [28,  8, -3,  7, -1,  1, 18, 12],
                      "sigma": [15, 10, 16, 11,  9, 11, 10, 18]}
      posterior = stan.build(schools_code, data=schools_data)
      fit = posterior.sample(num_chains=4, num_samples=1000)
      eta = fit["eta"]  # array with shape (8, 4000)
      df = fit.to_frame()  # pandas `DataFrame`


pkgId: 379767f4b86ad75e3e4c7dd13db81ea34d7db9df6c2bb0c61ce5cc97eb5d718d
name: python-pystemd
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: A systemd binding for python
url: https://github.com/facebookincubator/pystemd
rpm_license: LGPL-2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-19aec325-a5c7-492f-9ce3-9fba33fde24c
location_href: 00004817-python-pystemd/python-pystemd-0.11.0-1.src.rpm
checksum_type: sha256
description:
  ![Continuous Integration](https://github.com/facebookincubator/pystemd/workflows/Continuous%20Integration/badge.svg?event=push)
  This library allows you to talk to systemd over dbus from python, without
  actually thinking that you are talking to systemd over dbus. This allows you to
  programmatically start/stop/restart/kill and verify services status from
  systemd point of view, avoiding executing `subprocess.Popen(['systemctl', ...`
  and then parsing the output to know the result.


pkgId: 5dec6e2f6b9769eb415a2ca3e48184c690a322bd8c55dbb512bf04188875269d
name: python-pysvn
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Svn for python.
url: https://github.com/leafvmaple/pysvn
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c63e10a1-f339-40b4-a2a0-2fbc1602c0c4
location_href: 00004820-python-pysvn/python-pysvn-0.1.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/pysvn)

  This is a Python package that can operate `svn`, provide `log`, `diff`, `numstat` operation.



  Binary installers for the latest released version are available at the `Pypi`.

  ```
  python -m pip install --upgrade pysvn
  ```





  > initialize the client on `cwd`

  ```python
  import pysvn

  client = pysvn.Client(cwd = os.getcwd(), stdout = subprocess.PIPE)
  ```



  > Show the log messages for a set of revision(s) and/or path(s)..

  ```python
  client.log(decoding = 'utf8')
  ```



  > Display local changes or differences between two revisions or paths

  ```python
  client.diff(start_version, end_version = None, decoding = 'utf8', cache = False)
  ```



  > Shows number of added and deleted lines in decimal notation and pathname

  ```python
  client.numstat(start_version, end_version = None, decoding = 'utf8', cache = False)
  ```



  [BSD](https://github.com/leafvmaple/pysvn/blob/main/LICENSE)


pkgId: e73fc01e28e01219c735389fe2a21251d826456e469cb55f3da5a557e816bcda
name: python-pytabcmd
arch: src
version: 9.2.0
epoch: 0
release: 1
summary: A tabcmd wrapper for Python
url: https://github.com/AccesoGroup/pytabcmd
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-476cd75a-85d6-4c71-b141-45d49c6db9c6
location_href: 00012568-python-pytabcmd/python-pytabcmd-9.2.0-1.src.rpm
checksum_type: sha256
description:
  **pytabcmd** is a simple Python wrapper for tabcmd_.
  Currently it works with tabcmd 9.2 in Linux (and should work in Windows too, but it's not tested).


pkgId: 72d84ebe05b959f7c3951e1f16e3af361f56fc746f164ca41d0b2876f6599f9d
name: python-pytablewriter
arch: src
version: 0.64.2
epoch: 0
release: 1
url: https://github.com/thombashi/pytablewriter
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-963aaba4-77e8-4ec1-85a2-cb5249123a5d
location_href: 00012611-python-pytablewriter/python-pytablewriter-0.64.2-1.src.rpm
checksum_type: sha256
summary:
  pytablewriter is a Python library to write a table in various formats: AsciiDoc / CSV / Elasticsearch / HTML / JavaScript / JSON / LaTeX / LDJSON / LTSV / Markdown / MediaWiki / NumPy / Excel / Pandas / Python / reStructuredText / SQLite / TOML / TSV / YAML.

description:
  `pytablewriter <https://github.com/thombashi/pytablewriter>`__ is a Python library to write a table in various formats: AsciiDoc / CSV / Elasticsearch / HTML / JavaScript / JSON / LaTeX / LDJSON / LTSV / Markdown / MediaWiki / NumPy / Excel / Pandas / Python / reStructuredText / SQLite / TOML / TSV / YAML.


pkgId: fc57c39c6d4d4fba65d31187cec3d051498fe88d19b308724a4d190544b5bf69
name: python-pytaglib
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: cross-platform, Python audio metadata ("tagging") library based on TagLib
url: http://github.com/supermihi/pytaglib
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3fbc98c9-8b8e-4e11-9002-a76b308efa55
location_href: 00004821-python-pytaglib/python-pytaglib-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pytaglib.svg)](https://pypi.org/project/pytaglib/)

  pytaglib is a [Python](http://www.python.org) audio tagging library. It is cross-platform and svery simple to use yet fully featured:
   - [supports more than a dozen file formats](http://taglib.github.io) including mp3, flac, ogg, wma, and mp4,
   - support arbitrary, non-standard tag names,
   - support multiple values per tag.

  pytaglib is a very thin wrapper (≈150 lines of [code](src/taglib.pyx)) around the fast and rock-solid [TagLib](http://taglib.github.io) C++ library.

  See the [Changelog](CHANGELOG.md).

  At first, you might need to install taglib with development headers. Ubuntu, Mint and other Debian-Based distributions:

          sudo apt install libtag1-dev

  On a Mac, use HomeBrew:

          brew install taglib

  Then install pytaglib with [pip](https://pip.pypa.io/en/stable/):

          pip install pytaglib



  For other operating systems and more details, see [installation notes](#installation-notes) below.



  ```python
  >>> import taglib
  >>> song = taglib.File("/path/to/my/file.mp3")
  >>> song.tags
  {'ARTIST': ['piman', 'jzig'], 'ALBUM': ['Quod Libet Test Data'], 'TITLE': ['Silence'], 'GENRE': ['Silence'], 'TRACKNUMBER': ['02/10'], 'DATE': ['2004']}

  >>> song.length
  239
  >>> song.tags["ALBUM"] = ["White Album"] # always use lists, even for single values
  >>> del song.tags["DATE"]
  >>> song.tags["GENRE"] = ["Vocal", "Classical"]
  >>> song.tags["PERFORMER:HARPSICHORD"] = ["Ton Koopman"]
  >>> song.save()
  ```
  For detailed API documentation, use the docstrings of the `taglib.File` class or view the [source code](src/taglib.pyx) directly.



  This package also installs the `pyprinttags` script. It takes one or more files as
  command-line parameters and will display all known metadata of that files on the terminal.
  If unsupported tags (a.k.a. non-textual information) are found, they can optionally be removed
  from the file.



  * Ensure that `pip` is installed and points to the correct Python version
    - on Windows, be sure to check *install pip* in the Python installer
    - on Debian/Ubuntu/Mint, install `python3-pip`
    - you might need to type, e.g., `pip-3` to install pytaglib for Python 3 if your system's default is Python 2.x.
  * For Windows users, there are some precompiled binary packages (wheels). See the [PyPI page](https://pypi.python.org/pypi/pytaglib) for a list of supported Python versions.
  * If no binary packages exists, you need to have both Python and taglib installed with development headers (packages `python3-dev` (or `python-dev`) and `libtag1-dev` for debian / ubuntu and derivates, `python-devel` and `taglib-devel` for fedora and friends, `brew install taglib` on OS X).



  * Debian- and Ubuntu-based linux flavors have binary packages for the Python 3 version, called `python3-taglib`. Unfortunatelly, they are heavily outdated, so you should instally the recent version via `pip` whenever possible.
  * For Arch users, there is a [package](https://aur.archlinux.org/packages/python-pytaglib/) in the user repository (AUR).


  You can download or checkout the sources and compile manually:

          python setup.py build
          python setup.py test  # optional, run unit tests
          sudo python setup.py install


  **Note**: The `taglib` Python extension is built from [`taglib.cpp`](src/taglib.cpp) which in turn is
  auto-generated by [Cython](http://www.cython.org) from [`taglib.pyx`](src/taglib.pyx).
  To regenerate the `taglib.cpp` after making changes to `taglib.pyx`, set the environment variable `PYTAGLIB_CYTHONIZE` to `1` before calling `setup.py` or `pip`.



  Install MS Visual Studio Build Tools (or the complete IE) and include the correct compiler version as detailed [here](https://wiki.python.org/moin/WindowsCompilers). Also enable *cmake* in the Visual Studio Installer.

  Then:
  - open the VS native tools command prompt
  - navigate to the *pytaglib* repository
  - run `python build_taglib_windows.py` which will download and build the latest official TagLib release
  - run `python setup.py install`



  For bug reports or feature requests, please use the
  [issue tracker](https://github.com/supermihi/pytaglib/issues) on GitHub. For anything else, contact
  me by [email](mailto:michaelhelmling@posteo.de).


pkgId: f8609d625960e97300381fba0d893dc9001ea9b9a715b3a909b34d84fe385445
name: python-pytapo
arch: src
version: 3.1.7
epoch: 0
release: 1
summary: Python library for communication with Tapo Cameras
url: https://github.com/JurajNyiri/pytapo
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-00af3042-5186-4fe8-ab94-bbc6d7c71575
location_href: 00004822-python-pytapo/python-pytapo-3.1.7-1.src.rpm
checksum_type: sha256
description:
  Python library for communication with Tapo Cameras



  ```
  python3 -m pip install pytapo
  ```





  ```
  from pytapo import Tapo

  user = "" # user you set in Advanced Settings -> Camera Account
  password = "" # password you set in Advanced Settings -> Camera Account
  host = "" # ip of the camera, example: 192.168.1.52

  tapo = Tapo(host, user, password)

  print(tapo.getBasicInfo())
  ```



  Depending on your camera model and firmware version, the authentication method varies.

  Normally you should be able to authenticate using the "camera account" created via the Tapo App (Settings > Advanced settings > Camera account).

  In case of a similar stack trace:

  ```
  Traceback (most recent call last):
    File "/home/user/Projects/pytapo/pytapo/__init__.py", line 41, in __init__
      self.basicInfo = self.getBasicInfo()
    File "/home/user/Projects/pytapo/pytapo/__init__.py", line 232, in getBasicInfo
      return self.performRequest(
    File "/home/user/Projects/pytapo/pytapo/__init__.py", line 95, in performRequest
      self.ensureAuthenticated()
    File "/home/user/Projects/pytapo/pytapo/__init__.py", line 61, in ensureAuthenticated
      return self.refreshStok()
    File "/home/user/Projects/pytapo/pytapo/__init__.py", line 80, in refreshStok
      raise Exception("Invalid authentication data")
  Exception: Invalid authentication data
  ```

  Attempt to authenticate using `admin` as `user` and your TP-Link cloud account password as `password`.



  Integration supports downloading recordings saved on camera's SD card.

  See [example script](https://github.com/JurajNyiri/pytapo/blob/main/experiments/DownloadRecordings.py).
  You need to call it with following ENV values:

  - `HOST`: IP Address of your camera
  - `PASSWORD_CLOUD`: Tapo cloud account password, it is required to access the recordings, everything is still local
  - `OUTPUT`: Directory where you wish to save all the recordings
  - `DATE`: Date for which to download recordings in format of YYYYMMDD, for example 20230221.

  You also need to have ffmpeg installed as that is used for converting the streams to watchable file.



  Contributions to pytapo are welcomed.

  By creating a PR you acknowledge and agree that you are not breaking any TOS, law and/or have a permission to provide and share the code changes.

  Owner of this repository is not legally responsible for any PRs or code changes to this project created by 3rd parties.

  When you make a new change to the code base, make sure to have 100% unit test coverage, see below for more information about tests.



  Set the following environment variables:

  `PYTAPO_USER` - user you set in Advanced Settings -> Camera Account

  `PYTAPO_PASSWORD` - password you set in Advanced Settings -> Camera Account

  `PYTAPO_IP` - ip of the camera, example: 192.168.1.52

  Install `pre-commit` and `tox` from pip.

  Run `pre-commit install` and `pre-commit install -t pre-push`.

  Then run `tox` to run all the tests.

  Linters are ran on every commit.

  Tests are ran on push.

  Your camera may do all the actions supported by this library, including, but not limited to, move, change privacy mode and reboot while tests are running. Camera does not format SD card during tests.

  After the tests are done, your camera should be in the initial state.



  - [Dale Pavey](https://research.nccgroup.com/2020/07/31/lights-camera-hacked-an-insight-into-the-world-of-popular-ip-cameras/) from NCC Group for the initial research on the Tapo C200
  - [likaci](https://github.com/likaci) and [his github repository](https://github.com/likaci/mercury-ipc-control) for the research on the Mercury camera on which tapo is based
  - [Tim Zhang](https://github.com/ttimasdf) for additional research for Mercury camera on [his github repository](https://github.com/ttimasdf/mercury-ipc-control)
  - [Gábor Szabados](https://github.com/GSzabados) for doing research and gathering all the information above in [Home Assistant Community forum](https://community.home-assistant.io/t/use-pan-tilt-function-for-tp-link-tapo-c200-from-home-assistant/170143/18)
  - [Davide Depau](https://github.com/Depau) for additional [research](https://md.depau.eu/s/r1Ys_oWoP) of the cameras and work on pytapo library
  - [Alex X](https://github.com/AlexxIT) for his incredible work on go2rtc library, and its code for Tapo stream communication which was rewritten to python in order to implement stream-related features of this library



  Pytapo is an unofficial module for achieving interoperability with Tapo cameras.

  Author is in no way affiliated with Tp-Link or Tapo.

  All the api requests used within the library are available and published on the internet (examples linked above) and this module is purely just a wrapper around those https requests.

  Author does not guarantee functionality of this library and is not responsible for any damage.

  All product names, trademarks and registered trademarks in this repository, are property of their respective owners.


pkgId: 9d4c5ab87d86891b211df799e926f4995666746fd624dea7df1da805f1f0bf44
name: python-pyte
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Simple VTXXX-compatible terminal emulator.
url: https://github.com/selectel/pyte
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e6955733-9b3b-423a-a154-720b087c8914
location_href: 00013709-python-pyte/python-pyte-0.8.1-1.src.rpm
checksum_type: sha256
description:
  It's an in memory VTXXX-compatible terminal emulator.
  *XXX* stands for a series of video terminals, developed by
  `DEC <http://en.wikipedia.org/wiki/Digital_Equipment_Corporation>`_ between
  1970 and 1995. The first, and probably the most famous one, was VT100
  terminal, which is now a de-facto standard for all virtual terminal
  emulators. ``pyte`` follows the suit.
  So, why would one need a terminal emulator library?
  * To screen scrape terminal apps, for example ``htop`` or ``aptitude``.
  * To write cross platform terminal emulators; either with a graphical
    (`xterm <http://invisible-island.net/xterm/>`_,
    `rxvt <http://www.rxvt.org/>`_) or a web interface, like
    `AjaxTerm <http://antony.lesuisse.org/software/ajaxterm/>`_.
  * To have fun, hacking on the ancient, poorly documented technologies.
  **Note**: ``pyte`` started as a fork of `vt102 <http://github.com/samfoo/vt102>`_,
  which is an incomplete pure Python implementation of VT100 terminal.


pkgId: 17d32336be9fbc5817cae4336e2d598bffd5ec0d593ba582b0cc145ecc5002f5
name: python-pytesseract
arch: src
version: 0.3.10
epoch: 0
release: 1
summary: Python-tesseract is a python wrapper for Google's Tesseract-OCR
url: https://github.com/madmaze/pytesseract
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fef2288a-96e0-41f4-8141-9773d14a9b86
location_href: 00009605-python-pytesseract/python-pytesseract-0.3.10-1.src.rpm
checksum_type: sha256
description:
  Python-tesseract is an optical character recognition (OCR) tool for python.
  That is, it will recognize and "read" the text embedded in images.
  Python-tesseract is a wrapper for `Google's Tesseract-OCR Engine <https://github.com/tesseract-ocr/tesseract>`_.
  It is also useful as a stand-alone invocation script to tesseract, as it can read all image types
  supported by the Pillow and Leptonica imaging libraries, including jpeg, png, gif, bmp, tiff,
  and others. Additionally, if used as a script, Python-tesseract will print the recognized
  text instead of writing it to a file.


pkgId: ca655e0e478c9a822e52de976eaac94bfb4ff16a2be239ce47010cfe1eaa3bfb
name: python-pytest
arch: src
version: 7.3.0
epoch: 0
release: 1
summary: pytest: simple powerful testing with Python
url: https://docs.pytest.org/en/latest/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c4deedd-76ab-4791-9195-020ddf39259d
location_href: 00008935-python-pytest/python-pytest-7.3.0-1.src.rpm
checksum_type: sha256
description:
  The ``pytest`` framework makes it easy to write small tests, yet
  scales to support complex functional testing for applications and libraries.
  An example of a simple test:
      
      def inc(x):
          return x + 1
      def test_answer():
          assert inc(3) == 5
  To execute it::


pkgId: bbece71c017e59de54c7079ed7eab5fc2d566cf4b5f07b9b86c89b1a16164fa6
name: python-pytest-aiohttp
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Pytest plugin for aiohttp support
url: https://github.com/aio-libs/pytest-aiohttp
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-63c9a67a-1b93-4f58-9f3a-02a6f88d7b9c
location_href: 00004825-python-pytest-aiohttp/python-pytest-aiohttp-1.0.4-1.src.rpm
checksum_type: sha256
description:
  pytest plugin for aiohttp support
  The library provides useful fixtures for creation test aiohttp server and client.


pkgId: 9cd11cc9d2ebdf07105c1fbddf9212ef5e9dbc50b100a305857488e81a15b18f
name: python-pytest-arraydiff
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: pytest plugin to help with comparing array output from tests
url: https://github.com/astropy/pytest-arraydiff
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-255a695d-86c8-4fca-98c7-b77ec9565ed7
location_href: 00004826-python-pytest-arraydiff/python-pytest-arraydiff-0.5.0-1.src.rpm
checksum_type: sha256
description:
  This is a `py.test <http://pytest.org>`__ plugin to facilitate the
  generation and comparison of data arrays produced during tests, in particular
  in cases where the arrays are too large to conveniently hard-code them
  in the tests (e.g. ``np.testing.assert_allclose(x, [1, 2, 3])``).
  The basic idea is that you can write a test that generates a Numpy array (or
  other related objects depending on the format). You can then either run the
  tests in a mode to **generate** reference files from the arrays, or you can run
  the tests in **comparison** mode, which will compare the results of the tests to
  the reference ones within some tolerance.
  At the moment, the supported file formats for the reference files are:
  -  A plain text-based format (based on Numpy ``loadtxt`` output)
  -  The FITS format (requires `astropy <http://www.astropy.org>`__). With this
     format, tests can return either a Numpy array for a FITS HDU object.
  For more information on how to write tests to do this, see the **Using**
  section below.


pkgId: e946acb8cc9cd05ad7c81243f70801c4a52baba445888cdfe1f36454b35f1ceb
name: python-pytest-asyncio
arch: src
version: 0.20.3
epoch: 0
release: 1
summary: Pytest support for asyncio
url: https://github.com/pytest-dev/pytest-asyncio
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-296bba1f-10fd-42c8-8a73-e2d4d7e77681
location_href: 00004829-python-pytest-asyncio/python-pytest-asyncio-0.20.3-1.src.rpm
checksum_type: sha256
description:
  pytest-asyncio is a `pytest <https://docs.pytest.org/en/latest/contents.html>`_ plugin. It facilitates testing of code that uses the `asyncio <https://docs.python.org/3/library/asyncio.html>`_ library.
  Specifically, pytest-asyncio provides support for coroutines as test functions. This allows users to *await* code inside their tests. For example, the following code is executed as a test item by pytest:
      @pytest.mark.asyncio
      async def test_some_asyncio_code():
          res = await library.do_something()
          assert b"expected result" == res
  Note that test classes subclassing the standard `unittest <https://docs.python.org/3/library/unittest.html>`__ library are not supported. Users
  are advised to use `unittest.IsolatedAsyncioTestCase <https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase>`__
  or an async framework such as `asynctest <https://asynctest.readthedocs.io/en/latest>`__.
  pytest-asyncio is available under the `Apache License 2.0 <https://github.com/pytest-dev/pytest-asyncio/blob/master/LICENSE>`_.


pkgId: 12647f909cac8446ff3638539824199c1f897d4f910ac022dd2cd820a192adc9
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-66cad44d-753e-496e-a40a-d0e7af7ef2c9
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: a22fa256b09b82de20f9252a032c7485683b2380409bdb1a45380650d8855a78
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-f11afcf7-145f-4f16-9e06-d1a8bcc57a9c
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: 1a2548de58c3a4ea491cd9456c41129956d1f060d72f12335dab9d78096a877b
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-69e5143a-c397-41c3-88f5-cd54a92b791f
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: a5c32e65c7dace664f0846642ee83ad00b1d90a3a17fa6c401392146bc7f6618
name: python-pytest-black
arch: src
version: 0.3.12
epoch: 0
release: 1
summary: A pytest plugin to enable format checking with black
url: https://github.com/shopkeep/pytest-black
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7712c4ac-a739-471d-a91a-94c5625935b9
location_href: 00011351-python-pytest-black/python-pytest-black-0.3.12-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/shopkeep/pytest-black.svg?branch=master)](https://travis-ci.org/shopkeep/pytest-black)
  A pytest plugin to enable format checking with [black](https://github.com/ambv/black).


pkgId: d44ef8121e31fd266487a7e94498b152625edf7b95dc2f1d09a0ecedc9f47cdf
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-4dbfde6c-2502-451d-bf37-07bd49280e3b
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: a8bc39cfba46a444614881644e879c744e3a641c4be1932b85faedc40f2ba7c4
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-23d51715-cdea-49a6-a56b-dba67e0da9a3
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: 393ff2d284693b4c5b1af1acd3cdfdbcd55454d6e71e78e373c144aa992e5e33
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-42f4b1af-df6c-4597-a0bb-0ca6b0403240
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: 8cf2103d1b227706bed462c5f56bd0de3b44ca55e410057ece4e9d397678d898
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-081168ce-9afa-4d60-9da4-ab6ae331e8b1
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: daadcf337c788f75fe0c077c5895f5298829ddc52fa70a26c556394a3c55af2c
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-562fad0c-c97a-4f84-9f44-40a5a9dbd95c
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: f6e85c28a354478ed213d2783e8e62437c690a960e5a0613b6f0f162751840ec
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-267a8574-57f5-464f-945b-2c17fb5efd9b
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: a65a193d8dce555dac20cf1df9b3d49c224923b3bce5b190ff210e71e0fc3360
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-0a7da7c1-a594-4d80-a863-2630de197482
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: fdc0ee063efe18faabe09b7063b89a56c12bed97d45bcbf92e682beeed57da8f
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-55fe7e48-fc6d-4c02-8a3c-64f4422f2995
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: 3c2e402f45866cdb35400a3d8afd282c36da59aacf5472f6735eb81864eb74e3
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-86a04bc3-253a-4cdf-a0b2-c5042b41eeb1
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: 5467466c5798026ef8ad81e5a008a0aedb93e04249394c7f9bc7c688099d6c7c
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-5c75836e-825f-4209-9683-70612f5608ae
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: b4c74e61128671e1e949bc6fc256a0ec05f45d8dd2857fa65196cc3526dbea05
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-c84cc08e-1f92-48fd-92ec-097727cf79a0
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: 4a9f2f41e469dc7ab5635f6fbdd06905d1f27b6c7687fc0cf4af7ea58b7bc6a5
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-556205f2-2ec2-42e3-8802-3811482442da
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: b26daa397ee927e6344d0cbeb6ce406a242119b0344371a00f37afb170c13b6a
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-556205f2-2ec2-42e3-8802-3811482442da
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: a9b6a7551e410f89d44727110e493410d69e53457a774b9284d981e0ef1b324b
name: python-pytest-grpc
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: pytest plugin for grpc
url: https://pypi.org/project/pytest-grpc/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95d88539-e109-4574-882b-28877750b80b
location_href: 00011339-python-pytest-grpc/python-pytest-grpc-0.8.0-1.src.rpm
checksum_type: sha256
description:
  _________________________________ test_example __________________________________
  grpc_stub = <stub.test_pb2_grpc.EchoServiceStub object at 0x107a9b390>
      def test_example(grpc_stub):
          request = EchoRequest()
  >       response = grpc_stub.error_handler(request)
  example/test_example.py:35:
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
  .env/lib/python3.7/site-packages/grpc/_channel.py:547: in __call__
      return _end_unary_response_blocking(state, call, False, None)
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
  state = <grpc._channel._RPCState object at 0x107b263c8>
  call = <grpc._cython.cygrpc.SegregatedCall object at 0x107b323c8>
  with_call = False, deadline = None
      def _end_unary_response_blocking(state, call, with_call, deadline):
          if state.code is grpc.StatusCode.OK:
              if with_call:
                  rendezvous = _Rendezvous(state, call, None, deadline)
                  return state.response, rendezvous
              else:
                  return state.response
          else:
  >           raise _Rendezvous(state, None, None, deadline)
  E           grpc._channel._Rendezvous: <_Rendezvous of RPC that terminated with:
  E           	status = StatusCode.UNKNOWN
  E           	details = "Exception calling application: Some error"
  E           	debug_error_string = "{"created":"@1544451353.148337000","description":"Error received from peer","file":"src/core/lib/surface/call.cc","file_line":1036,"grpc_message":"Exception calling application: Some error","grpc_status":2}"
  E           >


pkgId: 535735a449b236f7847b775ed91aabe3c2471289887723dfd40bb5c29ebfd38a
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-a8f04dbb-363d-4b14-a0eb-adeeea7db434
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: d00a2f24efc311c986ff993995b81074657c53dd90d7e79629fb1d4808b88cb1
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-9920fb80-f767-4c7c-8017-e452cf719f16
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: 47e514ff9a8a4a33bb1e097c5e5b6cc928dc85fd5fadebad831cff8d86041a0a
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-9920fb80-f767-4c7c-8017-e452cf719f16
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: f95537c31e753ceafc04471c89b67920b872d34b8e5d0346f26e2276a21925ae
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-22c77a87-5912-4d38-ac60-72ea58130ffc
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: 11291287242c9065da900b1f620ffa422d76d83f09274e45a5415923cce49df6
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-4656521b-fd3d-4b7d-9089-8515f8323e94
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: e200cded19bdff5102e274bc9675c92308a9c8650e69e084ae90bac9c5761ecd
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-ffffb934-045c-4ba0-b07a-6a1b2ec789f6
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: 46de8802a6ea1f6cb9e0f54820b1502999ab4b7581f989de4959f43e9de85e7e
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-28240ea0-4cc5-46d8-bba6-3df61b49b62b
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: 03cb5c6a79b6ec0aa983303b282fe4bed112203af2ed40a23778723cc9060d85
name: python-pytest-instafail
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: pytest plugin to show failures instantly
url: https://github.com/pytest-dev/pytest-instafail
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-803aaeb5-8102-47e2-80ea-f3a23dc7d4f0
location_href: 00009782-python-pytest-instafail/python-pytest-instafail-0.5.0-1.src.rpm
checksum_type: sha256
description:
  |build status|_
  pytest-instafail is a plugin for `pytest <https://pytest.org>`_ that shows
  failures and errors instantly instead of waiting until the end of test session.


pkgId: 15d73a05878122418617fc654976a22da3c64bb40079cb8a461945f57e3f0a92
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-7cc5ea3b-99c0-4d8f-8b91-79653bdc5d3d
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: 674bb18f2a99ed2c9775f58b264b121760a3e638ac2fff0bb72ff079ebcd1c58
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-959e982a-4be4-4361-adc6-bcf387d35811
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: d906d109a63c59a88958b76cdaca481be66957f144a3aef2a516c803b07fff2d
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-2c6068d4-4199-4da5-85f3-9ec57f72cd2b
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: bb926eb15b85d2cbf19c4c931740ff1c92001818582e5b39c63be196ee704041
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-5dca6d9e-4af2-472a-aae7-60afc5d6d793
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: 852b808f0605c0c321fc8140035331d5ef571bc1b338ea458e7c6e3531cd40c7
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-c1edb753-7ae3-4b24-9b34-43510f0ab1ed
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: 54d4d7e8b9a38a08fed3f5afb896c49c94b77f4d91a4b9c62b789e7f201d0cd0
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-bd1c83b0-f7eb-40ca-ab18-511983734ca1
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: 135f06876fcebc4d200d4bc2ec66351b30621e78f750cb2b8ded5aa7cd67348e
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-691f0587-1b04-4560-b687-bd933c7a545f
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: c535c9a6cb3317af6327896a1b2ce83b0a78b2f6da4a1386dd715f20646cbb17
name: python-pytest-pylint
arch: src
version: 0.19.0
epoch: 0
release: 1
summary: pytest plugin to check source code with pylint
url: https://github.com/carsongee/pytest-pylint
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-80d4f386-38ef-47a1-ae37-3c9de3cd5cec
location_href: 00010997-python-pytest-pylint/python-pytest-pylint-0.19.0-1.src.rpm
checksum_type: sha256
description:
  Run pylint with pytest and have configurable rule types
  (i.e. Convention, Warn, and Error) fail the build.  You can also
  specify a pylintrc file.


pkgId: faafe68873ea023bbf3ccbf10d82aa847f76877e631f0add8799e216b5b054a3
name: python-pytest-pythonpath
arch: src
version: 0.7.4
epoch: 0
release: 1
summary: pytest plugin for adding to the PYTHONPATH from command line or configs.
url: https://github.com/bigsassy/pytest-pythonpath
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9273fbef-2259-4dfa-b58f-25588100acae
location_href: 00010348-python-pytest-pythonpath/python-pytest-pythonpath-0.7.4-1.src.rpm
checksum_type: sha256
description:
  **NOTE:**  This plugin is obsolete as of pytest 7.0.0.  Thanks to [this PR](https://github.com/pytest-dev/pytest/pull/9134) from [Brian Okken](https://github.com/okken), you can now modify the PYTHONPATH using the `pythonpath` configuration option.  See documentation here: https://docs.pytest.org/en/7.0.x/reference/reference.html#confval-pythonpath
  This is a py.test plugin for adding to the PYTHONPATH from the pytests.ini file before tests run.


pkgId: 644fedcb7cb84f7bc8871570a4b04f240ad39577129e49c907f0ed32ca672e29
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-55f3c816-aff0-4387-b9db-ee550ed1b600
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: c5850e723ca844f122b0c2da336f6dcc32991efc39c1f886cbf7697d607f7f2f
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-8f7265dc-7b49-448b-8408-bbaf122644e5
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: a0ef6e6304d624a14e5410b4d9c61f01a8a481684ddd96592c876a9a65a2e5fc
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-24e3695b-8f62-462e-a64a-a0a413e74860
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: 4a78d2841a0af8ee90748a9c951884d23d176f876f6d60ce7223a1d9c5957de8
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-60e6ce56-4187-4f7f-adff-6946912586d8
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: 18870374964ee8ee1da642910709ef8741f9939662523a34eeaf2ba3824c1da8
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-68f43821-0fb4-479c-ad3c-ad12d5bafacf
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: 2bd7785061e4bb25e6d4207a06bff321e3819efb16eb68e2d841e8ab70082fc8
name: python-pytest-selenium
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: pytest plugin for Selenium
url: https://github.com/pytest-dev/pytest-selenium
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-13b07cfd-5cf6-45aa-a64c-0c0244adbf07
location_href: 00011404-python-pytest-selenium/python-pytest-selenium-4.0.0-1.src.rpm
checksum_type: sha256
description:
  pytest-selenium is a plugin for `pytest <http://pytest.org>`_ that provides
  support for running `Selenium <http://seleniumhq.org/>`_ based tests.


pkgId: 67f40cc1bad696697d47a07294af945264924615e817cd2bebeb59355d1b5d93
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-8a2247c7-b48a-4e71-9026-9a7f7c02f618
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: 199ed31256740a4afd859f7a14576556865fe238c5756364c9cab99ee33b6af0
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-da7143e7-957a-4f76-bd3f-2101167af378
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: bd68833e977c2832f574bbd56f78eed53d83d828cf94abb03add55e50693367e
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-2e625325-1be7-4ea1-b0aa-3d9c5fdab769
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: 32c6dc5a4913069b2791d7ecc1cbcf902c001e90b67aab22b03a9fd808685b09
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-a70f59ab-5ff6-48c3-9c0d-8e67ec108313
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: 08a5810ed9f370e610b8f2177f31268326a7e28f4cddcce9cac8cf95d567ff78
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-c3d75fe3-5e64-4b28-805d-4cae6c4aa375
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: fc0d1241155f8e3740890c47e8f7dabb1b94f409f7036f4419e7161616591373
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-9d3ec46d-fdb4-420e-bcea-7128a6ac412d
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: cc7c9e0201b5bcee17fcace21d1b190be7b22c5f713f4268b834592b062bb800
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-0a971686-a8b7-4832-856c-357449405d06
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: 26b218396f8eb651426352f443f9baea9a4d16fb87637eeafaf3a8557ec7c911
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-4c934e3f-d590-4fa5-8ce2-9822f1534859
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: f0a980ac18dc7349019f3c673149fbb310e50b81fbfdf99355e91496c4790b4e
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-bb4a11da-cb34-408a-b216-9588bf9b47bf
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: 4e5dd746316bc7a3c4b1c01a1670a4e62921ae7eb36d4e1ae686ac7182e8942f
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-a34ea351-eb64-443b-b3d7-122e60f4de72
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: 55867ce98af16eceb09541b6e3a66d44a9741db47665857c9efbc2068372351a
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-fc3b65f7-3793-4082-9e59-886a55e16ca6
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: f25cb67fd5276e87fa139d66eb2afd9be12d88a5d97da584a9133af1aa2f1561
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-26dcae36-0101-4883-a544-816b45a75714
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: 5719da10eab8a2ac545622e79f37fc850ed832f06065f665bdc35201443d3965
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-7569d605-4607-4412-8e25-a61abac0b738
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: 2c476499d14a3e87899d6ff22c53a23b0bc46e15e6183ca4e95ba9e2e6410742
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-1037f26d-a76a-4b57-826a-34ac939aaa6f
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: ba1b3ca1fa1577e8993b57c97db53a942de5a0d6933c38959ee9cfe6cfc46411
name: python-pythena
arch: src
version: 1.6.0
epoch: 0
release: 1
url: https://github.com/chrispruitt/pythena
rpm_license: Mozilla Public License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bfd28a89-e34a-4a07-93b6-912f276782d9
location_href: 00014258-python-pythena/python-pythena-1.6.0-1.src.rpm
checksum_type: sha256
summary:
  A simple athena wrapper leveraging boto3 to execute queries and return results while only requiring a database and a query string.

description:
  This is a simple python module that will allow you to query athena the same way the AWS Athena console would. It only requires a database name and query string.



  ```bash
  pip install pythena
  ```



  Be sure to set up your AWS authentication credentials. You can do so by using the aws cli and running

  ```bash
  pip install awscli
  aws configure
  ```

  More help on configuring the aws cli here https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html



  ```python
  import pythena

  athena_client = pythena.Athena("mydatabase")


  df = athena_client.execute("select * from mytable")

  print(df.sample(n=2)) # Prints 2 rows from your dataframe
  ```



  ```python
  import boto3
  import pythena


  athena_client = pythena.Athena(database="mydatabase")

  athena_client = pythena.Athena(database="mydatabase", region='us-east-1')

  athena_client = pythena.Athena(database="mydatabase", session=boto3.session.Session())

  ```



  ```
  execute(
    query='SQL_QUERY',                   # Required
    s3_output_url='FULL_S3_PATH',        # Optional (Format example: 's3://mybucket/mydir'
    save_results=TRUE | FALSE            # Optional. Defaults to True only when 's3_output_url' is provided. If True, the s3 results will not be deleted and an tuple is returned with the execution_id.
    run_async=TRUE | FALSE               # Optional. If True, allows you to run the query asynchronously. Returns execution_id, use get_result(execution_id) to fetch it when finished
    workgroup='primary'                  # Optional. Defaults to 'primary' workgroup
  )
  ```

  Note: `execute()` returns a tuple (dataframe, execution_id) unless `run_async=True`, then it only returns the execution_id.



  ```python
  import boto3
  import pythena


  pythena.print_databases()
  pythena.print_databases(region='us-east-1') # Overrides default region
  pythena.print_databases(session=boto3.session.Session()) # Overrides default profile


  pythena.get_databases()
  pythena.get_databases(region='us-east-1') # Overrides default region
  pythena.get_databases(session=boto3.session.Session()) # Overrides default profile


  athena_client = pythena.Athena(database="mydatabase")
  athena_client = pythena.Athena(database="mydatabase", region='us-east-1') # Overrides default region
  athena_client = pythena.Athena(database="mydatabase", session=boto3.session.Session()) # Overrides default profile


  athena_client.print_tables()


  athena_client.get_tables()


  dataframe, _ = athena_client.execute(query="select * from my_table") # Results are  returned as a dataframe


  dataframe, execution_id = athena_client.execute(query="select * from my_table", s3_output_url="s3://mybucket/mydir") # Results are  returned as a dataframe


  dataframe, execution_id = athena_client.execute(query="select * from my_table", save_results=True)


  dataframe, execution_id = athena_client.execute(query="select * from my_table", save_results=True)


  execution_id = athena_client.execute(query="select * from my_table", run_async=True) # Returns just the execution id
  dataframe = athena_client.get_result(execution_id) # Will report errors if query failed or let you know if it is still running


  pythena.get_query_status(execution_id)
  pythena.get_query_error(execution_id)
  pythena.cancel_query(execution_id)

  ```



  By default, when executing athena queries, via boto3 or the AWS athena console, the results are saved in an s3 bucket. This module by default, assuming a successful execution, will delete the s3 result file to keep s3 clean. If an s3_output_url is provided, then the results will be saved to that location and will not be deleted.


pkgId: d2ef65c69c42d3c3c2af797d6a39d61ef3983e8d707936cc6dd1011bbad86799
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-c725f71e-6324-416d-bd07-4aecc68980a9
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: dafa1775f43eb5384c7b4b927ea7d9574e8a059c1ff1ed81a03764cf2fba8f63
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-96007b53-6492-4986-82ed-947b8c4630e2
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: 8b9233b84aca585a283104d65da7ab6e4dd1bf0d143b2997004b2346fde35aa3
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-61d08276-99a0-4d38-8338-a53a7f3da898
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: 372584692bfd97f2565ed4ff2278572b81f531ff8f2162f1176e052d8832dbd0
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-7acd632e-039b-465b-bd7e-1e7c4a036991
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: bc12816c07e4edff689e8f7311e350fc94a85dc72f374317106fc2b0f6ffec8b
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-d1739092-1077-478a-a902-81f01d41b789
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: 6c3995a8775726dc5b004eeff5c2401c7225fb0cd37884923569eb29edda21b4
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-fb575455-c02e-4864-b35a-2e2a117ff699
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: 0a7e7865cbca4e6cb1ddb3aefeb11f75fe3f8fc4bb3063d95e968e1309111f81
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-3d64e174-b2cd-4c5f-a7e9-ac8b7ff77c0e
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: e48f7381da86dcde94a9d19aec48f7757115554997342749377fe23a893b394b
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-4bf3d519-8aec-4663-bd11-d2dd9d6b1157
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: 571ceb5cf33fb137c40f9e087d6d07fac6b7adb74865e91eeeba422b3c68b7a0
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-94d9659d-12ee-4169-bbba-2b61e5e5e937
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: 45fad05ab00f975ad378f5d1416bd8abf90f204c8f21370f4492fbcca0977bf2
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-7b5148c2-e8f2-4747-b145-38c8a2bb5738
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: 7d44fa1a5dd13c604bbcccb0025736c72442befd33fad67e29aa7fee1ba1a581
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-19277011-e785-48d0-a97c-227301b486fc
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: 1a562e225c8491a7b2596b055a37df766ba93a48531665134577cd3707f39350
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-a04b9782-6660-4ad8-9f65-4901b2f19bc7
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: 2f5401080ca9836cc0ffec8bc450255bfa8214b6d7f560eff24e310e7474064a
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-5f545b9a-c5f1-4f58-ad79-2c408a918c42
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: ba09685a3ff0fe817d4593b24cd0e0c28f347e7be082efe5fa75c0844ffb2df8
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-a27b08f0-5a45-459c-b6ad-dd79bfbec70a
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: 8620ddbd987a591ec6d95b9e35d54659dbc45f9007b5343a33e9a7322aa070c1
name: python-pyupgrade
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: A tool to automatically upgrade syntax for newer versions.
url: https://github.com/asottile/pyupgrade
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ea0b35c-a988-4e8a-96d3-e36bdb63ef67
location_href: 00011302-python-pyupgrade/python-pyupgrade-3.3.1-1.src.rpm
checksum_type: sha256
description:
  A tool (and pre-commit hook) to automatically upgrade syntax for newer
  versions of the language.

  ```bash
  pip install pyupgrade
  ```

  See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
  Sample `.pre-commit-config.yaml`:
  ```yaml
  -   repo: https://github.com/asottile/pyupgrade
      rev: v3.3.1
      hooks:
      -   id: pyupgrade
  ```


  ```diff
  -set(())
  +set()
  -set([])
  +set()
  -set((1,))
  +{1}
  -set((1, 2))
  +{1, 2}
  -set([1, 2])
  +{1, 2}
  -set(x for x in y)
  +{x for x in y}
  -set([x for x in y])
  +{x for x in y}
  ```

  ```diff
  -dict((a, b) for a, b in y)
  +{a: b for a, b in y}
  -dict([(a, b) for a, b in y])
  +{a: b for a, b in y}
  ```

  ```diff
  -'{0} {1}'.format(1, 2)
  +'{} {}'.format(1, 2)
  -'{0}' '{1}'.format(1, 2)
  +'{}' '{}'.format(1, 2)
  ```

  Availability:
  - Unless `--keep-percent-format` is passed.
  ```diff
  -'%s %s' % (a, b)
  +'{} {}'.format(a, b)
  -'%r %2f' % (a, b)
  +'{!r} {:2f}'.format(a, b)
  -'s s' % {'a': 1, 'b': 2}
  +'{a} {b}'.format(a=1, b=2)
  ```

  ```diff
  -u'foo'
  +'foo'
  -u"foo"
  +'foo'
  -u'''foo'''
  +'''foo'''
  ```

  ```diff
   
  -'\d'
  +r'\d'
   
  -'\n\d'
  +'\n\\d'
  -u'\d'
  +r'\d'
   
  -'\N'
  +r'\N'



  ```

  In python3.8+, comparison to literals becomes a `SyntaxWarning` as the success
  of those comparisons is implementation specific (due to common object caching).
  ```diff
  -x is 5
  +x == 5
  -x is not 5
  +x != 5
  -x is 'foo'
  +x == 'foo'
  ```

  ```diff
  -'foo'.encode()
  +b'foo'
  -'foo'.encode('ascii')
  +b'foo'
  -'foo'.encode('utf-8')
  +b'foo'
  -u'foo'.encode()
  +b'foo'
  -'\xa0'.encode('latin1')
  +b'\xa0'
  ```

  A fix for [python-modernize/python-modernize#178]
  ```diff
   
   print(())
   
   print((1,))
   
   sum((i for i in range(3)), [])
   
  -print(("foo"))
  +print("foo")
  ```
  [python-modernize/python-modernize#178]: https://github.com/python-modernize/python-modernize/issues/178

  Rewrites [deprecated unittest method aliases](https://docs.python.org/3/library/unittest.html#deprecated-aliases) to their non-deprecated forms.
  ```diff
   from unittest import TestCase
   class MyTests(TestCase):
       def test_something(self):
  -        self.failUnlessEqual(1, 1)
  +        self.assertEqual(1, 1)
  -        self.assertEquals(1, 1)
  +        self.assertEqual(1, 1)
  ```

  ```diff
   class C(Base):
       def f(self):
  -        super(C, self).f()
  +        super().f()
  ```


  ```diff
  -class C(object): pass
  +class C: pass
  -class C(B, object): pass
  +class C(B): pass
  ```

  ```diff
   class C:
  -    __metaclass__ = type
  ```

  ```diff
  -str()
  +''
  -str("foo")
  +"foo"
  ```

  ```diff
  -"foo".encode("utf-8")
  +"foo".encode()
  ```

  as of [PEP 3120], the default encoding for python source is UTF-8
  ```diff
  -# coding: utf-8
   x = 1
  ```
  [PEP 3120]: https://www.python.org/dev/peps/pep-3120/

  Availability:
  - by default removes `nested_scopes`, `generators`, `with_statement`,
    `absolute_import`, `division`, `print_function`, `unicode_literals`
  - `--py37-plus` will also remove `generator_stop`
  ```diff
  -from __future__ import with_statement
  ```

  ```diff
  -from io import open
  -from six.moves import map
  -from builtins import object  # python-future
  ```

  Availability:
  - `--py36-plus` (and others) will replace imports
  see also [reorder-python-imports](https://github.com/asottile/reorder_python_imports#removing--rewriting-obsolete-six-imports)
  some examples:
  ```diff
  -from collections import deque, Mapping
  +from collections import deque
  +from collections.abc import Mapping
  ```
  ```diff
  -from typing import Sequence
  +from collections.abc import Sequence
  ```
  ```diff
  -from typing_extensions import Concatenate
  +from typing import Concatenate
  ```

  Availability:
  - [Unless `--keep-mock` is passed on the commandline](https://github.com/asottile/pyupgrade/issues/314).
  ```diff
  -from mock import patch
  +from unittest.mock import patch
  ```

  ```diff
   def f():
  -    for x in y:
  -        yield x
  +    yield from y
  -    for a, b in c:
  -        yield (a, b)
  +    yield from c
  ```

  ```diff
   import sys
  -if sys.version_info < (3,):  # also understands `six.PY2` (and `not`), `six.PY3` (and `not`)
  -    print('py2')
  -else:
  -    print('py3')
  +print('py3')
  ```
  Availability:
  - `--py36-plus` will remove Python <= 3.5 only blocks
  - `--py37-plus` will remove Python <= 3.6 only blocks
  - so on and so forth
  ```diff
   
   import sys
  -if sys.version_info < (3, 6):
  -    print('py3.5')
  -else:
  -    print('py3.6+')
  +print('py3.6+')
  -if sys.version_info <= (3, 5):
  -    print('py3.5')
  -else:
  -    print('py3.6+')
  +print('py3.6+')
  -if sys.version_info >= (3, 6):
  -    print('py3.6+')
  -else:
  -    print('py3.5')
  +print('py3.6+')
  ```
  Note that `if` blocks without an `else` will not be rewritten as it could introduce a syntax error.

  ```diff
  -six.text_type
  +str
  -six.binary_type
  +bytes
  -six.class_types
  +(type,)
  -six.string_types
  +(str,)
  -six.integer_types
  +(int,)
  -six.unichr
  +chr
  -six.iterbytes
  +iter
  -six.print_(...)
  +print(...)
  -six.exec_(c, g, l)
  +exec(c, g, l)
  -six.advance_iterator(it)
  +next(it)
  -six.next(it)
  +next(it)
  -six.callable(x)
  +callable(x)
  -six.moves.range(x)
  +range(x)
  -six.moves.xrange(x)
  +range(x)
  -from six import text_type
  -text_type
  +str
  -@six.python_2_unicode_compatible
   class C:
       def __str__(self):
           return u'C()'
  -class C(six.Iterator): pass
  +class C: pass
  -class C(six.with_metaclass(M, B)): pass
  +class C(B, metaclass=M): pass
  -@six.add_metaclass(M)
  -class C(B): pass
  +class C(B, metaclass=M): pass
  -isinstance(..., six.class_types)
  +isinstance(..., type)
  -issubclass(..., six.integer_types)
  +issubclass(..., int)
  -isinstance(..., six.string_types)
  +isinstance(..., str)
  -six.b('...')
  +b'...'
  -six.u('...')
  +'...'
  -six.byte2int(bs)
  +bs[0]
  -six.indexbytes(bs, i)
  +bs[i]
  -six.int2byte(i)
  +bytes((i,))
  -six.iteritems(dct)
  +dct.items()
  -six.iterkeys(dct)
  +dct.keys()
  -six.itervalues(dct)
  +dct.values()
  -next(six.iteritems(dct))
  +next(iter(dct.items()))
  -next(six.iterkeys(dct))
  +next(iter(dct.keys()))
  -next(six.itervalues(dct))
  +next(iter(dct.values()))
  -six.viewitems(dct)
  +dct.items()
  -six.viewkeys(dct)
  +dct.keys()
  -six.viewvalues(dct)
  +dct.values()
  -six.create_unbound_method(fn, cls)
  +fn
  -six.get_unbound_function(meth)
  +meth
  -six.get_method_function(meth)
  +meth.__func__
  -six.get_method_self(meth)
  +meth.__self__
  -six.get_function_closure(fn)
  +fn.__closure__
  -six.get_function_code(fn)
  +fn.__code__
  -six.get_function_defaults(fn)
  +fn.__defaults__
  -six.get_function_globals(fn)
  +fn.__globals__
  -six.raise_from(exc, exc_from)
  +raise exc from exc_from
  -six.reraise(tp, exc, tb)
  +raise exc.with_traceback(tb)
  -six.reraise(*sys.exc_info())
  +raise
  -six.assertCountEqual(self, a1, a2)
  +self.assertCountEqual(a1, a2)
  -six.assertRaisesRegex(self, e, r, fn)
  +self.assertRaisesRegex(e, r, fn)
  -six.assertRegex(self, s, r)
  +self.assertRegex(s, r)
   
  -six.ensure_binary('...')
  +b'...'
  -six.ensure_str('...')
  +'...'
  -six.ensure_text('...')
  +'...'
  ```

  ```diff
  -with io.open('f.txt') as f:
  +with open('f.txt') as f:
  ```

  ```diff
  -open("foo", "U")
  +open("foo")
  -open("foo", "Ur")
  +open("foo")
  -open("foo", "Ub")
  +open("foo", "rb")
  -open("foo", "rUb")
  +open("foo", "rb")
  -open("foo", "r")
  +open("foo")
  -open("foo", "rt")
  +open("foo")
  -open("f", "r", encoding="UTF-8")
  +open("f", encoding="UTF-8")
  -open("f", "wt")
  +open("f", "w")
  ```

  ```diff
   
   
   
   
   
   
   def throw():
  -    raise EnvironmentError('boom')
  +    raise OSError('boom')
   def catch():
       try:
           throw()
  -    except EnvironmentError:
  +    except OSError:
           handle_error()
  ```

  ```diff
  -def f(x: Text) -> None:
  +def f(x: str) -> None:
  ```

  ```diff
  -foo, bar, baz = [fn(x) for x in items]
  +foo, bar, baz = (fn(x) for x in items)
  ```

  ```diff
  -import xml.etree.cElementTree as ET
  +import xml.etree.ElementTree as ET
  -from xml.etree.cElementTree import XML
  +from xml.etree.ElementTree import XML
  ```

  ```diff
  -type('')
  +str
  -type(b'')
  +bytes
  -type(0)
  +int
  -type(0.)
  +float
  ```

  Availability:
  - `--py36-plus` is passed on the commandline.
  ```diff
  -NT = typing.NamedTuple('NT', [('a', int), ('b', Tuple[str, ...])])
  +class NT(typing.NamedTuple):
  +    a: int
  +    b: Tuple[str, ...]
  -D1 = typing.TypedDict('D1', a=int, b=str)
  +class D1(typing.TypedDict):
  +    a: int
  +    b: str
  -D2 = typing.TypedDict('D2', {'a': int, 'b': str})
  +class D2(typing.TypedDict):
  +    a: int
  +    b: str
  ```

  Availability:
  - `--py36-plus` is passed on the commandline.
  ```diff
  -'{foo} {bar}'.format(foo=foo, bar=bar)
  +f'{foo} {bar}'
  -'{} {}'.format(foo, bar)
  +f'{foo} {bar}'
  -'{} {}'.format(foo.bar, baz.womp)
  +f'{foo.bar} {baz.womp}'
  -'{} {}'.format(f(), g())
  +f'{f()} {g()}'
  -'{x}'.format(**locals())
  +f'{x}'
  ```
  _note_: `pyupgrade` is intentionally timid and will not create an f-string
  if it would make the expression longer or if the substitution parameters are
  sufficiently complicated (as this can decrease readability).

  Availability:
  - `--py37-plus` is passed on the commandline.
  ```diff
  -output = subprocess.run(['foo'], universal_newlines=True)
  +output = subprocess.run(['foo'], text=True)
  ```

  Availability:
  - `--py37-plus` is passed on the commandline.
  ```diff
  -output = subprocess.run(['foo'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  +output = subprocess.run(['foo'], capture_output=True)
  ```

  Availability:
  - `--py38-plus` is passed on the commandline.
  ```diff
   import functools
  -@functools.lru_cache()
  +@functools.lru_cache
   def expensive():
  ```

  Availability:
  - `--py39-plus` is passed on the commandline.
  ```diff
   import functools
  -@functools.lru_cache(maxsize=None)
  +@functools.cache
   def expensive():
  ```

  Availability:
  - File imports `from __future__ import annotations`
      - Unless `--keep-runtime-typing` is passed on the commandline.
  - `--py39-plus` is passed on the commandline.
  ```diff
  -def f(x: List[str]) -> None:
  +def f(x: list[str]) -> None:
  ```

  Availability:
  - File imports `from __future__ import annotations`
      - Unless `--keep-runtime-typing` is passed on the commandline.
  - `--py310-plus` is passed on the commandline.
  ```diff
  -def f() -> Optional[str]:
  +def f() -> str | None:
  ```
  ```diff
  -def f() -> Union[int, str]:
  +def f() -> int | str:
  ```

  Availability:
  - File imports `from __future__ import annotations`
  ```diff
  -def f(x: 'queue.Queue[int]') -> C:
  +def f(x: queue.Queue[int]) -> C:
  ```

  Availability:
  - `--py311-plus` is passed on the commandline.
  ```diff
   import datetime
  -datetime.timezone.utc
  +datetime.UTC
  ```


pkgId: 403baaae7c74bf17ff1d56e9e0f50f1c8adaf5f81ee2e59852239bc5d73220c2
name: python-pyusb
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Python USB access module
url: https://pyusb.github.io/pyusb
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d08f66bf-617f-4905-801f-4f0655d76c5c
location_href: 00009896-python-pyusb/python-pyusb-1.2.1-1.src.rpm
checksum_type: sha256
description:
  PyUSB offers easy USB devices communication in Python.
  It should work without additional code in any environment with
  Python >= 3.6, ctypes and a pre-built USB backend library
  (currently: libusb 1.x, libusb 0.1.x or OpenUSB).


pkgId: 01cf0d11cd2fdbb955ad3b36ad267723fc1fbd8dc4cb000d9c8a038c4bf2bf29
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-14c1b803-2d90-4c94-9eec-554f320dc4b4
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: 119d658adbf14233fb626f8637dadf0c6df024edd00767f15a42a0f6634e42a2
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-fb9618e3-cf9a-43ff-bd00-ec92a3beea4f
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: 34c66f7aae3ad474f76b2c33761c9ff7ad5df136d5afce24ef760acb88e1be32
name: python-pyvista
arch: src
version: 0.38.5
epoch: 0
release: 1
summary: Easier Pythonic interface to VTK
url: https://pypi.org/project/pyvista/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9042b8f1-8817-4cb5-b576-4c62356758ec
location_href: 00014040-python-pyvista/python-pyvista-0.38.5-1.src.rpm
checksum_type: sha256
description:
  Head over to the `Quick Examples`_ page in the docs to explore our gallery of
  examples showcasing what PyVista can do! Want to test-drive PyVista?
  All of the examples from the gallery are live on MyBinder for you to test
  drive without installing anything locally: |binder|


pkgId: 3fbaa9b3df4f5f457385aa79c0ec65ed68d6a2060bdf3ce6a70929c897718f99
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-39dee184-fc36-4321-8a1a-7aa965e785e0
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: 4345e699d92754321c1c616f397af44652fc8f4425956553ba9f219c71b22618
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-7d81a2ed-e324-401c-bc97-20658d63a5bd
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: 6534af492542547cf0dc6e72fdff21146e4ee0cc6b0a2b6b25dd279e97bae3d9
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-2db43659-9a30-47fe-bde8-1716c95669d5
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: 53cd2da25d57738bdad7e2176424758205518fafda141d5ffec50865821576f8
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-ba0782a2-c2ed-4fd8-86bd-a7d127e81505
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: d88bd08de9653e849df21bae19f3cc7e0e50b68e5db97507c1f528edd54150bc
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-65e35c95-c815-4ec0-87f3-5226a2989633
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: c1f746ae5f2c037a9bf112a9a19c31453ead0d3583d7c1cb06c226e887638ce1
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-ab6a3a3e-5f28-4dbd-bb98-e84ff0810aa2
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: f485ac1e2943b99288c987d6e08cfbfa0e4dea46490411a079f84837e04a43d4
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-043fdefa-e867-46e2-b29a-fa3bf5d043ae
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: 30fc236f508e46d6fc14d0ba5ed14dbfb72b72a94622e2967cbd42608fa51769
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-133b7a0c-00d8-4b15-b8ac-d390e563b22d
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: b04ea14c25052ac844f9cfefc2090839d22e8a9a6263e7749a165312cb65d517
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-b2f53748-568c-44e2-91b5-432220f9be67
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: e7c976fe0e05151efca84e4c253c2681751e01f6b6369378224ee7df8c48ae28
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-202b5106-3b0a-42ab-954f-7010e8608eb5
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: c1b5531340fafe525f411011622aafd9a90b5f88547932c8a600ca0972c0af18
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-e5cb7e6b-da52-446b-86b8-81e23f9b81fd
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: 507a1acf085b018bac0033f80d7256f124a3f6f671a89aeab6f112ba159439dd
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-ef8708d0-d212-4c2b-bf8a-6753811c5a9b
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: 7514a84443c94386931711a55de8b4be50151ec84fdd91d798666fe782bcee46
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-b8c83aa7-c168-4742-a2fd-0fcc2abf322b
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: bcb86b9077fe46795bc8b7517395f28060ca552b4d644ab64c309231925f708f
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-a7733d45-b47b-416c-8f47-a353e1e6ea4b
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: d0a1e4ba6ee056664f47e4abf8bd620436eba14144d3403330d381305c64d8a3
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-40402d73-55f7-4321-8127-5e11ac6cbc77
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: 828e5569d1a5c7c748a4385da98230b460bfbcc9293df7a2fa4626af4da63868
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-1b6b4090-adb9-4b64-a91b-b9d35be0a11b
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: 6aed876fc53bb192ed2af0f57f7cb8dd702d22f5cc76bb798348ac902f9c2c4d
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-67a23c8f-6799-4992-8af9-2edf41183473
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: b78ec8d321f5f724fabfb0dd7f57ab380a644b2084b1d4b8cd258f387cc672a1
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-6aa6019f-fa0e-480b-8129-f36ab13e1246
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: 11a6e16e85c4c9de6f2e6c56944783b76006368083d08ee02e764708b48760c6
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-adc106ec-8338-42e7-b91b-01c361d437ec
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: b65072cabdb034eb75417727339332d34dca0f253e93b69166787a96dcf9a093
name: python-pyzstd-debuginfo
arch: x86_64
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-adc106ec-8338-42e7-b91b-01c361d437ec
rpm_sourcerpm: python-pyzstd-0.15.6-1.src.rpm
location_href: 00010467-python-pyzstd/python-pyzstd-debuginfo-0.15.6-1.x86_64.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: 876a2169f31725152373089f8d15c291929b32e251fa829b9a4907f04f34c728
name: python-pyzstd-debugsource
arch: x86_64
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-adc106ec-8338-42e7-b91b-01c361d437ec
rpm_sourcerpm: python-pyzstd-0.15.6-1.src.rpm
location_href: 00010467-python-pyzstd/python-pyzstd-debugsource-0.15.6-1.x86_64.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: 71b2e2e784970ee3f507ef6f8675cf70077b2b0208ae039e1daf780616a08902
name: python-qasync
arch: src
version: 0.24.0
epoch: 0
release: 1
summary: Implementation of the PEP 3156 Event-Loop with Qt.
url: https://github.com/CabbageDevelopment/qasync
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76a52bca-5618-4474-938a-2e11c7e94b44
location_href: 00014246-python-qasync/python-qasync-0.24.0-1.src.rpm
checksum_type: sha256
description:
  [![Maintenance](https://img.shields.io/maintenance/yes/2023)](https://pypi.org/project/qasync)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/qasync)](https://pypi.org/project/qasync)
  [![PyPI - License](https://img.shields.io/pypi/l/qasync)](/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/qasync)](https://pypi.org/project/qasync)
  [![test](https://github.com/CabbageDevelopment/qasync/actions/workflows/test.yml/badge.svg)](https://github.com/CabbageDevelopment/qasync/actions/workflows/test.yml)



  `qasync` allows coroutines to be used in PyQt/PySide applications by providing an implementation of the `PEP 3156` event-loop.

  `qasync` is a fork of [asyncqt](https://github.com/gmarull/asyncqt), which is a fork of [quamash](https://github.com/harvimt/quamash). May it live longer than its predecessors.



  `qasync` was created because `asyncqt` and `quamash` are no longer maintained.

  **`qasync` will continue to be maintained, and will still be accepting pull requests.**



  `qasync` requires Python >= 3.6, and PyQt5 or PySide2.



  To install `qasync`, use `pip`:

  ```
  pip install qasync
  ```



  You may use, modify and redistribute this software under the terms of the [BSD License](http://opensource.org/licenses/BSD-2-Clause). See [LICENSE](/LICENSE).


pkgId: f58f1204b3b75d34ced9795886fb1edfc3d2b0dea821aae88438a775aebf4e9d
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-25a9a338-4ef2-4866-bdd2-4067ed0e1ac6
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: f04e615e570d4be1488d9f6114fc9b0b77cb3e9a42d77750297b47bd536824f4
name: python-qds_sdk
arch: src
version: 1.16.1
epoch: 0
release: 1
summary: Python SDK for coding to the Qubole Data Service API
url: https://github.com/qubole/qds-sdk-py
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-150e0e57-c25b-4274-bc8a-ef019bce74fb
location_href: 00009864-python-qds-sdk/python-qds_sdk-1.16.1-1.src.rpm
checksum_type: sha256
description:
  A Python module that provides the tools you need to authenticate with,
  and use the Qubole Data Service API.


pkgId: 8c4b528a5221aed508093b0857ce86eb71e3c59abe46886499c041a7be4e3033
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-25255656-ee0f-4861-9bab-e9b3ed6a472e
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: d3be62a569f922722afe7577eb6247ea3bf44b481bdaa2ee616b297da218fac6
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-aca490f3-493d-4199-8572-b545abd9cabc
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: 0364acb12cecd43eaf68d471cae9f38c126b4cbc24c500b7d5f107590df15607
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-c8deead5-47bf-43bd-9293-4b86b7cdadd8
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: 5fe228b33c50e80a72e5fcf20c965a5f727a62c7830efcbbce190fa5d7827db1
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-3679bc7e-7d46-4cf3-980f-56f75b4c08fc
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: 2fe06fe7230597a8f1f5a2a5fa1e3cf82b924135f5842b557d5021e960cf6f19
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-794cf35c-4b6b-4b26-afea-421901e3299b
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: 63c887feaba724868d8979de0870df2a3499dfe0bfa02158843f6ada9e3aea3e
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-587c0f40-f77c-4d9a-a1bb-37ef5498859d
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: 0f1dcbfdf041f4e66337f1ed0a47bb48b8bdb5d242a1f68ae1bd9695c1ebf1a9
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-bbd9f33e-6a9e-446a-8af3-8be42168d97b
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: 847a203be3c32cf3bd1349e5b403854d3266a609563dde77b3a4bc3b635d791c
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-e450499d-92e9-42fe-9d6e-c27dbaa3bf03
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: feeeafcc42f5b79d3548f3224e0e06777848ad055681ab346553dda577f5256b
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-42e43e26-54e4-4079-986d-1917f92e0047
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: f2ad71d41b5985cfb695dcd728e102b500c74a96386e319e0097611e65a209dd
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-4d336bf8-4147-422d-a0fb-4ce873c963dd
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: a9062a33241978c94247ebef0724a8b70567cfa583adc1daa3f99d05df0e41e6
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-6d370ad2-dfaa-498d-9987-943881039d55
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: 72e87a0f614c05ee4b96c8aef43a62832b8a9dbc729d570ead7eea308e312f2a
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-c2f5e98f-e09d-4a27-a04d-cb225186b3af
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: 67e9b110949d5e6d06afad1774a06239eb21e5fa33b1cc1f95b379bb37dacb10
name: python-quotefancy
arch: src
version: 1.0
epoch: 0
release: 1
summary: Get Quotes from QuoteFancy.com
url: https://pypi.org/project/quotefancy/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10078980-9fef-4841-bf99-2279196f9f1b
location_href: 00012835-python-quotefancy/python-quotefancy-1.0-1.src.rpm
checksum_type: sha256
description:
  You can use to this Package to get random quotes as Text or Images. You can Download Quote too!

  Install it as
  `pip install quotefancy`


  ```
  from quotefancy import get_quote


  get_quote(type='img', download=True)


  print(get_quote(type='text'))

  ```


  - [New-Dev](https://github.com/New-dev0)


pkgId: 8e9c54cc4629b8281271d410f2ca28ba36e0bd90d122da1ea4d5c43b58156e31
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-7cfc9904-46d0-415f-b105-8ba4e5c5742b
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: fa26ae5d7a1c6e9f038de78a3b71358917d8f3c8b622eed24f32498d2960feb2
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-3ae13277-c50b-458e-b374-e17f54eb7da4
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: 759ec9e6ded279c670a11837ea7e5fadda8254d44c78f540708e476833610e98
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-93b3d0b7-a6e7-4afc-8e6b-32cf0872c2eb
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: 76a6a14a81f4cdc1972d8a1d2751aa5283858afe944cda217d641c451d763cc1
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-bd82abdb-bb4e-4374-b3c0-68dfb6a5c64f
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: f0dea9da7b9582167f94ce48f99f6ff8aa328b5487600a75d932e6611c4d571d
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-a9b3a3a7-7add-4226-93f6-08ad5124973a
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: 6762f58b04dfe3610aa6dd870167c069e732be15883c103ed3ba7c8a716cfef5
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-cb78c5ae-cbce-4512-bc3f-f7abf7ee7b40
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: b61e2c8cbd1e908249d1c189dae9247dd3e470c16756817682f82f12267db4a4
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-8965aa5e-265c-4a20-830c-fbd416f05448
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: 1a9e9286151f24e3601d101ea50398fb6104687b4b500472d34b873995968c02
name: python-rasterstats
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Summarize geospatial raster datasets based on vector geometries
url: https://pypi.org/project/rasterstats/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a1d01fc0-8979-489d-af28-e1d18e7381f7
location_href: 00013339-python-rasterstats/python-rasterstats-0.18.0-1.src.rpm
checksum_type: sha256
description:
  |BuildStatus|_
  ``rasterstats`` is a Python module for summarizing geospatial raster datasets based on vector geometries.
  It includes functions for **zonal statistics** and interpolated **point queries**. The command-line interface allows for
  easy interoperability with other GeoJSON tools.


pkgId: ff28b09e9b3c718a7e48e66080b14aebb62077341de5aa33210c393a36ef7816
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-f00536e0-402e-4952-a466-4bf5f5992c25
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: 4eb3401c2032557aa6842d3bdb3e5afe158a8b2966558333b2391d8966fe8248
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-13b61cc9-81d4-4aeb-b336-4d4ed6330b20
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: 67f1e6dd5e907753a3b726359a0348f41316954fdffe06e7d16fab7ac549e664
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-c257284b-0817-477f-911e-1e77621d3f88
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: 0a6af4820a0710c9af7322b86d7f0418caa84f338263b558e4e363a81c9b0eef
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-fdf0b207-f366-4aa3-98ce-9b9da1370d7b
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.


pkgId: 7e905ddbfe738b06525eb548c9fb1225b817af14a0a66b3b36305c4d58e6f724
name: python-raven
arch: src
version: 6.10.0
epoch: 0
release: 1
summary: Raven is a client for Sentry (https://getsentry.com)
url: https://github.com/getsentry/raven-python
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-829e20ef-7935-460e-ab76-d27da6e4e477
location_href: 00004929-python-raven/python-raven-6.10.0-1.src.rpm
checksum_type: sha256
description:
  Raven is a Python client for `Sentry <http://getsentry.com/>`_. It provides
  full out-of-the-box support for many of the popular frameworks, including
  `Django <djangoproject.com>`_, `Flask <http://flask.pocoo.org/>`_, and `Pylons
  <http://www.pylonsproject.org/>`_. Raven also includes drop-in support for any
  `WSGI <https://wsgi.readthedocs.io/>`_-compatible web application.


pkgId: 1df7d88c1d67f6a9939eac55901cb699084e48c3c1f344f77016090d4bfd64e2
name: python-rawkit
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: CTypes based LibRaw bindings
url: https://rawkit.readthedocs.org
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0806102c-f5f4-4286-97b5-b6580f5eaf87
location_href: 00004931-python-rawkit/python-rawkit-0.6.0-1.src.rpm
checksum_type: sha256
description:
  ``rawkit`` (pronounced `rocket`) is a ctypes-based LibRaw_ binding for
  Python inspired by the Wand_ API.
      from rawkit.raw import Raw
      from rawkit.options import WhiteBalance
      with Raw(filename='some/raw/image.CR2') as raw:
        raw.options.white_balance = WhiteBalance(camera=False, auto=True)
        raw.save(filename='some/destination/image.ppm')
  for more info, see the docs_


pkgId: aab1162798a6fdfd53cf29e024825809f4b257591a05e3d99fb80c6fc4e0c942
name: python-rdopkg
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: RPM packaging automation tool
url: https://github.com/softwarefactory-project/rdopkg
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cbd11fcd-a17a-4b64-b69c-c8a88f740b53
location_href: 00004935-python-rdopkg/python-rdopkg-1.5.1-1.src.rpm
checksum_type: sha256
description:
  `rdopkg` is an RPM packaging automation tool. It provides automation for
  package maintenance including git-based patches management and automagic
  rebases to new upstream versions with nice .spec changes, changelogs and
  commit messages for both CLI and CI usage.
  It also contains various functionality we needed for
  [RDO](https://www.rdoproject.org/) packaging, such as advanced
  `requirements.txt` management for python projects and
  [rdoinfo](https://github.com/redhat-openstack/rdoinfo) integration.

  Generic
  [distgit](https://www.rdoproject.org/documentation/intro-packaging/#distgit---where-the-spec-file-lives)
  and patches management functionality and conventions provided by `rdopkg`
  proved to be efficient way of packaging fast-moving upstream projects with
  minimal human effort but without losing control over individual packages.

  `rdopkg` is now considered **stable**. It was originally developed to serve
  the needs of the mighty [RDO](https://www.rdoproject.org/) packager-warriors
  and their weapons such as
  [DLRN](https://github.com/softwarefactory-project/DLRN), but it can help with
  any RPM package. For example, see [how you can manage your RPMs with
  rdopkg](https://www.rdoproject.org//blog/2017/03/let-rdopkg-manage-your-RPM-package/).

  `rdopkg` uses [software factory](https://softwarefactory-project.io/)
  for CI and every commit goes through automatic unit, feature, and integration
  testing as well as human reviews.

  See [open rdopkg reviews](https://softwarefactory-project.io/r/#/q/status:open+project:rdopkg).




  `rdopkg` is currently compatible with both python 3 and python 2.




  `rdopkg` is available on **Fedora 25** and newer:

      dnf install rdopkg

  On CentOS/RHEL 7, `rdopkg` is available from
  [EPEL](https://fedoraproject.org/wiki/EPEL).

  On **CentOS 7**:

      yum install epel-release
      yum install rdopkg

  On **RHEL 7**:

      yum install https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
      yum install rdopkg




  If you want to hack `rdopkg` or just have the latest fixes without waiting for
  next release, I suggest using the git repo directly:

      git clone https://github.com/softwarefactory-project/rdopkg
      cd rdopkg
      python setup.py develop --user

  You may set the preference over `rdopkg` RPM by correctly positioning
  `~/.local/bin/rdopkg` in your `$PATH`.

  Or you can use virtualenv to avoid conflicts with RPM:

      git clone https://github.com/softwarefactory-project/rdopkg
      cd rdopkg
      virtualenv --system-site-packages ~/rdopkg-venv
      source ~/rdopkg-venv/bin/activate
      python setup.py develop
      ln `which rdopkg` ~/bin/rdopkg-dev

      rdopkg-dev --version

  Required python modules are listed in
  [requirements.txt](requirements.txt) and also in
  [rdopkg.spec](https://src.fedoraproject.org/rpms/rdopkg/blob/master/f/rdopkg.spec) as
  RPM Requires.




  For your convenience, `rdopkg` is also available from the Cheese
  Shop. This should come in handy especially if you want to reuse `rdopkg` as
  a module.

      pip install rdopkg

  Note that you need to have python2-rpm(resp. python3-rpm) package installed in
  order for RPM macro related featuers to work as it isn't available from
  PyPI.




  Exhaustive `rdopkg` manual is available, you can:

   * read it nicely rendered on github: [rdopkg manual](https://github.com/softwarefactory-project/rdopkg/blob/master/doc/rdopkg.1.adoc)
   * run `man rdopkg` if you installed from RPM
   * render it to HTML/man using `make doc`

  You might also be interested in
  [RDO packaging intro](https://www.rdoproject.org/documentation/intro-packaging/)
  which contains some examples of `rdopkg` usage and more.




  Please use the
  [github Issues](https://github.com/softwarefactory-project/rdopkg/issues)
  to report bugs. I usually fix critical bugs within days.


