# packages

pkgId: 22fa4e85efc1e265172dd2bfab516a1c82315421b648fbbfe39405a8cc66a1df
name: python-pyotp
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: Python One Time Password Library
url: https://github.com/pyotp/pyotp
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9db603de-8990-42ad-8de1-c0aee1ec714e
location_href: 00004759-python-pyotp/python-pyotp-2.8.0-1.src.rpm
checksum_type: sha256
description:
  PyOTP is a Python library for generating and verifying one-time passwords. It can be used to implement two-factor (2FA)
  or multi-factor (MFA) authentication methods in web applications and in other systems that require users to log in.
  Open MFA standards are defined in `RFC 4226 <https://tools.ietf.org/html/rfc4226>`_ (HOTP: An HMAC-Based One-Time
  Password Algorithm) and in `RFC 6238 <https://tools.ietf.org/html/rfc6238>`_ (TOTP: Time-Based One-Time Password
  Algorithm). PyOTP implements server-side support for both of these standards. Client-side support can be enabled by
  sending authentication codes to users over SMS or email (HOTP) or, for TOTP, by instructing users to use `Google
  Authenticator <https://en.wikipedia.org/wiki/Google_Authenticator>`_, `Authy <https://www.authy.com/>`_, or another
  compatible app. Users can set up auth tokens in their apps easily by using their phone camera to scan `otpauth://
  <https://github.com/google/google-authenticator/wiki/Key-Uri-Format>`_ QR codes provided by PyOTP.
  Implementers should read and follow the `HOTP security requirements <https://tools.ietf.org/html/rfc4226#section-7>`_
  and `TOTP security considerations <https://tools.ietf.org/html/rfc6238#section-5>`_ sections of the relevant RFCs. At
  minimum, application implementers should follow this checklist:
  - Ensure transport confidentiality by using HTTPS
  - Ensure HOTP/TOTP secret confidentiality by storing secrets in a controlled access database
  - Deny replay attacks by rejecting one-time passwords that have been used by the client (this requires storing the most
    recently authenticated timestamp, OTP, or hash of the OTP in your database, and rejecting the OTP when a match is seen)
  - Throttle (rate limit) brute-force attacks against your application's login functionality (see RFC 4226, section 7.3)
  - When implementing a "greenfield" application, consider supporting
    `FIDO U2F <https://en.wikipedia.org/wiki/Universal_2nd_Factor>`_/`WebAuthn <https://www.w3.org/TR/webauthn/>`_ in
    addition to HOTP/TOTP. U2F uses asymmetric cryptography to avoid using a shared secret design, which strengthens your
    MFA solution against server-side attacks. Hardware U2F also sequesters the client secret in a dedicated single-purpose
    device, which strengthens your clients against client-side attacks. And by automating scoping of credentials to
    relying party IDs (application origin/domain names), U2F adds protection against phishing attacks. One implementation of
    FIDO U2F/WebAuthn is PyOTP's sister project, `PyWARP <https://github.com/pyauth/pywarp>`_.
  We also recommend that implementers read the
  `OWASP Authentication Cheat Sheet <https://github.com/OWASP/CheatSheetSeries/blob/master/cheatsheets/Authentication_Cheat_Sheet.md>`_ and
  `NIST SP 800-63-3: Digital Authentication Guideline <https://pages.nist.gov/800-63-3/>`_ for a high level overview of
  authentication best practices.


pkgId: ddbb357663b47da765b22ab9bb0f02cb30a988bb7abc94e7cd4e1a06dfb361f3
name: python-pyowm
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: A Python wrapper around OpenWeatherMap web APIs
url: https://github.com/csparpa/pyowm
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eee380c2-286c-4136-ba8a-3cf5b490bcd8
location_href: 00004760-python-pyowm/python-pyowm-3.3.0-1.src.rpm
checksum_type: sha256
description:
  [![logo](logos/180x180.png)](https://github.com/csparpa)


  **A Python wrapper around OpenWeatherMap web APIs**

  [![PyPI version](https://badge.fury.io/py/pyowm.svg)](https://badge.fury.io/py/pyowm)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/pyowm.svg)](https://img.shields.io/pypi/dm/pyowm.svg)
  <br>
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyowm.svg)](https://img.shields.io/pypi/pyversions/pyowm.svg)
  <br>
  [![Latest Release Documentation](https://readthedocs.org/projects/pyowm/badge/?version=latest)](https://pyowm.readthedocs.io/en/latest/)
  [![Build Status](https://travis-ci.org/csparpa/pyowm.png?branch=develop)](https://travis-ci.org/csparpa/pyowm)
  [![Coverage Status](https://coveralls.io/repos/github/csparpa/pyowm/badge.svg?branch=develop)](https://coveralls.io/github/csparpa/pyowm?branch=master)
  <br>
  <a href="https://www.buymeacoffee.com/LmAl1n9" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/black_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>
  [![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/csparpa%40gmail.com)


  PyOWM is a client Python wrapper library for OpenWeatherMap (OWM) web APIs. It allows quick and easy consumption of OWM data from Python applications via a simple object model and in a human-friendly fashion.

  PyOWM runs on Python 3.7+

  **Former Dark Sky API users**: you can can use PyOWM to get [OpenWeatherMap's OneCall API](https://openweathermap.org/api/one-call-api) data as an easy replacement to Dark Sky


  With PyOWM you can integrate into your code any of the following OpenWeatherMap web APIs:

   - **Weather API v2.5** + **OneCall API**, providing current weather data, weather forecasts, weather history
   - **Agro API v1.0**, providing soil data and satellite imagery search and download
   - **Air Pollution API v3.0**, providing data about CO, O3, NO2 and SO2
   - **UV Index API v3.0**, providing data about Ultraviolet exposition
   - **Stations API v3.0**, allowing to create and manage meteostation and publish local weather measurements
   - **Weather Alerts API v3.0**, allowing to set triggers on weather conditions and areas and poll for spawned alerts
   - **Image tiles** for several map layers provided by OWM
   - **Geocoding API v1.0** allowing to perform direct/reverse geocoding



  Please **read the [FAQ](https://pyowm.readthedocs.io/en/latest/v3/faq.html)** before filing a new issue on GitHub! There are many common issues, therefore a fix for your issue might come easier than you think

   



  As OpenWeatherMap APIs need a valid API key to allow responses, *PyOWM won't work if you don't provide one*. This stands for both free and paid (pro) subscription plans.
  You can signup for a free API key [on the OWM website](https://home.openweathermap.org/users/sign_up)
  Please notice that the free API subscription plan is subject to requests throttling.



  With a free OWM API Key:

  ```python
  from pyowm import OWM
  from pyowm.utils import config
  from pyowm.utils import timestamps



  owm = OWM('your free OWM API key')
  mgr = owm.weather_manager()



  observation = mgr.weather_at_place('London,GB')
  w = observation.weather

  w.detailed_status         # 'clouds'
  w.wind()                  # {'speed': 4.6, 'deg': 330}
  w.humidity                # 87
  w.temperature('celsius')  # {'temp_max': 10.5, 'temp': 9.7, 'temp_min': 9.0}
  w.rain                    # {}
  w.heat_index              # None
  w.clouds                  # 75


  forecast = mgr.forecast_at_place('Milan,IT', 'daily')
  answer = forecast.will_be_clear_at(timestamps.tomorrow())



  config_dict = config.get_default_config_for_subscription_type('professional')
  owm = OWM('your paid OWM API key', config_dict)


  one_call_object = mgr.one_call(lat=52.5244, lon=13.4105)
  one_call_object.current.humidity
  ```



  Install with `pip` for your ease:

  ```shell
  $ pip install pyowm
  ```

  There are alternatives: _setuptools_, _Windows installers_ and common Linux package managers such as _Yaourt (Arch Linux)_
  _YaST/Zypper (OpenSuse)_ (please refer to the documentation for more detail)

  Eager to fetch the very latest updates to PyOWM? Install the development trunk (which might be unstable). Eg on Linux:

  ```shell
  $ git clone https://github.com/csparpa/pyowm.git
  $ cd pyowm && git checkout develop
  $ pip install -r requirements.txt && python setup.py install
  ```


  The library software API documentation is available on [Read the Docs](https://pyowm.readthedocs.io/en/latest/).

  The [Code recipes](https://pyowm.readthedocs.io/en/latest/v3/code-recipes.html) section comes in handy!




  Here are [some cool projects](https://github.com/csparpa/pyowm/wiki/Community-Projects-using-PyOWM) that use PyOWM

  Join the **[PyOWM public Slack team](https://pyowm.slack.com)** by signing up [here](http://pyowm-slackin.herokuapp.com/)

  _Contributors (coding, testing, packaging, reporting issues) are welcome!_ See the [the official documentation website](https://pyowm.readthedocs.io/) for details or the [CONTRIBUTING.md](https://github.com/csparpa/pyowm/blob/master/CONTRIBUTING.md) file for a quick primer.



  [MIT license](https://github.com/csparpa/pyowm/blob/master/LICENSE)


pkgId: 1d4e5f749ea1dd6c137540554f57e8f1e4ac48430ed6a6015b5d06d75c12f718
name: python-pypandoc
arch: src
version: 1.11
epoch: 0
release: 1
summary: Thin wrapper for pandoc.
url: https://github.com/JessicaTegner/pypandoc
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb3a45b8-5f60-4157-bde1-ce011c281828
location_href: 00004761-python-pypandoc/python-pypandoc-1.11-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/JessicaTegner/pypandoc/actions/workflows/ci.yaml/badge.svg)](https://github.com/JessicaTegner/pypandoc/actions/workflows/ci.yaml)
  [![GitHub Releases](https://img.shields.io/github/tag/JessicaTegner/pypandoc.svg)](https://github.com/JessicaTegner/pypandoc/releases)
  [![Pypandoc PyPI Version](https://img.shields.io/pypi/v/pypandoc?label=pypandoc+pypi+version)](https://pypi.org/project/pypandoc/)
  [![Pypandoc Binary PyPI Version](https://img.shields.io/pypi/v/pypandoc_binary?label=pypandoc+binary+pypi+version)](https://pypi.org/project/pypandoc_binary/)
  ![PyPandoc PyPi Downloads](https://img.shields.io/pypi/dm/pypandoc)
  ![PyPandoc Binary PyPI Downloads](https://img.shields.io/pypi/dm/pypandoc_binary)
  [![conda version](https://anaconda.org/conda-forge/pypandoc/badges/version.svg)](https://anaconda.org/conda-forge/pypandoc/)
  [![Development Status](https://img.shields.io/pypi/status/pypandoc.svg)](https://pypi.python.org/pypi/pypandoc/)
  [![PyPandoc Python version](https://img.shields.io/pypi/pyversions/pypandoc.svg)](https://pypi.python.org/pypi/pypandoc/)
  [![PyPandoc Binary Python version](https://img.shields.io/pypi/pyversions/pypandoc_binary.svg)](https://pypi.python.org/pypi/pypandoc_binary/)
  ![License](https://img.shields.io/pypi/l/pypandoc.svg)

  Pypandoc provides a thin wrapper for [pandoc](https://pandoc.org), a universal
  document converter.



  Pypandoc uses pandoc, so it needs an available installation of pandoc. Pypandoc provides 2 packages, "pypandoc" and "pypandoc_binary", with the second one including pandoc out of the box.
  The 2 packages are identical, with the only difference being that one includes pandoc, while the other don't.

  If pandoc is already installed (i.e. pandoc is in the `PATH`), pypandoc uses the version with the
  higher version number, and if both are the same, the already installed version. See [Specifying the location of pandoc binaries](#specifying-the-location-of-pandoc-binaries) for more.

  To use pandoc filters, you must have the relevant filters installed on your machine.



  If you [want to install pandoc yourself](#Installing-pandoc) or are on a unsupported platform, you'll need to install "pypandoc" and  [install pandoc manually](#Installing-pandoc)

  ```
  pip install pypandoc
  ```


  If you want pandoc included out of the box, you can utilize our pypandoc_binary package, which are identical to the "pypandoc" package, but with pandoc included.

  ```
  pip install pypandoc_binary
  ```

  Prebuilt [wheels for Windows and Mac OS X](https://pypi.python.org/pypi/pypandoc_binary/)

  If you use Linux and have [your own wheelhouse](https://wheel.readthedocs.org/en/latest/#usage),
  you can build a wheel which include pandoc with
  `python setup_binary.py download_pandoc; python setup.py bdist_wheel`. Be aware that this works only
  on 64bit intel systems, as we only download it from the
  [official releases](https://github.com/jgm/pandoc/releases).



  Pypandoc is included in [conda-forge](https://conda-forge.github.io/). The conda packages will
  also install the pandoc package, so pandoc is available in the installation.

  Install via `conda install -c conda-forge pypandoc`.

  You can also add the channel to your conda config via
  `conda config --add channels conda-forge`. This makes it possible to
  use `conda install pypandoc` directly and also lets you update via `conda update pypandoc`.



  If you don't already have pandoc on your system, or have installed the pypandoc_binary package, which includes pandoc, you need to install pandoc by yourself.



  Installing via pypandoc is possible on Windows, Mac OS X or Linux (Intel-based, 64-bit):

  ```python
  pip install pypandoc
  from pypandoc.pandoc_download import download_pandoc


  download_pandoc()
  ```

  The default install location is included in the search path for pandoc, so you
  don't need to add it to the `PATH`.

  By default, the latest pandoc version is installed. If you want to specify your own version, say 1.19.1, use `download_pandoc(version='1.19.1')` instead.



  Installing manually via the system mechanism is also possible. Such installation mechanism
  make pandoc available on many more platforms:

  - Ubuntu/Debian: `sudo apt-get install pandoc`
  - Fedora/Red Hat: `sudo yum install pandoc`
  - Arch: `sudo pacman -S pandoc`
  - Mac OS X with Homebrew: `brew install pandoc pandoc-citeproc Caskroom/cask/mactex`
  - Machine with Haskell: `cabal-install pandoc`
  - Windows: There is an installer available
    [here](https://pandoc.org/installing.html)
  - [FreeBSD with pkg:](https://www.freshports.org/textproc/hs-pandoc/) `pkg install hs-pandoc`
  - Or see [Pandoc - Installing pandoc](https://pandoc.org/installing.html)

  Be aware that not all install mechanisms put pandoc in the `PATH`, so you either
  have to change the `PATH` yourself or set the full `PATH` to pandoc in
  `PYPANDOC_PANDOC`. See the next section for more information.



  You can point to a specific pandoc version by setting the environment variable
  `PYPANDOC_PANDOC` to the full `PATH` to the pandoc binary
  (`PYPANDOC_PANDOC=/home/x/whatever/pandoc` or `PYPANDOC_PANDOC=c:\pandoc\pandoc.exe`).
  If this environment variable is set, this is the only place where pandoc is searched for.

  In certain cases, e.g. pandoc is installed but a web server with its own user
  cannot find the binaries, it is useful to specify the location at runtime:

  ```python
  import os
  os.environ.setdefault('PYPANDOC_PANDOC', '/home/x/whatever/pandoc')
  ```



  There are two basic ways to use pypandoc: with input files or with input
  strings.


  ```python
  import pypandoc


  output = pypandoc.convert_file('somefile.md', 'rst')


  output = pypandoc.convert_file('somefile.txt', 'rst', format='md')



  output = pypandoc.convert_text('# some title', 'rst', format='md')

  ```

  `convert_text` expects this string to be unicode or utf-8 encoded bytes. `convert_*` will always
  return a unicode string.

  It's also possible to directly let pandoc write the output to a file. This is the only way to
  convert to some output formats (e.g. odt, docx, epub, epub3, pdf). In that case `convert_*()` will
  return an empty string.

  ```python
  import pypandoc

  output = pypandoc.convert_file('somefile.md', 'docx', outputfile="somefile.docx")
  assert output == ""
  ```


  It's also possible to specify multiple input files to pandoc, either as absolute paths, relative paths or file patterns.

  ```python
  import pypandoc


  pypandoc.convert_file('chapters/*.md', 'docx', outputfile="somefile.docx")


  pypandoc.convert_file(['book1/*.md', 'book2/*.md'], 'docx', outputfile="somefile.docx")


  pypandoc.convert_file(['D:/book_front.md', 'book2/*.md'], 'docx', outputfile="somefile.docx")
  ```


  pathlib is also supported.

  ```python
  import pypandoc
  from pathlib import Path


  input = Path('somefile.md')
  output = input.with_suffix('.docx')
  pypandoc.convert_file(input, 'docx', outputfile=output)


  pypandoc.convert_file(Path('chapters').glob('*.md'), 'docx', outputfile="somefile.docx")


  pypandoc.convert_file([*Path('book1').glob('*.md'), *Path('book2').glob('*.md')], 'docx', outputfile="somefile.docx")

  ```

  In addition to `format`, it is possible to pass `extra_args`.
  That makes it possible to access various pandoc options easily.

  ```python
  output = pypandoc.convert_text(
      '<h1>Primary Heading</h1>',
      'md', format='html',
      extra_args=['--atx-headers'])

  output = pypandoc.convert_text(
      '# Primary Heading',
      'html', format='md',
      extra_args=['--base-header-level=2'])

  ```

  pypandoc now supports easy addition of
  [pandoc filters](https://pandoc.org/scripting.html).

  ```python
  filters = ['pandoc-citeproc']
  pdoc_args = ['--mathjax',
               '--smart']
  output = pypandoc.convert_file(filename,
                                 to='html5',
                                 format='md',
                                 extra_args=pdoc_args,
                                 filters=filters)
  ```

  Please pass any filters in as a list and not as a string.

  Please refer to `pandoc -h` and the
  [official documentation](https://pandoc.org/MANUAL.html) for further details.



  Pandoc supports custom formatting though `-V` parameter. In order to use it through
  pypandoc, use code such as this:

  ```python
  output = pypandoc.convert_file('demo.md', 'pdf', outputfile='demo.pdf',
    extra_args=['-V', 'geometry:margin=1.5cm'])
  ```

  > Note: it's important to separate `-V` and its argument within a list like that or else
  it won't work. This gotcha has to do with the way
  [`subprocess.Popen`](https://docs.python.org/2/library/subprocess.html#subprocess.Popen) works.



  Pypandoc logs messages using the [Python logging library](https://docs.python.org/3/library/logging.html).
  By default, it will send messages to the console, including any messages
  generated by Pandoc. If desired, this behaviour can be changed by adding
  [handlers](https://docs.python.org/3/library/logging.html#handler-objects) to
  the pypandoc logger **before calling any functions**. For example, to mute all
  logging add a [null handler](https://docs.python.org/3/library/logging.handlers.html#nullhandler):

  ```python
  import logging
  logging.getLogger('pypandoc').addHandler(logging.NullHandler())
  ```



  As it can be useful sometimes to check what pandoc version is available at your system or which
  particular pandoc binary is used by pypandoc. For that, pypandoc provides the following
  utility functions. Example:

  ```
  print(pypandoc.get_pandoc_version())
  print(pypandoc.get_pandoc_path())
  print(pypandoc.get_pandoc_formats())
  ```



  * [pydocverter](https://github.com/msabramo/pydocverter) is a client for a service called
  [Docverter](https://www.docverter.com), which offers pandoc as a service (plus some extra goodies).
  * See [pyandoc](https://pypi.python.org/pypi/pyandoc/) for an alternative implementation of a pandoc
  wrapper from Kenneth Reitz. This one hasn't been active in a while though.
  * See [panflute](https://github.com/sergiocorreia/panflute) which provides `convert_text` similar to pypandoc's. Its focus is on writing and running pandoc filters though.



  Contributions are welcome. When opening a PR, please keep the following guidelines in mind:

  1. Before implementing, please open an issue for discussion.
  2. Make sure you have tests for the new logic.
  3. Make sure your code passes `flake8 pypandoc/*.py tests.py`
  4. Add yourself to contributors at `README.md` unless you are already there. In that case tweak your contributions.

  Note that for citeproc tests to pass you'll need to have [pandoc-citeproc](https://github.com/jgm/pandoc-citeproc) installed. If you installed a prebuilt wheel or conda package, it is already included.



  * [Jessica Tegner](https://github.com/JessicaTegner) - New maintainer as of 1. Juli 2021
  * [Valentin Haenel](https://github.com/esc) - String conversion fix
  * [Daniel Sanchez](https://github.com/ErunamoJAZZ) - Automatic parsing of input/output formats
  * [Thomas G.](https://github.com/coldfix) - Python 3 support
  * [Ben Jao Ming](https://github.com/benjaoming) - Fail gracefully if pandoc is missing
  * [Ross Crawford-d'Heureuse](https://github.com/rosscdh) - Encode input in UTF-8 and add Django
    example
  * [Michael Chow](https://github.com/machow) - Decode output in UTF-8
  * [Janusz Skonieczny](https://github.com/wooyek) - Support Windows newlines and allow encoding to
    be specified.
  * [gabeos](https://github.com/gabeos) - Fix help parsing
  * [Marc Abramowitz](https://github.com/msabramo) - Make `setup.py` fail hard if pandoc is
    missing, Travis, Dockerfile, PyPI badge, Tox, PEP-8, improved documentation
  * [Daniel L.](https://github.com/mcktrtl) - Add `extra_args` example to README
  * [Amy Guy](https://github.com/rhiaro) - Exception handling for unicode errors
  * [Florian Eßer](https://github.com/flesser) - Allow Markdown extensions in output format
  * [Philipp Wendler](https://github.com/PhilippWendler) - Allow Markdown extensions in input format
  * [Jan Katins](https://github.com/jankatins) - Handling output to a file, Travis to work on newer version of pandoc, return code checking, get_pandoc_version. Helped to fix the Travis build, new `convert_*` API. Former maintainer of pypandoc
  * [Aaron Gonzales](https://github.com/xysmas) - Added better filter handling
  * [David Lukes](https://github.com/dlukes) - Enabled input from non-plain-text files and made sure tests clean up template files correctly if they fail
  * [valholl](https://github.com/valholl) - Set up licensing information correctly and include examples to distribution version
  * [Cyrille Rossant](https://github.com/rossant) - Fixed bug by trimming out stars in the list of pandoc formats. Helped to fix the Travis build.
  * [Paul Osborne](https://github.com/posborne) - Don't require pandoc to install pypandoc.
  * [Felix Yan](https://github.com/felixonmars) - Added installation instructions for Arch Linux.
  * [Kolen Cheung](https://github.com/ickc) - Implement `_get_pandoc_urls` for installing arbitrary version as well as the latest version of pandoc. Minor: README, Travis, setup.py.
  * [Rebecca Heineman](https://github.com/burgerbecky) - Added scanning code for finding pandoc in Windows
  * [Andrew Barraford](https://github.com/abarrafo) - Download destination.
  * [Jesse Widner](https://github.com/jwidner) & [Dominic Thorn](https://github.com/domvwt) - Add support for lua filters
  * [Alex Kneisel](https://github.com/hey-thanks/) - Added pathlib.Path support to convert_file.
  * [Juho Vepsäläinen](https://github.com/bebraw/) - Creator and former maintainer of pypandoc




  Pypandoc is available under MIT license. See LICENSE for more details. Pandoc itself is [available under the GPL2 license](https://github.com/jgm/pandoc/blob/master/COPYING.md).


pkgId: a5560d0d7b5cbd903efe61121edb8880184b6e7a9f95a54d4c000665679d8d5f
name: python-pypcapkit
arch: src
version: 0.16.3
epoch: 0
release: 1
summary: Python multi-engine PCAP analyse kit.
url: https://github.com/JarryShaw/PyPCAPKit
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dff42efe-e479-4324-bdae-b7d57bff2fbc
location_href: 00004762-python-pypcapkit/python-pypcapkit-0.16.3-1.src.rpm
checksum_type: sha256
description:
     For any technical and/or maintenance information,
     please kindly refer to the |docs|_.
  The PyPCAPKit project is an open source Python program focus
  on `PCAP`_ parsing and analysis, which works as a stream PCAP file extractor.
  With support of `DictDumper`_, it shall support multiple
  output report formats.


pkgId: b57f098cf2dd78c3df7b412f97f811b26d7a32d531f22ebf7d2629bc98e11d6f
name: python-pyperclip
arch: src
version: 1.8.2
epoch: 0
release: 1
summary: A cross-platform clipboard module for Python. (Only handles plain text for now.)
url: https://github.com/asweigart/pyperclip
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-755aa5af-49ef-4692-b7a5-5f61a76d0c4b
location_href: 00004763-python-pyperclip/python-pyperclip-1.8.2-1.src.rpm
checksum_type: sha256
description:
      >>> import pyperclip
      >>> pyperclip.copy('The text to be copied to the clipboard.')
      >>> pyperclip.paste()
      'The text to be copied to the clipboard.'
  Currently only handles plaintext.
  On Windows, no additional modules are needed.
  On Mac, this module makes use of the pbcopy and pbpaste commands, which should come with the os.
  On Linux, this module makes use of the xclip or xsel commands, which should come with the os. Otherwise run "sudo apt-get install xclip" or "sudo apt-get install xsel" (Note: xsel does not always seem to work.)
  Otherwise on Linux, you will need the gtk or PyQt4 modules installed.


pkgId: 7f5c210522583a651b4192eb6c55fb3c262100bf7a3b5b7f52358e162c9138d5
name: python-pyphi
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Python library for computing integrated information.
url: http://github.com/wmayner/pyphi
rpm_license: GNU General Public License v3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fdc5089-a5b4-4524-9419-e78bbe8847a7
location_href: 00004766-python-pyphi/python-pyphi-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Mayner WGP, Marshall W, Albantakis L, Findlay G, Marchman R, Tononi G. (2018)
  [PyPhi: A toolbox for integrated information
  theory](https://doi.org/10.1371/journal.pcbi.1006343). PLOS Computational


pkgId: 6f690554d55d489076d06024797fe85474efc14c78664b48c0819820f6d2dbd5
name: python-pypillowfight
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Library containing various image processing algorithms
url: https://gitlab.gnome.org/World/OpenPaperwork/libpillowfight#readme
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ebdb48fe-6c82-48d6-a3ed-353e473b2912
location_href: 00004767-python-pypillowfight/python-pypillowfight-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Library containing various image processing algorithms: Automatic Color Equalization, Unpaper's algorithms, Stroke Width Transformation, etc


pkgId: 367a4c6955f9da0378476dd3cfc4adef4221fa85b2893ca5d0446012137e6800
name: python-pypng
arch: src
version: 0.20220715.0
epoch: 0
release: 1
summary: Pure Python library for saving and loading PNG images
url: https://gitlab.com/drj11/pypng
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-43a54d89-c9fe-433b-96d3-1096c2d6816f
location_href: 00004768-python-pypng/python-pypng-0.20220715.0-1.src.rpm
checksum_type: sha256
description:
  drj@pobox.com




  PNG module for Python. PyPNG is written entirely in Python.

  - PyPNG home page: https://gitlab.com/drj11/pypng/
  - PyPNG Documentation: https://pypng.readthedocs.io/en/latest/
  - PyPNG mailing list: https://groups.google.com/forum/#!forum/pypng-users




      import png
      png.from_array([[255, 0, 0, 255],
                      [0, 255, 255, 0]], 'L').save("small_smiley.png")

  After that, try `import png` then `help(png)`.
  Also, lickable HTML documentation appears in the `html/` directory.
  If HTML is no good then you could try the ReST sources
  in the `man/` directory.




  PyPNG is pure Python and has no dependencies.
  It requires Python 3.5 or any compatible higher version.

  To install PyPNG package via pip use:

      python -m pip install git+https://gitlab.com/drj11/pypng@pypng-0.20220715.0

  After install use

      `import png`

  to access the `png` module in your Python program.

  You can also install from source using `setuptools`.
  PyPNG uses `setup.cfg` and `pyproject.toml` to record its
  configuration.

  To install from (version controlled) sources using a suitable
  version of `pip`:

  `cd` into the directory and execute the command:

      python -m pip install .

  PyPNG is so simple, that you don't need installation tools.
  You can copy `code/png.py` wherever you like.
  It's intended that you can copy `png.py` into
  your application and distribute it.
  The following `curl` command should copy the latest version into
  your current directory:

      curl -LO https://gitlab.com/drj11/pypng/-/raw/main/code/png.py




  (For issues see https://gitlab.com/drj11/pypng/-/issues/ )






  Development moved to gitlab: https://gitlab.com/drj11/pypng

  If you pass an empty file to PyPNG
  it now raises the builtin Python exception `EOFError`.
  This should make it easier to diagnose _empty file_ problems separately
  from genuine format errors
  (which use `png.FormatError`).
  This is a slightly breaking change to the API.

  New `prirowpng` tool to join PNG images in a row left-to-right
  (old internal `pipcat` tool).

  New `pricolpng` tool to join PNG images in a column top-to-bottom.

  Support for plain PGM files (magic number P2) added to `pripamtopng`.

  New `priplan9topng` tool to convert from Plan 9 image format to PNG.
  In reality this has been lurking in the codebase for years, but
  has recently been converted to Python 3.
  The author has only a limited collection of Plan 9 images,
  which limits the testing that can be done.
  The author welcomes bug reports for Plan 9 images.

  The `priplan9topng` tool has an even more experimental option
  `--font` which converts Plan 9 subfont files to a sequence of
  PNG files.




  Support for Python 2 is dropped.
  Python 3.5 and onwards are supported.
  Some of the ancillary tools are modified to work on Python 3.

  Installs via wheel files.

  `prichunkpng` command line tool now has some new options to add
  chunks:
  - `--iccprofile` to add a `iCCP` chunk (ICC Profile);
  - `--physical` to add a `pHYs` chunk,
    specifying the intended pixel size;
  - `--sigbit` to add a `sBIT` chunk,
    specifying the encoded significant bits;
  - `--transparent` to add a `tRNS` chunk,
    specifying the transparent colour.

  `priditherpng` command line tool standardised and
  converted to Python 3.

  `pripngtopam` tool now has a `--plain` option to output plain PGM
  and PPM formats. The `topam` part of the name is a bit of a
  misnomer: when possible (L and RGB PNG files) the tool will
  output either a PGM (grey) or a PPM (RGB) file. Essentially all
  tools that can process a PAM file can also process a PGM or a
  PPM file. PAM files cannot be _plain_ so using the option
  will raise an error in the case where a true PAM file is
  written.

  Better error messages when you write the wrong number of rows.

  (Slightly experimentally) running the `png` module as a command
  line tool, with `python -m png`, will report the version and
  file location of the `png` module.




  Support for earlier versions of Python is dropped.
  Python 3.4 and onwards are supported.
  Python 2.7 also works, but this is the last
  release to support any version of Python 2.

  Cython code is removed, which simplifies the implementation.

  Removed the (optional) dependency `setuptools`.

  Changed the default for `png.Writer` to be greyscale.

  Removed 3D support from `.from_array()`.




  Support for earlier versions of Python is dropped in order to
  simplify the code.
  From the Python 3.x series all versions from 3.2 onward are supported.
  From the 2.x series only Python 2.6 and 2.7 are supported.

  Code cleaned.
  Tests renamed and more organised.
  Generally Flake 8 compliant.
  Fewer special cases for ancient versions of Python.

  The row length is checked when writing PNG files.
  Previously it was possible to write badly formed PNG files
  by passing in rows of the wrong length.

  `pHYS` chunk is now processed.

  The `Writer()` interface now supports source pixels
  that have a different bitdepth for each channel.
  To exploit this, pass in a tuple for the bitdepth argument.

  Ancillary tools regularised and simplified.

  `pripamtopng` command line tool converts NetPBM PNM/PAM files to PNG.
  Previously `png.py` did this.
  Note that only one input file is converted,
  if you have intensity and opacity in separate files,
  you have two options:
  either use `pamstack` to convert them into a single PAM file and
  convert that, or
  convert each file to PNG, then use `priweavepng` to weave them together.
  Both will work.

  `pripngtopam` command line tool converts PNG to NetPBM PNM/PAM file.
  Previously `png.py` did this.

  `python -m pngsuite` is now a command line tool to
  write various images from the PNG suite of test images.
  Previously this was possible using `gen`.

  `priweavepng` command line tool performs channel extraction across
  multiple images.
  This is a more general version of `pipstack` (which has been removed),
  and is inspired by `pamstack` from NetPBM.

  The `--interlace` option available on many previous tools is
  now only available on `priweavepng`,
  making it the preferred tool for generating interlaced PNGs.

  `prichunkpng` command line tool adds and deletes chunks and
  "intelligently" knows about transparent, gamma, background chunks.
  It is the preferred tool for adding those chunks,
  which was previously possible using various options of other tools.

  `gen` has been renamed to `priforgepng`.

  `priforgepng` uses centre pixel sampling, which means that a 256 pixel
  wide 8-bit gradient takes on all possible 256 values.
  It also improves output for very small images.

  `priforgepng` uses `Fraction` for internal maths meaning that
  the stripe patterns are accurate and do not have loose pixels.

  `priforgepng` only outputs greyscale PNG files
  (but see next item for a feature to generate colour PNGs).

  `priforgepng` can output multiple PNGs onto the same stream.
  This aligns well with a feature of `priweavepng` which
  accepts multiple PNGs from stdin.
  LA, RGB, and RGBA test images can be generated by
  piping `priforgepng` into `priweavepng`:
  `priforgepng RTL RTR RBR | priweavepng - - -`
  will generate an RGB PNG.




  Thanks to `github.com/sean-duffy`,
  `.from_array()` can now take a 3D array.

  Converting to PNMs was broken in Python 3; this is now fixed.
  Issue 26: https://gitlab.com/drj11/pypng/-/issues/26




  Various fixes when running on Python 3 and Windows.
  Merging pull requests from `github.com/ironfroggy` and
  `github.com/techtonik`,
  and merging by hand a commit from `github.com/Scondo`.




  Compatible with nose: `nosetests png.py` now works.

  Allow any "file-like" object as an input.

  Handle newlines in `texttopng`.




  Fixed various URLs to point at github.com instead of googlecode.




  When using `png.py` as a command line tool,
  it can now produce non-square test images.

  PyPNG now installs "out of the box" on Python 3 on a plain install
  (previously `distribute` or `pip` was required).

  PyPNG welcomes the following community contributions:

    Joaquín Cuenca Abela speeds up PNG reading when Cython is available.

    Josh Bleecher Snyder adds a lenient mode
    which has relaxed checksum checking.

    nathan@dunfield.info fixed a problem writing files
    when using the command line tool on Windows (Issue 62).

  The following issues have been fixed:

    On github:

    Issue 6: Palette processing is annoying

    On googlecode:

    Issue 62: Problem writing PNG files on Windows

  Development has moved from googlecode to github.
  All issues below here, and the one immediately above,
  are from the googlecode issue tracker.
  All newer issue should be on github.




  PyPNG now installs "out of the box" on Python 3.
  Thanks to simon.sapin@kozea.fr and nathan@dunfield.info for the patch.

  The following issues have been fixed:

    Issue 63: setup.py does not use 2to3
    Issue 64: Typo in documentation




  PyPNG now works on Python 3 if you use the `2to3` tool.
  Fix for converting grey images to RGBA.

  The following issues have been fixed:

    Issue 60: Greyscale images not properly being converted to RGBA
    Issue 61: Doesn't work on Python 3




  Added the "How Fast is PyPNG" section to the documentation.
  Changed it so that more PNG formats return their rows as
  Python `array.array` instances.




  Fix for read_flat method (broken for ages).

  The following issues have been fixed:

    Issue 56:  read_flat broken




  Tentative fix for a deprecation warning on 64-bit Python 2.5 systems.
  Conversion tool for Plan 9 images.

  Issue 54 (below) is tentative.
  The PyPNG developers have been unable to reproduce the error
  (as it seems to be on 64-bit Python 2.5 systems);
  any user reports would be most welcome.

  The following issues have been fixed:

    Issue 54:  Deprecation warnings when using pypng.
    Issue 55:  Cannot convert Plan 9 images.




  Mostly more robust to dodgy input PNGs,
  as a result of testing with `brokensuite`.
  One fixed bug was a critical:
  an infinite loop for a least one input (Issue 52 below).

  The following issues have been fixed:

    Issue 47:  Leading blanks when using write_packed.
    Issue 48:  pipdither fails when input has no gamma chunk.
    Issue 49:  pipdither fail with 1-bit input.
    Issue 50:  pipchunk adds second gamma chunk.
    Issue 51:  piprgb and pipasgrey fail for color mapped images.
    Issue 52:  Some inputs cause infinite loop.




  Better documentation (in `html/ex.html` mostly) for NumPy integration.

  The following issues have been fixed:

    Issue 46:  Unclear how to get PNG pixel data into and out of NumPy.




  NumPy integer types now work.

  The following issues have been fixed:

    Issue 44:  Cannot use numpy.uint16 for pixel values.




  `sBIT` chunks are now handled,
  meaning that PyPNG can handle any (single) bit depth from 1 to 16
  from end to end.

  The following issues have been fixed:

    Issue 28:  Does not add sBIT chunk.
    Issue 36:  Ignores sBIT chunk when present.




  PyPNG now works on Python 2.2
  (significant for Symbian users as PyS60 is based on Python 2.2).
  Not all features are supported on Python 2.2.

  The following issues have been fixed:

    Issue 16:  Source and doc uses 'K' where it should use 'L'.
    Issue 32:  Does not accept packed data.
    Issue 33:  Cannot create greyscale PNG with transparency.
    Issue 35:  Does not work on Python 2.2.




  Handling PAM files allows end to end handling of alpha channels in
  workflows that involve both Netpbm formats and PNG.
  PyPNG now works in Python 2.3.

  The following issues have been fixed:

    Issue 14:  Does not read PAM files.
    Issue 15:  Does not write PAM files.
    Issue 25:  Incorrect handling of tRNS chunk.
    Issue 26:  asRGBA8 method crashes out for color type 2 images.
    Issue 27:  Fails on Python 2.3.




  Lickable HTML documentation is now provided (see the html/ directory),
  generated by Sphinx.

  The following issues have been fixed:

    Issue 8:  Documentation is not lickable.
    Issue 9:  Advantage over PIL is not clear.
    Issue 19: Bogus message for PNM inputs with unsupported maxval
    Issue 20: Cannot write large PNG files




  Stuff happened.




  - .../ - top-level crud (like this README, and setup.py).
  - .../asset - assets (needed for testing)
  - .../code/ - the Python code.
  - .../man/ - manuals (in source/plain-text).
  - .../proc/ - documented procedures (release procedure).




  - Python: www.python.org
  - PNG: http://www.w3.org/TR/PNG/


pkgId: 3138613e59b6d675568567c546590b0404ca3098eb017cd3efea4f3fcd15d38b
name: python-pyppeteer
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Headless chrome/chromium automation library (unofficial port of puppeteer)
url: https://github.com/pyppeteer/pyppeteer
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dd0b60c0-c3a6-4866-95ba-2a3306fa821b
location_href: 00009678-python-pyppeteer/python-pyppeteer-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pyppeteer.svg)](https://pypi.python.org/pypi/pyppeteer)
  [![PyPI version](https://img.shields.io/pypi/pyversions/pyppeteer.svg)](https://pypi.python.org/pypi/pyppeteer)
  [![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://pyppeteer.github.io/pyppeteer/)
  [![CircleCI](https://circleci.com/gh/pyppeteer/pyppeteer.svg?style=shield)](https://circleci.com/gh/pyppeteer/pyppeteer)
  [![codecov](https://codecov.io/gh/pyppeteer/pyppeteer/branch/dev/graph/badge.svg)](https://codecov.io/gh/pyppeteer/pyppeteer)
  _Note: this is a continuation of the [pyppeteer project](https://github.com/miyakogi/pyppeteer)_. Before undertaking any sort of developement, it is highly recommended that you take a look at [#16](https://github.com/pyppeteer/pyppeteer/pull/16) for the ongoing effort to update this library to avoid duplicating efforts.
  Unofficial Python port of [puppeteer](https://github.com/GoogleChrome/puppeteer) JavaScript (headless) chrome/chromium browser automation library.
  * Free software: MIT license (including the work distributed under the Apache 2.0 license)
  * Documentation: https://pyppeteer.github.io/pyppeteer/

  pyppeteer requires Python >= 3.6
  Install with `pip` from PyPI:
  ```
  pip install pyppeteer
  ```
  Or install the latest version from [this github repo](https://github.com/pyppeteer/pyppeteer/):
  ```
  pip install -U git+https://github.com/pyppeteer/pyppeteer@dev
  ```

  > **Note**: When you run pyppeteer for the first time, it downloads the latest version of Chromium (~150MB) if it is not found on your system. If you don't prefer this behavior, ensure that a suitable Chrome binary is installed. One way to do this is to run `pyppeteer-install` command before prior to using this library.
  Full documentation can be found [here](https://pyppeteer.github.io/pyppeteer/reference.html). [Puppeteer's documentation](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#) and [its troubleshooting guide](https://github.com/GoogleChrome/puppeteer/blob/master/docs/troubleshooting.md) are also great resources for pyppeteer users.

  Open web page and take a screenshot:
  ```py
  import asyncio
  from pyppeteer import launch
  async def main():
      browser = await launch()
      page = await browser.newPage()
      await page.goto('https://example.com')
      await page.screenshot({'path': 'example.png'})
      await browser.close()
  asyncio.get_event_loop().run_until_complete(main())
  ```
  Evaluate javascript on a page:
  ```py
  import asyncio
  from pyppeteer import launch
  async def main():
      browser = await launch()
      page = await browser.newPage()
      await page.goto('https://example.com')
      await page.screenshot({'path': 'example.png'})
      dimensions = await page.evaluate('''() => {
          return {
              width: document.documentElement.clientWidth,
              height: document.documentElement.clientHeight,
              deviceScaleFactor: window.devicePixelRatio,
          }
      }''')
      print(dimensions)
      
      await browser.close()
  asyncio.get_event_loop().run_until_complete(main())
  ```

  pyppeteer strives to replicate the puppeteer API as close as possible, however, fundamental differences between Javascript and Python make this difficult to do precisely. More information on specifics can be found in the [documentation](https://pyppeteer.github.io/pyppeteer/reference.html).

  puppeteer uses an object for passing options to functions/methods. pyppeteer methods/functions accept both dictionary (python equivalent to JavaScript's objects) and keyword arguments for options.
  Dictionary style options (similar to puppeteer):
  ```python
  browser = await launch({'headless': True})
  ```
  Keyword argument style options (more pythonic, isn't it?):
  ```python
  browser = await launch(headless=True)
  ```

  In python, `$` is not a valid identifier. The equivalent methods to Puppeteer's `$`, `$$`, and `$x` methods are listed below, along with some shorthand methods for your convenience:
  | puppeteer | pyppeteer              | pyppeteer shorthand |
  |-----------|-------------------------|----------------------|
  | Page.$()  | Page.querySelector()    | Page.J()             |
  | Page.$$() | Page.querySelectorAll() | Page.JJ()            |
  | Page.$x() | Page.xpath()            | Page.Jx()            |

  puppeteer's version of `evaluate()` takes a JavaScript function or a string representation of a JavaScript expression. pyppeteer takes string representation of JavaScript expression or function. pyppeteer will try to automatically detect if the string is function or expression, but it will fail sometimes. If an expression is erroneously treated as function and an error is raised, try setting `force_expr` to `True`, to force pyppeteer to treat the string as expression.

  Get a page's `textContent`:
  ```python
  content = await page.evaluate('document.body.textContent', force_expr=True)
  ```
  Get an element's `textContent`:
  ```python
  element = await page.querySelector('h1')
  title = await page.evaluate('(element) => element.textContent', element)
  ```

  See [projects](https://github.com/pyppeteer/pyppeteer/projects)


pkgId: d5b32ee4a9eba68fb80a4b805292bafc9bfe5ac069283ab91661944abcb51005
name: python-pyppmd-debuginfo
arch: aarch64
version: 1.0.0
epoch: 0
release: 1
summary: Debug information for package python-pyppmd
url: http://github.com/miurahr/pyppmd
rpm_license: LGPL-2.1-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-b136e34e-939e-401a-a3e2-ad6a26bea25a
rpm_sourcerpm: python-pyppmd-1.0.0-1.src.rpm
location_href: 00010474-python-pyppmd/python-pyppmd-debuginfo-1.0.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyppmd.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: d49a933ddf40f18261c39704a23138ef771d04129b21270463f8d50fda83b7d4
name: python-pyppmd-debugsource
arch: aarch64
version: 1.0.0
epoch: 0
release: 1
summary: Debug sources for package python-pyppmd
url: http://github.com/miurahr/pyppmd
rpm_license: LGPL-2.1-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-b136e34e-939e-401a-a3e2-ad6a26bea25a
rpm_sourcerpm: python-pyppmd-1.0.0-1.src.rpm
location_href: 00010474-python-pyppmd/python-pyppmd-debugsource-1.0.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyppmd.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e4be3de250575651e7c63bcc5a3c20d0468e2daa4064d5e1dc356821b710f101
name: python-pypresence
arch: src
version: 4.2.1
epoch: 0
release: 1
summary: Discord RPC client written in Python
url: https://github.com/qwertyquerty/pypresence
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f0447e1-a9b0-43d4-9f81-33ec2b89020d
location_href: 00010187-python-pypresence/python-pypresence-4.2.1-1.src.rpm
checksum_type: sha256
description:
  **Use this badge in your project's Readme to show you're using pypresence! The markdown code is below.**
  [![pypresence](https://img.shields.io/badge/using-pypresence-00bb88.svg?style=for-the-badge&logo=discord&logoWidth=20)](https://github.com/qwertyquerty/pypresence)
  ```markdown
  [![pypresence](https://img.shields.io/badge/using-pypresence-00bb88.svg?style=for-the-badge&logo=discord&logoWidth=20)](https://github.com/qwertyquerty/pypresence)


pkgId: 27abb4f9cba52e939a506bd684dbbe232cf9e78cfd0fea8e76eba8211334c6d4
name: python-pyprocdev
arch: src
version: 0.2
epoch: 0
release: 1
summary: Python interface to /proc/devices
url: UNKNOWN
rpm_license: GPL 2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5f3f293a-a5d9-4a2f-a811-49020bfc090a
location_href: 00004769-python-pyprocdev/python-pyprocdev-0.2-1.src.rpm
checksum_type: sha256
description:
  This package supplies a Python interface to the /proc/devices file.
  To use, instantiate the ProcDev class and invoke its methods. ::
      >>> from pyprocdev import *
      >>> procdev = ProcDev()
      >>> procdev.majors(DeviceTypes.BLOCK)
      [8, 9, 11, 65, 66, 67, 68, 69, 70, 71, 128, 129, 130, 131, 132, 133, 134, 135, 253, 254, 259]
      >>> procdev.majors(DeviceTypes.CHARACTER)
      [1, 4, 5, 7, 10, 13, 14, 21, 29, 99, 116, 128, 136, 162, 166, 180, 188, 189, 202, 203, 226, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254]
      >>> procdev.drivers(DeviceTypes.BLOCK)
      frozenset(['md', 'sr', 'device-mapper', 'blkext', 'mdp', 'sd'])
      >>> procdev.get_driver(DeviceTypes.BLOCK, 8)
      'sd'
      >>> procdev.get_majors(DeviceTypes.BLOCK, 'sd')
      [8, 65, 66, 67, 68, 69, 70, 71, 128, 129, 130, 131, 132, 133, 134, 135]


pkgId: dc83e5d9fc52de37d49f47ff9aad935513e620e8eec6050e3d37fe58a3a0bd44
name: python-pyproj
arch: src
version: 3.4.1
epoch: 0
release: 1
summary: Python interface to PROJ (cartographic projections and coordinate transformations library)
url: https://github.com/pyproj4/pyproj
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c43c185-31a8-40aa-9e7a-16409c62b089
location_href: 00004770-python-pyproj/python-pyproj-3.4.1-1.src.rpm
checksum_type: sha256
description:
  ![Pyproj logo](docs/media/logo.png)



  Python interface to [PROJ](http://proj.org) (cartographic projections and coordinate transformations library).

  <p align="center">
  <a href="https://gitter.im/pyproj4-pyproj/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"><img alt="Join the chat at https://gitter.im/pyproj4-pyproj/community" src="https://badges.gitter.im/pyproj4-pyproj/community.svg"></a>
  <a href="#contributors"><img alt="All Contributors" src="https://img.shields.io/badge/all_contributors-56-orange.svg?style=flat-square"></a>
  <a href="https://ci.appveyor.com/project/snowman2/pyproj"><img alt="Appveyor Build Status" src="https://ci.appveyor.com/api/projects/status/v2ypts9j76doa9ey/branch/main?svg=true"></a>
  <a href="https://github.com/pyproj4/pyproj/actions?query=workflow%3ATests"><img alt="GitHub Actions Build Status" src="https://github.com/pyproj4/pyproj/workflows/Tests/badge.svg"></a>
  <a href="https://codecov.io/gh/pyproj4/pyproj"><img alt="Codecov Status" src="https://codecov.io/gh/pyproj4/pyproj/branch/main/graph/badge.svg"></a>
  <a href="https://badge.fury.io/py/pyproj"><img alt="PyPI" src="https://badge.fury.io/py/pyproj.svg"></a>
  <a href="https://pepy.tech/project/pyproj"><img alt="Downloads" src="https://pepy.tech/badge/pyproj"></a>
  <a href="https://anaconda.org/conda-forge/pyproj"><img alt="Anaconda-Server Badge" src="https://anaconda.org/conda-forge/pyproj/badges/version.svg"></a>
  <a href="https://github.com/python/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  <a href="https://github.com/pre-commit/pre-commit"><img alt="pre-commit" src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white"></a>
  <a href="https://zenodo.org/badge/latestdoi/28607354"><img alt="DOI" src="https://zenodo.org/badge/28607354.svg"></a>
  </p>




  - Stable: http://pyproj4.github.io/pyproj/stable/
  - Latest: https://pyproj4.github.io/pyproj/latest/



  - Report bugs/feature requests: https://github.com/pyproj4/pyproj/issues
  - Ask questions: https://github.com/pyproj4/pyproj/discussions
  - Ask developer questions: https://gitter.im/pyproj4-pyproj/community
  - Ask the GIS community: https://gis.stackexchange.com/questions/tagged/pyproj



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://github.com/jswhit"><img src="https://avatars2.githubusercontent.com/u/579593?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jeff Whitaker</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=jswhit" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jswhit" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jswhit" title="Code">💻</a> <a href="#example-jswhit" title="Examples">💡</a> <a href="#ideas-jswhit" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Ajswhit" title="Reviewed Pull Requests">👀</a> <a href="#question-jswhit" title="Answering Questions">💬</a> <a href="#maintenance-jswhit" title="Maintenance">🚧</a> <a href="#infra-jswhit" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajswhit" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/snowman2"><img src="https://avatars3.githubusercontent.com/u/8699967?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Alan D. Snow</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=snowman2" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=snowman2" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/commits?author=snowman2" title="Code">💻</a> <a href="#example-snowman2" title="Examples">💡</a> <a href="#maintenance-snowman2" title="Maintenance">🚧</a> <a href="#infra-snowman2" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#ideas-snowman2" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Asnowman2" title="Reviewed Pull Requests">👀</a> <a href="#question-snowman2" title="Answering Questions">💬</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Asnowman2" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/micahcochran"><img src="https://avatars0.githubusercontent.com/u/7433104?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Micah Cochran</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=micahcochran" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=micahcochran" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/commits?author=micahcochran" title="Code">💻</a> <a href="#maintenance-micahcochran" title="Maintenance">🚧</a> <a href="#infra-micahcochran" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Amicahcochran" title="Reviewed Pull Requests">👀</a> <a href="#question-micahcochran" title="Answering Questions">💬</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Amicahcochran" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://jorisvandenbossche.github.io/"><img src="https://avatars2.githubusercontent.com/u/1020496?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Joris Van den Bossche</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=jorisvandenbossche" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jorisvandenbossche" title="Code">💻</a> <a href="#ideas-jorisvandenbossche" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Ajorisvandenbossche" title="Reviewed Pull Requests">👀</a> <a href="#question-jorisvandenbossche" title="Answering Questions">💬</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajorisvandenbossche" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jorisvandenbossche" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/cjmayo"><img src="https://avatars1.githubusercontent.com/u/921089?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Chris Mayo</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=cjmayo" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://www.petrel.org"><img src="https://avatars1.githubusercontent.com/u/2298266?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Charles Karney</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=cffk" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=cffk" title="Tests">⚠️</a></td>
      <td align="center"><a href="http://www.justaprogrammer.net/profile/justin"><img src="https://avatars3.githubusercontent.com/u/146930?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Justin Dearing</b></sub></a><br /><a href="#infra-zippy1981" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/jdkloe"><img src="https://avatars3.githubusercontent.com/u/1906112?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jos de Kloe</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=jdkloe" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jdkloe" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajdkloe" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/georgeouzou"><img src="https://avatars3.githubusercontent.com/u/16732042?v=4?s=100" width="100px;" alt=""/><br /><sub><b>George Ouzounoudis</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=georgeouzou" title="Code">💻</a> <a href="#ideas-georgeouzou" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://github.com/djhoese"><img src="https://avatars3.githubusercontent.com/u/1828519?v=4?s=100" width="100px;" alt=""/><br /><sub><b>David Hoese</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Adjhoese" title="Reviewed Pull Requests">👀</a> <a href="#ideas-djhoese" title="Ideas, Planning, & Feedback">🤔</a> <a href="#platform-djhoese" title="Packaging/porting to new platform">📦</a> <a href="https://github.com/pyproj4/pyproj/commits?author=djhoese" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=djhoese" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/commits?author=djhoese" title="Code">💻</a></td>
      <td align="center"><a href="http://mitkin.github.io"><img src="https://avatars3.githubusercontent.com/u/3927849?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mikhail Itkin</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=mitkin" title="Code">💻</a></td>
      <td align="center"><a href="http://dopplershift.github.io"><img src="https://avatars2.githubusercontent.com/u/221526?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ryan May</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=dopplershift" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/artttt"><img src="https://avatars3.githubusercontent.com/u/4626281?v=4?s=100" width="100px;" alt=""/><br /><sub><b>artttt</b></sub></a><br /><a href="#ideas-artttt" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="http://ocefpaf.github.io/python4oceanographers"><img src="https://avatars1.githubusercontent.com/u/950575?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Filipe</b></sub></a><br /><a href="#infra-ocefpaf" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/pyproj4/pyproj/commits?author=ocefpaf" title="Code">💻</a> <a href="#platform-ocefpaf" title="Packaging/porting to new platform">📦</a> <a href="https://github.com/pyproj4/pyproj/commits?author=ocefpaf" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/heitorPB"><img src="https://avatars2.githubusercontent.com/u/13461702?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Heitor</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=heitorPB" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/sebastic"><img src="https://avatars3.githubusercontent.com/u/4605306?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Bas Couwenberg</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=sebastic" title="Code">💻</a> <a href="#platform-sebastic" title="Packaging/porting to new platform">📦</a> <a href="https://github.com/pyproj4/pyproj/commits?author=sebastic" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/nickeubank"><img src="https://avatars0.githubusercontent.com/u/9683693?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Nick Eubank</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=nickeubank" title="Code">💻</a></td>
      <td align="center"><a href="https://www.math.uwaterloo.ca/~mdunphy/"><img src="https://avatars3.githubusercontent.com/u/9088426?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Michael Dunphy</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=mdunphy" title="Documentation">📖</a></td>
      <td align="center"><a href="http://matthew.dynevor.org"><img src="https://avatars2.githubusercontent.com/u/67612?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Matthew Brett</b></sub></a><br /><a href="#infra-matthew-brett" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#platform-matthew-brett" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://naboa.de"><img src="https://avatars1.githubusercontent.com/u/10531844?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jakob de Maeyer </b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=jdemaeyer" title="Code">💻</a></td>
      <td align="center"><a href="https://gitter.im"><img src="https://avatars2.githubusercontent.com/u/8518239?v=4?s=100" width="100px;" alt=""/><br /><sub><b>The Gitter Badger</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=gitter-badger" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="http://lizards.opensuse.org/author/bmwiedemann/"><img src="https://avatars3.githubusercontent.com/u/637990?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Bernhard M. Wiedemann</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=bmwiedemann" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/ReallyNiceGuy"><img src="https://avatars0.githubusercontent.com/u/6545730?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Marco Aurélio da Costa</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=ReallyNiceGuy" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/ChrisBarker-NOAA"><img src="https://avatars2.githubusercontent.com/u/916576?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Christopher H. Barker</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=ChrisBarker-NOAA" title="Code">💻</a></td>
      <td align="center"><a href="https://evers.dev/"><img src="https://avatars3.githubusercontent.com/u/13132571?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Kristian Evers</b></sub></a><br /><a href="#question-kbevers" title="Answering Questions">💬</a> <a href="#ideas-kbevers" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/commits?author=kbevers" title="Documentation">📖</a></td>
      <td align="center"><a href="http://www.spatialys.com/en/about/"><img src="https://avatars2.githubusercontent.com/u/1192433?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Even Rouault</b></sub></a><br /><a href="#question-rouault" title="Answering Questions">💬</a></td>
      <td align="center"><a href="https://github.com/cgohlke"><img src="https://avatars3.githubusercontent.com/u/483428?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Christoph Gohlke</b></sub></a><br /><a href="#platform-cgohlke" title="Packaging/porting to new platform">📦</a> <a href="#question-cgohlke" title="Answering Questions">💬</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Acgohlke" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=cgohlke" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/chrrrisw"><img src="https://avatars0.githubusercontent.com/u/5555320?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Chris Willoughby</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=chrrrisw" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/glostis"><img src="https://avatars0.githubusercontent.com/u/25295717?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Guillaume Lostis</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=glostis" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/edpop"><img src="https://avatars3.githubusercontent.com/u/13479292?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Eduard Popov</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=edpop" title="Documentation">📖</a></td>
      <td align="center"><a href="http://www.personal.psu.edu/jar339"><img src="https://avatars2.githubusercontent.com/u/7864460?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Joe Ranalli</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajranalli" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jranalli" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jranalli" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/gberardinelli"><img src="https://avatars0.githubusercontent.com/u/13799588?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Greg Berardinelli</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Agberardinelli" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=gberardinelli" title="Code">💻</a> <a href="#ideas-gberardinelli" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/commits?author=gberardinelli" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/mraspaud"><img src="https://avatars1.githubusercontent.com/u/167802?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Martin Raspaud</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Amraspaud" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=mraspaud" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=mraspaud" title="Tests">⚠️</a> <a href="#ideas-mraspaud" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://sites.google.com/site/mwtoews/"><img src="https://avatars1.githubusercontent.com/u/895458?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mike Taves</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=mwtoews" title="Tests">⚠️</a></td>
      <td align="center"><a href="http://davidhaberthür.ch"><img src="https://avatars2.githubusercontent.com/u/1651235?v=4?s=100" width="100px;" alt=""/><br /><sub><b>David Haberthür</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=habi" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/mmodenesi"><img src="https://avatars2.githubusercontent.com/u/5569789?v=4?s=100" width="100px;" alt=""/><br /><sub><b>mmodenesi</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ammodenesi" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=mmodenesi" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=mmodenesi" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://www.indigoag.com/"><img src="https://avatars0.githubusercontent.com/u/48448372?v=4?s=100" width="100px;" alt=""/><br /><sub><b>jacob-indigo</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajacob-indigo" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jacob-indigo" title="Code">💻</a></td>
      <td align="center"><a href="https://rahulporuri.github.io"><img src="https://avatars0.githubusercontent.com/u/1926457?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Poruri Sai Rahul</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=rahulporuri" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://medium.com/@underchemist"><img src="https://avatars1.githubusercontent.com/u/5283998?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Yann-Sebastien Tremblay-Johnston</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=underchemist" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/odidev"><img src="https://avatars2.githubusercontent.com/u/40816837?v=4?s=100" width="100px;" alt=""/><br /><sub><b>odidev</b></sub></a><br /><a href="#platform-odidev" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://github.com/idanmiara"><img src="https://avatars.githubusercontent.com/u/26349741?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Idan Miara</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=idanmiara" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=idanmiara" title="Documentation">📖</a> <a href="#example-idanmiara" title="Examples">💡</a> <a href="https://github.com/pyproj4/pyproj/commits?author=idanmiara" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/direvus"><img src="https://avatars.githubusercontent.com/u/312229?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Brendan Jurd</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=direvus" title="Documentation">📖</a> <a href="#design-direvus" title="Design">🎨</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://www.metoffice.gov.uk/"><img src="https://avatars.githubusercontent.com/u/2051656?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Bill Little</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=bjlittle" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/gerritholl"><img src="https://avatars.githubusercontent.com/u/500246?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Gerrit Holl</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=gerritholl" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/Kirill888"><img src="https://avatars.githubusercontent.com/u/1428024?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Kirill Kouzoubov</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=Kirill888" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/hemberger"><img src="https://avatars.githubusercontent.com/u/846186?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Dan Hemberger</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ahemberger" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=hemberger" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/martinfleis"><img src="https://avatars.githubusercontent.com/u/36797143?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Martin Fleischmann</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Amartinfleis" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=martinfleis" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=martinfleis" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/orontee"><img src="https://avatars.githubusercontent.com/u/2065954?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Matthias Meulien</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=orontee" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Aorontee" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/iboates"><img src="https://avatars.githubusercontent.com/u/13814358?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Isaac Boates</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=iboates" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Aiboates" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=iboates" title="Tests">⚠️</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/kdpenner"><img src="https://avatars.githubusercontent.com/u/9297904?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Kyle Penner</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=kdpenner" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Akdpenner" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=kdpenner" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/paulcochrane"><img src="https://avatars.githubusercontent.com/u/18310598?v=4?s=100" width="100px;" alt=""/><br /><sub><b>paulcochrane</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=paulcochrane" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=paulcochrane" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=paulcochrane" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Apaulcochrane" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/vot4anto"><img src="https://avatars.githubusercontent.com/u/56338190?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Antonio Ettorre</b></sub></a><br /><a href="#platform-vot4anto" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://github.com/DWesl"><img src="https://avatars.githubusercontent.com/u/22566757?v=4?s=100" width="100px;" alt=""/><br /><sub><b>DWesl</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=DWesl" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/molinav"><img src="https://avatars.githubusercontent.com/u/9979942?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Víctor Molina García</b></sub></a><br /><a href="#platform-molinav" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://github.com/skogler"><img src="https://avatars.githubusercontent.com/u/1032405?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Samuel Kogler</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Askogler" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=skogler" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/shadchin"><img src="https://avatars.githubusercontent.com/u/61256?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Alexander Shadchin</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ashadchin" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=shadchin" title="Code">💻</a></td>
    </tr>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: 63c2c643d43f59f053f628e672f7fbcba9df3622aa669eb7817745a263a410d1
name: python-pypsexec
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Run commands on a remote Windows host using SMB/RPC
url: https://github.com/jborean93/pypsexec
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-00da09a4-c233-4af7-9330-7852cd327300
location_href: 00011222-python-pypsexec/python-pypsexec-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Test workflow](https://github.com/jborean93/pypsexec/actions/workflows/ci.yml/badge.svg)](https://github.com/jborean93/pypsexec/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/jborean93/pypsexec/branch/master/graph/badge.svg?token=Hi2Nk4RfMF)](https://codecov.io/gh/jborean93/pypsexec)
  [![PyPI version](https://badge.fury.io/py/pypsexec.svg)](https://badge.fury.io/py/pypsexec)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jborean93/pypsexec/blob/master/LICENSE)

  This library can run commands on a remote Windows host through Python. This
  means that it can be run on any host with Python and does not require any
  binaries to be present or a specific OS. It uses SMB/RPC to executable commands
  in a similar fashion to the popular PsExec tool. More details on this tool
  can be read on
  [this blog post](https://www.bloggingforlogging.com/2018/03/12/introducing-psexec-for-python/).

  The executable wrapper that is sent to the service is based on the
  [PAExec](https://github.com/poweradminllc/PAExec) library. PAExec is an free,
  redistributable and open source equivalent to Microsoft's
  [PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)
  application. This program is stored as a binary in this package and is used
  to run the remote service and start the process execution.

  I would like to thank the developers of Power Admin for creating this library
  as it has made this library a lot less complex than what it would have been.




  With pypsexec you can run commands of a remote Windows host like you would with
  PsExec. Current you can use pypsexec to do the following;

  * Run as a specific local or domain user or the user
  * Run as the local SYSTEM account
  * Run as an interactive process
  * Specify the session the interactive process should run on
  * Specify the run level of the user token, `highest` or `limited`
  * Set the priority of the process
  * Set a timeout for the remote process
  * Send input through the stdin pipe to the running process
  * Set the processors the process can run on




  While this info is not necessary for you to use this library it can help people
  understand what is happening under the hood. This library runs the following
  steps when running a command;

  * Create an SMB connection to the host
  * Copies across the PAExec binary to the `ADMIN$` share of the remote host
  * Binds the Windows Service Manager to the opened `IPC$` tree using RPC
  * Creates and starts a Windows service as the `SYSTEM` account to run the binary copied
  * Connect to the PAExec named pipe the service creates
  * Sends the process details to the PAExec service through the pipe
  * Send a request to the PAExec service to start the process based on the settings sent
  * Connect to the newly spawned process's stdout, stderr, stdin pipe (if not interactive or async)
  * Read the stdout/stderr pipe until the process is complete
  * Get the return code of the new process
  * Stop and remove the PAExec service
  * Remove the PAExec binary from the `ADMIN$` share
  * Disconnects from the SMB connection

  In the case of a failed process, the PAExec service and binary may not be
  removed from the host and may need to be done manually. This is only the case
  for a critical error or the cleanup functions not being called.

  By default the data being sent to and from the server is encrypted to stop
  people listening in on the network from snooping your data. Unfortunately this
  uses SMB encryption which was added in the SMB 3.x dialects so hosts running
  Windows 7, Server 2008, or Server 2008 R2 will not work with encryption.

  This means that any data sent over the wire on these older versions of Windows
  is viewable by anyone reading those packets. Any input or output of the process
  comes through these packets so any secrets sent over the network won't be
  encrypted. PAExec tries to reduce this risk by doing a simple XOR scramble of
  the settings set in `run_executable` so it isn't plaintext but it can be
  decoded by someone who knows the protocol.




  * Python 3.6+
  * [smbprotocol](https://github.com/jborean93/smbprotocol)

  To install pypsexec, simply run

  ```bash
  pip install pypsexec
  ```

  This will download the required packages that are required and get your
  Python environment ready to do.

  Out of the box, pypsexec supports authenticating to a Windows host with NTLM
  authentication but users in a domain environment can take advantage of Kerberos
  authentication as well for added security. The Kerberos libraries are an
  optional install which can be installed with;

  ```bash

  sudo apt-get install gcc python-dev libkrb5-dev
  pip install smbprotocol[kerberos]


  sudo yum install gcc python-devel krb5-devel krb5-workstation python-devel
  pip install smbprotocol[kerberos]
  ```




  The goal of this package to be able to run executables on a vanilla remote
  Windows host with as little setup as possible. Unfortunately there is still
  some setup required to get working depending on the OS version and type
  that is being used. What pypsexec requires on the host is;

  * SMB to be up and running on the Windows port and readable from the Python host
  * The `ADMIN$` share to be enabled with read/write access of the user configured
  * The above usually means the configured user is an administrator of the Windows host
  * At least SMB 2 on the host (Server 2008 and newer)
  * The connection user has a full logon token that is not filtered by UAC
  * If connecting to localhost and `pywin32` is installed, the script must be run as a user with Administrator privileges



  By default, Windows blocks the SMB port 445 and it needs to be opened up before
  pypsexec can connect to the host. To do this run either one of the following
  commands;

  ```powershell

  Set-NetFirewallRule -Name FPS-SMB-In-TCP -Enabled True


  netsh advfirewall firewall set rule name="File and Printer Sharing (SMB-In)" dir=in new enable=Yes
  ```

  This will open up inbound traffic to port `445` which is used by SMB.




  In some circumstances, UAC will filter any remote logon token and limit the
  rights that are available to it. This causes issues with pypsexec and it will
  fail with an `ACCESS_IS_DENIED` error message when trying to interact with the
  remote SCMR API. This restriction is enforced in various different scenarios
  and to get it working with pypsexec you can either;

  * In a domain environment, use any domain account that is a member of the local `Administrators` group
  * Use any local account that is a member of the local `Administrators` group if [LocalAccountTokenFilterPolicy](https://support.microsoft.com/en-us/help/951016/description-of-user-account-control-and-remote-restrictions-in-windows) is set to `1`
      * This means any remote logon token will not be filtered and will have the full rights of that user
      * By default this is not defined and needs to be created
      * This only affects remote tokens, any local tokens/processes will still be limited as per usual
  * Use the builtin local Administrator account (SID `S-1-5-21-*-500`) that is created when Windows was installed
      * The builtin Administrator account for English installs is typically called `Administrator` but it can be renamed
      * This account is typically disabled by default on the desktop variants of Windows, e.g. Windows 7, 8.1, 10
      * When [AdminApprovalMode](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/dd835564(v=ws.10)#BKMK_BuiltInAdmin) is `Enabled` this will not work. `AdminApprovalMode` is not `Enabled` by default
  * Use any local account that is a member of the local `Administrators` group if [EnableLUA](https://docs.microsoft.com/en-us/windows-hardware/customize/desktop/unattend/microsoft-windows-lua-settings-enablelua) is `Disabled`
      * Unlike the `LocalAccountTokenFilterPolicy` option, this affects local tokens and processes spawned locally
      * This effectively disables UAC for any Administrator accounts and should be avoided

  To set `LocalAccountTokenFilterPolicy` to allow a full token on a remote logon,
  run the following PowerShell commands;

  ```powershell
  $reg_path = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System"
  $reg_prop_name = "LocalAccountTokenFilterPolicy"

  $reg_key = Get-Item -Path $reg_path
  $reg_prop = $reg_key.GetValue($reg_prop_name)
  if ($null -ne $reg_prop) {
      Remove-ItemProperty -Path $reg_path -Name $reg_prop_name
  }

  New-ItemProperty -Path $reg_path -Name $reg_prop_name -Value 1 -PropertyType DWord
  ```

  To get the name of the builtin Administrator (SID `S-1-5-21-*-500`), you can
  run the following PowerShell commands;

  ```powershell
  Add-Type -AssemblyName System.DirectoryServices.AccountManagement
  $principal_context = New-Object -TypeName System.DirectoryServices.AccountManagement.PrincipalContext([System.DirectoryServices.AccountManagement.ContextType]::Machine)
  $user_principal = New-Object -TypeName System.DirectoryServices.AccountManagement.UserPrincipal($principal_context)
  $searcher = New-Object -TypeName System.DirectoryServices.AccountManagement.PrincipalSearcher($user_principal)
  $users = $searcher.FindAll() | Where-Object { $_.Sid -like "*-500" }
  $users[0].Name
  ```

  The last resort would be to disable UAC for any local Administrator account.
  Once again this should be avoided as there are other options available and this
  will reduce the security of your Windows host, but to do so you can run the
  following PowerShell commands;

  ```powershell
  $reg_path = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System"
  $reg_prop_name = "EnableLUA"

  $reg_key = Get-Item -Path $reg_path
  $reg_prop = $reg_key.GetValue($reg_prop_name)
  if ($null -ne $reg_prop) {
      Remove-ItemProperty -Path $reg_path -Name $reg_prop_name
  }

  New-ItemProperty -Path $reg_path -Name $reg_prop_name -Value 0 -PropertyType DWord
  ```

  After changing the `EnableLUA` setting, the Windows host needs to be rebooted
  before the policies are enacted.




  Here is an example of how to run a command with this library

  ```python
  from pypsexec.client import Client


  c = Client("hostname", username="username", password="password")


  c = Client("hostname", username="username", password="password", encrypt=False)



  c = Client("hostname")



  c = Client("hostname", username="username@DOMAIN.LOCAL")

  c.connect()
  try:
      c.create_service()

      
      

      
      stdout, stderr, rc = c.run_executable("cmd.exe",
                                            arguments="/c echo Hello World")

      
      stdout, stderr, rc = c.run_executable("whoami.exe", use_system_account=True)

      
      stdout, stderr, rc = c.run_executable("longrunning.exe",
                                            arguments="/s other args",
                                            asynchronous=True)

      
      stdout, stderr, rc = c.run_executable("whoami",
                                            arguments="/all",
                                            username="local-user",
                                            password="password",
                                            run_elevated=True)
  finally:
      c.remove_service()
      c.disconnect()
  ```

  In the case of a fatal failure, this project may leave behind some the PAExec
  payload in `C:\Windows` or the service still installed. As these are uniquely
  named they can build up over time. They can be manually removed but you can
  also use pypsexec to cleanup them all up at once. To do this run

  ```python
  from pypsexec.client import Client

  c = Client("server", username="username", password="password")
  c.connect()
  c.cleanup()  # this is where the magic happens
  c.disconnect()
  ```

  The script will delete any files that match `C:\Windows\PAExec-*` and any
  services that match `PAExec-*`. For an individual run, the `remove_service()`
  function should still be used.



  When creating the main pypsexec `Client` object there are some configuration
  options that can be set to control the process. These args are;

  * `server`: This needs to be set and is the host or IP address of the server to connect to
  * `username`: The username to connect with. Can be `None` if `python-gssapi` is installed and a ticket has been granted in the local credential cache
  * `password`: The password for `username`. Can be `None` if `python-gssapi` is installed and a ticket has been granted for the user specified
  * `port`: Override the default port of `445` when connecting to the server
  * `encrypt`: Whether to encrypt the messages or not, default is `True`. Server 2008, 2008 R2 and Windows 7 hosts do not support SMB Encryption and need this to be set to `False`




  When calling `run_executable`, there are multiple kwargs that can define
  how the remote process will work. These args are;

  * `executable`: (string) The path to the executable to be run
  * `arguments`: (string) Arguments for the executable
  * `processors`: (list<int>) A list of processor numbers that the process can run on
  * `asynchronous`: (bool) Doesn't wait until the process is complete before returning. The `rc` returned by the function is the `PID` of the async process, default is `False`
  * `load_profile`: (bool) Load the user's profile, default is `True`
  * `interactive_session`: (int) The session ID to display the interactive process when `interactive=True`, default is `0`
  * `interactive`: (bool) Runs the process as an interactive process. The stdout and stderr buffers will be `None` if `True`, default `False`
  * `run_elevated`: (bool) When `username` is defined, will elevated permissions, default `False`
  * `run_limited`: (bool) When `username` is defined, will run the process under limited permissions, default `False`
  * `username`: (string) Used to run the process under a different user than the one that authenticated the SMB session
  * `password`: (string) The password for `username`
  * `use_system_account`: (bool) Run the process as `NT AUTHORITY\SYSTEM`
  * `working_dir`: (string) The working directory of the process, default `C:\Windows\System32`
  * `show_ui_on_win_logon`: (bool) Displays the UI on the Winlogon secure desktop when `use_system_account=True`, default `False`
  * `priority`: (pypsexec.ProcessPriority) The priority level of the process, default `NORMAL_PRIORITY_CLASS`
  * `remote_log_path`: (string) A path on the remote host to log the PAExec service details
  * `timeout_seconds`: (int) The maximum time the process can run for, default is `0` (no timeout)
  * `stdout`: (pipe.OutputPipe) A class that implements pipe.OutputPipe that controls how the stdout output is processed and returned, will default to returning the byte string of the stdout. Is ignored when `interactive=True` and `asynchronous=True`
  * `stderr`: (pipe.OutputPipe) A class that implements pipe.OutputPipe that controls how the stderr output is processed and returned, will default to returning the byte string of the stderr. Is ignored when `interactive=True` and `asynchronous=True`
  * `stdin`: (bytes/generator) A byte string or generator that yields a byte string to send over the stdin pipe, does not work with `interactive=True` and `asynchronous=True`
  * `wow64`: (bool) Set to `True` to run the executable in 32-bit mode on 64-bit systems. This does nothing on 32-bit systems, default `False`




  This library uses the builtin Python logging library and can be used to find
  out what is happening in the pypsexec process. Log messages are logged to the
  `pypsexec` named logger as well as `pypsexec.*` where `*` is each python script
  in the `pypsexec` directory.

  A way to enable the logging in your scripts through code is to add the
  following to the top of the script being used;

  ```python
  import logging

  logger = logging.getLogger("pypsexec")
  logger.setLevel(logging.DEBUG)  # set to logging.INFO if you don't want DEBUG logs
  ch = logging.StreamHandler()
  ch.setLevel(logging.DEBUG)
  formatter = logging.Formatter('s - s - s - '
                                's')
  ch.setFormatter(formatter)
  logger.addHandler(ch)
  ```

  These logs are generally useful when debugging issues as they give you a more
  step by step snapshot of what it is doing and what may be going wrong. The
  debug level will also print out a human readable string of each SMB packet that
  is sent out from the client but this level can get really verbose.




  To this module, you need to install some pre-requisites first. This can be done
  by running;

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


  pip install tox
  ```

  From there to run the basic tests run;

  ```bash
  py.test -v --cov pypsexec --cov-report term-missing


  tox
  ```

  There are extra tests that only run when certain environment variables are set.
  To run these tests set the following variables;

  * `PYPSEXEC_SERVER`: The hostname or IP to a Windows host
  * `PYPSEXEC_USERNAME`: The username to use authenticate with
  * `PYPSEXEC_PASSWORD`: The password for `PYPSEXEC_USERNAME`

  From there, you can just run `tox` or `py.test` with these environment
  variables to run the integration tests.




  Some things I would be interested in looking at adding in the future would be

  * Add a Python script that can be called to run adhoc commands like `PsExec.exe`


pkgId: 066df71398f1afcb01d37d846e8e0df5a55c592d6524bee892b6e352a3b64063
name: python-pyqtgraph
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: Scientific Graphics and GUI Library for Python
url: http://www.pyqtgraph.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a479a071-d60e-4895-9b9c-8e0382dc85f2
location_href: 00004777-python-pyqtgraph/python-pyqtgraph-0.13.2-1.src.rpm
checksum_type: sha256
description:
  PyQtGraph is a pure-python graphics and GUI library built on PyQt5/PySide2 and
  numpy.

  It is intended for use in mathematics / scientific / engineering applications.
  Despite being written entirely in python, the library is very fast due to its
  heavy leverage of numpy for number crunching, Qt's GraphicsView framework for
  2D display, and OpenGL for 3D display.


pkgId: 3fdf992d83b575bcf99fd4250250f115f8c77675a9e97c419afe5c317581b82a
name: python-pyquery
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A jquery-like library for python
url: https://github.com/gawel/pyquery
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-51e19168-7616-47f1-b76d-71311df404ee
location_href: 00009653-python-pyquery/python-pyquery-2.0.0-1.src.rpm
checksum_type: sha256
description:
  pyquery allows you to make jquery queries on xml documents.
  The API is as much as possible similar to jquery. pyquery uses lxml for fast
  xml and html manipulation.
  This is not (or at least not yet) a library to produce or interact with
  javascript code. I just liked the jquery API and I missed it in python so I
  told myself "Hey let's make jquery in python". This is the result.
  The `project`_ is being actively developed on a git repository on Github. I
  have the policy of giving push access to anyone who wants it and then reviewing
  what they do. So if you want to contribute just email me.
  Please report bugs on the `github
  <https://github.com/gawel/pyquery/issues>`_ issue
  tracker.
  I've spent hours maintaining this software, with love.
  Please consider tipping if you like it:
  BTC: 1PruQAwByDndFZ7vTeJhyWefAghaZx9RZg
  ETH: 0xb6418036d8E06c60C4D91c17d72Df6e1e5b15CE6
  LTC: LY6CdZcDbxnBX9GFBJ45TqVj8NykBBqsmT
     >>> (urlopen, your_url, path_to_html_file) = getfixture('readme_fixt')


pkgId: 88aa394ffa58c362f2a172279d45f1583335e8e15d3b4e974614e7adce3e9dda
name: python-pyrad
arch: src
version: 2.4
epoch: 0
release: 1
summary: RADIUS tools
url: https://github.com/pyradius/pyrad
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1bdf51a1-d663-46da-8726-cbba21132980
location_href: 00004778-python-pyrad/python-pyrad-2.4-1.src.rpm
checksum_type: sha256
description:
  pyrad is an implementation of a RADIUS client/server as described in RFC2865.
  It takes care of all the details like building RADIUS packets, sending
  them and decoding responses.
  Here is an example of doing a authentication request::
      from __future__ import print_function
      from pyrad.client import Client
      from pyrad.dictionary import Dictionary
      import pyrad.packet
      srv = Client(server="localhost", secret=b"Kah3choteereethiejeimaeziecumi",
                   dict=Dictionary("dictionary"))
      
      req = srv.CreateAuthPacket(code=pyrad.packet.AccessRequest,
                                 User_Name="wichert", NAS_Identifier="localhost")
      req["User-Password"] = req.PwCrypt("password")
      
      reply = srv.SendPacket(req)
      if reply.code == pyrad.packet.AccessAccept:
          print("access accepted")
      else:
          print("access denied")
      print("Attributes returned by server:")
      for i in reply.keys():
          print("%s: %s" % (i, reply[i]))


pkgId: 1911a4ea3e1c71afacecd082e85b56d6f25562eb44fb47085b7eef6cfe6ea3be
name: python-pyramid-tm
arch: src
version: 2.5
epoch: 0
release: 1
summary: A package which allows Pyramid requests to join the active transaction
url: https://github.com/Pylons/pyramid_tm
rpm_license: BSD-derived (Repoze)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ac91a898-7cd1-44f2-82cb-9aaa22f71cfc
location_href: 00004782-python-pyramid-tm/python-pyramid-tm-2.5-1.src.rpm
checksum_type: sha256
description:
  ``pyramid_tm`` is a package which allows Pyramid requests to join
  the active transaction as provided by the `transaction
  <https://pypi.org/project/transaction/>`_ package.
  See `https://docs.pylonsproject.org/projects/pyramid_tm/en/latest/
  <https://docs.pylonsproject.org/projects/pyramid_tm/en/latest/>`_
  or ``docs/index.rst`` in this distribution for detailed
  documentation.


pkgId: a1a986e789ec0686a8cf6e035db805950dee4dfc90b97b81a6ef0e7226c3254b
name: python-pyreadline
arch: src
version: 2.1
epoch: 0
release: 1
summary: A python implmementation of GNU readline.
url: http://ipython.org/pyreadline.html
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f252257-5542-498a-af70-b33490940cb3
location_href: 00010029-python-pyreadline/python-pyreadline-2.1-1.src.rpm
checksum_type: sha256
description:
  The pyreadline package is a python implementation of GNU readline functionality
  it is based on the ctypes based UNC readline package by Gary Bishop.
  It is not complete. It has been tested for use with windows 2000 and windows xp.

  * pyreadline 2.1 <2015-09-16>

    This is a bugfix release to make pyreadline work with python 3.5.

    Contributors to this release:

      - Jörgen Stenarson, maintainer
      - kivhift, improved error message for running on non windows platforms
      - zooba, made helpful suggestions to make it work for python 3.5

    Version 2.1 of pyreadline has been verfied for Python 2.7, and 3.4, 3.5.


  Features:
   *  keyboard text selection and copy/paste
   *  Shift-arrowkeys for text selection
   *  Control-c can be used for copy activate with allow_ctrl_c(True) in config file
   *  Double tapping ctrl-c will raise a KeyboardInterrupt, use ctrl_c_tap_time_interval(x)
      where x is your preferred tap time window, default 0.3 s.
   *  paste pastes first line of content on clipboard.
   *  ipython_paste, pastes tab-separated data as list of lists or numpy array if all data is numeric
   *  paste_mulitline_code pastes multi line code, removing any empty lines.


   The latest development version is always available at the IPython github
   repository_.

  .. _repository: https://github.com/pyreadline/pyreadline.git


pkgId: 003e7eaba8f58c8b8962e209dcb0d606e4f6389d94220ba380e106d68d67ce10
name: python-pyriemann
arch: src
version: 0.4
epoch: 0
release: 1
summary: Biosignals classification with Riemannian geometry
url: https://pyriemann.readthedocs.io
rpm_license: BSD (3-clause)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aa435462-b9fe-4730-90b0-2f8ee4dfffee
location_href: 00004785-python-pyriemann/python-pyriemann-0.4-1.src.rpm
checksum_type: sha256
description:
  [![Code PythonVersion](https://img.shields.io/badge/python-3.7%20%7C%203.8%20%7C%203.9-blue)](https://img.shields.io/badge/python-3.7%20%7C%203.8%20%7C%203.9-blue)
  [![PyPI version](https://badge.fury.io/py/pyriemann.svg)](https://badge.fury.io/py/pyriemann)
  [![Build Status](https://github.com/pyRiemann/pyRiemann/workflows/testing/badge.svg?branch=master&event=push)](https://github.com/pyRiemann/pyRiemann/actions)
  [![codecov](https://codecov.io/gh/pyRiemann/pyRiemann/branch/master/graph/badge.svg)](https://codecov.io/gh/pyRiemann/pyRiemann)
  [![Documentation Status](https://readthedocs.org/projects/pyriemann/badge/?version=latest)](http://pyriemann.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.593816.svg)](https://doi.org/10.5281/zenodo.593816)
  [![Downloads](https://pepy.tech/badge/pot)](https://pepy.tech/project/pyriemann)

  pyRiemann is a Python machine learning package based on [scikit-learn](http://scikit-learn.org/stable/modules/classes.html) API.
  It provides a high-level interface for processing and classification of multivariate time series
  through the Riemannian geometry of symmetric positive definite (SPD) matrices.

  pyRiemann aims at being a generic package for multivariate time series classification
  but has been designed around multichannel biosignals (like EEG, MEG or EMG) manipulation applied to brain-computer interface (BCI),
  transforming multichannel time series into covariance matrices, and classifying them using the Riemannian geometry of SPD matrices [[1]](#1).

  For BCI applications, studied paradigms are motor imagery [[2]](#2) [[3]](#3), event-related potentials (ERP) [[4]](#4) and steady-state visually evoked potentials (SSVEP) [[5]](#5).
  Using extended labels, API allows transfer learning between sessions or subjects [[6]](#6).

  This code is BSD-licenced (3 clause).



  The documentation is available on http://pyriemann.readthedocs.io/en/latest/





  ```
  pip install pyriemann
  ```
  or using pip+git for the latest version of the code :

  ```
  pip install git+https://github.com/pyRiemann/pyRiemann
  ```

  Anaconda is not currently supported, if you want to use anaconda, you need to create a virtual environment in anaconda,
  activate it and use the above command to install it.



  For the latest version, you can install the package from the sources using the setup.py script

  ```
  python setup.py install
  ```

  or in developer mode to be able to modify the sources.

  ```
  python setup.py develop
  ```



  Most of the functions mimic the scikit-learn API, and therefore can be directly used with sklearn.
  For example, for cross-validation classification of EEG signal using the MDM algorithm described in [[2]](#2), it is easy as:

  ```python
  import pyriemann
  from sklearn.model_selection import cross_val_score


  X = ... # EEG data, in format n_epochs x n_channels x n_times
  y = ... # labels


  cov = pyriemann.estimation.Covariances().fit_transform(X)


  mdm = pyriemann.classification.MDM()

  accuracy = cross_val_score(mdm, cov, y)

  print(accuracy.mean())

  ```

  You can also pipeline methods using sklearn pipeline framework.
  For example, to classify EEG signal using a SVM classifier in the tangent space, described in [[3]](#3):

  ```python
  from pyriemann.estimation import Covariances
  from pyriemann.tangentspace import TangentSpace

  from sklearn.pipeline import make_pipeline
  from sklearn.svm import SVC
  from sklearn.model_selection import cross_val_score


  X = ... # EEG data, in format n_epochs x n_channels x n_times
  y = ... # labels


  covest = Covariances()
  ts = TangentSpace()
  svc = SVC(kernel='linear')
  clf = make_pipeline(covest, ts, svc)


  accuracy = cross_val_score(clf, X, y)

  print(accuracy.mean())

  ```

  **Check out the example folder for more examples !**



  The package aims at adopting the [scikit-learn](http://scikit-learn.org/stable/developers/contributing.html#contributing-code)
  and [MNE-Python](https://mne.tools/stable/install/contributing.html) conventions as much as possible.
  See their contribution guidelines before contributing to the repository.



  If you make a modification, run the test suite before submitting a pull request

  ```
  pytest
  ```



  ```bibtex
  @software{pyriemann,
    author       = {Alexandre Barachant and
                    Quentin Barthélemy and
                    Jean-Rémi King and
                    Alexandre Gramfort and
                    Sylvain Chevallier and
                    Pedro L. C. Rodrigues and
                    Emanuele Olivetti and
                    Vladislav Goncharenko and
                    Gabriel Wagner vom Berg and
                    Ghiles Reguig and
                    Arthur Lebeurrier and
                    Erik Bjäreholt and
                    Maria Sayu Yamamoto and
                    Pierre Clisson and
                    Marie-Constance Corsi},
    title        = {pyRiemann/pyRiemann: v0.3},
    month        = jul,
    year         = 2022,
    publisher    = {Zenodo},
    version      = {v0.3},
    doi          = {10.5281/zenodo.7547583},
    url          = {https://doi.org/10.5281/zenodo.7547583}
  }
  ```



  <a id="1">[1]</a>
  M. Congedo, A. Barachant and R. Bhatia, "Riemannian geometry for EEG-based brain-computer interfaces; a primer and a review".
  Brain-Computer Interfaces, 4.3, pp. 155-174, 2017. [link](https://hal.science/hal-01570120/document)

  <a id="2">[2]</a>
  A. Barachant, S. Bonnet, M. Congedo and C. Jutten, "Multiclass Brain-Computer Interface Classification by Riemannian Geometry".
  IEEE Transactions on Biomedical Engineering, vol. 59, no. 4, pp. 920-928, 2012. [link](https://hal.archives-ouvertes.fr/hal-00681328)

  <a id="3">[3]</a>
  A. Barachant, S. Bonnet, M. Congedo and C. Jutten, "Classification of covariance matrices using a Riemannian-based kernel for BCI applications".
  Neurocomputing, 112, pp. 172-178, 2013. [link](https://hal.archives-ouvertes.fr/hal-00820475/)

  <a id="4">[4]</a>
  A. Barachant and M. Congedo, "A Plug&Play P300 BCI Using Information Geometry".
  Research report, 2014. [link](http://arxiv.org/abs/1409.0107)

  <a id="5">[5]</a>
  EK. Kalunga, S. Chevallier, Q. Barthélemy, K. Djouani, E. Monacelli and Y. Hamam, "Online SSVEP-based BCI using Riemannian geometry".
  Neurocomputing, 191, pp. 55-68, 2014. [link](https://hal.science/hal-01351623/file/Kalunga-Chevallier-Barthelemy-Online%20SSVEP-based%20BCI%20using%20Riemannian%20Geometry-Neurocomputing-16.pdf)

  <a id="6">[6]</a>
  PLC. Rodrigues, C. Jutten and M. Congedo, "Riemannian Procrustes analysis: transfer learning for brain-computer interfaces".
  IEEE Transactions on Biomedical Engineering, vol. 66, no. 8, pp. 2390-2401, 2018. [link](https://hal.archives-ouvertes.fr/hal-01971856)


pkgId: d409be664ea6f30f8d149024714138fa10eeed1efaf2e7f537e6b977785ac7c7
name: python-pyro-api
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Generic API for dispatch to Pyro backends.
url: https://github.com/pyro-ppl/pyro-api
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c62b8a9-1d67-45cc-a60e-bc3def141a34
location_href: 00012223-python-pyro-api/python-pyro-api-0.1.2-1.src.rpm
checksum_type: sha256
description:
  For testing API compatibility on different backends, install pytest and other test dependencies that includes backends like [funsor](https://github.com/pyro-ppl/funsor) and [numpyro](https://github.com/pyro-ppl/numpyro) and run the test suite:
  ```
  pip install -e .[test]
  pytest -vs
  ```
  This library has no dependencies and can easily be installed for testing your particular Pyro backend
  implementation. You can use the following pattern and test your backend on models in the `pyroapi.testing`
  module.
  ```python
  from pyro_api.dispatch import pyro_backend
  from pyro_api.testing import MODELS

  with pyro_backend(handlers='my_backend.handlers',
                    distributions='my_backend.distributions',
      
      for model in MODELS:
          f = MODELS[model]()
          model, model_args = f['model'], f.get('model_args', ())
          model(*model_args)
  ```


pkgId: 4f29da5dd3bc5a971a3f6eb9a0727ed6971f80fd58cfa1a8837f373e7fde6729
name: python-pyro-ppl
arch: src
version: 1.8.4
epoch: 0
release: 1
summary: A Python library for probabilistic modeling and inference
url: http://pyro.ai
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ff514b4-3f3c-4735-b53f-d3e09b0a903f
location_href: 00012071-python-pyro-ppl/python-pyro-ppl-1.8.4-1.src.rpm
checksum_type: sha256
description:
  [Getting Started](http://pyro.ai/examples) |
  [Documentation](http://docs.pyro.ai/) |
  [Community](http://forum.pyro.ai/) |
  [Contributing](https://github.com/pyro-ppl/pyro/blob/master/CONTRIBUTING.md)

  Pyro is a flexible, scalable deep probabilistic programming library built on PyTorch.  Notably, it was designed with these principles in mind:

  - **Universal**: Pyro is a universal PPL - it can represent any computable probability distribution.
  - **Scalable**: Pyro scales to large data sets with little overhead compared to hand-written code.
  - **Minimal**: Pyro is agile and maintainable. It is implemented with a small core of powerful, composable abstractions.
  - **Flexible**: Pyro aims for automation when you want it, control when you need it. This is accomplished through high-level abstractions to express generative and inference models, while allowing experts easy-access to customize inference.

  Pyro was originally developed at Uber AI and is now actively maintained by community contributors, including a dedicated team at the [Broad Institute](https://www.broadinstitute.org/).
  In 2019, Pyro [became](https://www.linuxfoundation.org/press-release/2019/02/pyro-probabilistic-programming-language-becomes-newest-lf-deep-learning-project/) a project of the Linux Foundation, a neutral space for collaboration on open source software, open standards, open data, and open hardware.

  For more information about the high level motivation for Pyro, check out our [launch blog post](http://eng.uber.com/pyro).
  For additional blog posts, check out work on [experimental design](https://eng.uber.com/oed-pyro-release/) and
  [time-to-event modeling](https://eng.uber.com/modeling-censored-time-to-event-data-using-pyro/) in Pyro.





  **Install using pip:**
  ```sh
  pip install pyro-ppl
  ```

  **Install from source:**
  ```sh
  git clone git@github.com:pyro-ppl/pyro.git
  cd pyro
  git checkout master  # master is pinned to the latest release
  pip install .
  ```

  **Install with extra packages:**

  To install the dependencies required to run the probabilistic models included in the `examples`/`tutorials` directories, please use the following command:
  ```sh
  pip install pyro-ppl[extras]
  ```
  Make sure that the models come from the same release version of the [Pyro source code](https://github.com/pyro-ppl/pyro/releases) as you have installed.



  For recent features you can install Pyro from source.

  **Install Pyro using pip:**

  ```sh
  pip install git+https://github.com/pyro-ppl/pyro.git
  ```
  or, with the `extras` dependency to run the probabilistic models included in the `examples`/`tutorials` directories:
  ```sh
  pip install git+https://github.com/pyro-ppl/pyro.git#egg=project[extras]
  ```

  **Install Pyro from source:**

  ```sh
  git clone https://github.com/pyro-ppl/pyro
  cd pyro
  pip install .  # pip install .[extras] for running models in examples/tutorials
  ```



  Refer to the instructions [here](docker/README.md).


  If you use Pyro, please consider citing:
  ```
  @article{bingham2019pyro,
    author    = {Eli Bingham and
                 Jonathan P. Chen and
                 Martin Jankowiak and
                 Fritz Obermeyer and
                 Neeraj Pradhan and
                 Theofanis Karaletsos and
                 Rohit Singh and
                 Paul A. Szerlip and
                 Paul Horsfall and
                 Noah D. Goodman},
    title     = {Pyro: Deep Universal Probabilistic Programming},
    journal   = {J. Mach. Learn. Res.},
    volume    = {20},
    pages     = {28:1--28:6},
    year      = {2019},
    url       = {http://jmlr.org/papers/v20/18-403.html}
  }
  ```


pkgId: 9fc99db59ce4bd8815c4227e18b59ce940676bb7b92fb769e1e5a854273277ed
name: python-pyroute2
arch: src
version: 0.7.6
epoch: 0
release: 1
summary: Python Netlink library
url: https://github.com/svinota/pyroute2
rpm_license: GPL-2.0-or-later OR Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12eb67df-8f6c-429a-b85d-dd7316b7a88b
location_href: 00010804-python-pyroute2/python-pyroute2-0.7.6-1.src.rpm
checksum_type: sha256
description:
  Pyroute2 is a pure Python **netlink** library. The core requires only Python
  stdlib, no 3rd party libraries. The library was started as an RTNL protocol
  implementation, so the name is **pyroute2**, but now it supports many netlink
  protocols. Some supported netlink families and protocols:
  * **rtnl**, network settings --- addresses, routes, traffic controls
  * **nfnetlink** --- netfilter API
  * **ipq** --- simplest userspace packet filtering, iptables QUEUE target
  * **devlink** --- manage and monitor devlink-enabled hardware
  * **generic** --- generic netlink families
  * **uevent** --- same uevent messages as in udev
  Netfilter API:
  * **ipset** --- IP sets
  * **nftables** --- packet filtering
  * **nfct** --- connection tracking
  Generic netlink:
  * **ethtool** --- low-level network interface setup
  * **wireguard** --- VPN setup
  * **nl80211** --- wireless functions API (basic support)
  * **taskstats** --- extended process statistics
  * **acpi_events** --- ACPI events monitoring
  * **thermal_events** --- thermal events monitoring
  * **VFS_DQUOT** --- disk quota events monitoring
  On the low level the library provides socket objects with an
  extended API. The additional functionality aims to:
  * Help to open/bind netlink sockets
  * Discover generic netlink protocols and multicast groups
  * Construct, encode and decode netlink and PF_ROUTE messages


pkgId: c2f4662c8ef28abe797a7f7a8c84f7e71615ffc83f3388082fa73a11f8244e5f
name: python-pyroute2.ipdb
arch: src
version: 0.6.13
epoch: 0
release: 1
summary: Python Netlink library: IPDB module
url: https://github.com/svinota/pyroute2
rpm_license: dual license GPLv2+ and Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-827072ab-c3d4-487b-ad09-12aa370a8720
location_href: 00011722-python-pyroute2-ipdb/python-pyroute2.ipdb-0.6.13-1.src.rpm
checksum_type: sha256
description:
  PyRoute2 is a pure Python **netlink** library.
  IPDB module is approaching its end of life.
  Details: <https://github.com/svinota/pyroute2/discussions/788>


pkgId: 5d782eb82b7c3f4532db6a905a3f3a5da940d13535f8a02cba353070ec2eb776
name: python-pyroute2.nslink
arch: src
version: 0.6.13
epoch: 0
release: 1
summary: Python Netlink library: NetNS, NSPopen and remote modules
url: https://github.com/svinota/pyroute2
rpm_license: dual license GPLv2+ and Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e977d1f0-62ff-4a2c-baaa-3eef4cd5b2e7
location_href: 00011720-python-pyroute2-nslink/python-pyroute2.nslink-0.6.13-1.src.rpm
checksum_type: sha256
description:
  PyRoute2 is a pure Python **netlink** library.
  This module provides NetNS, NSPopen and RemoteSocket classes.


pkgId: 859d3abe2dea940baaff4b6c7f0e9d6e1b0f85b9b3030c3876897492b36ecf5c
name: python-pyrsistent
arch: src
version: 0.19.3
epoch: 0
release: 1
summary: Persistent/Functional/Immutable data structures
url: https://github.com/tobgu/pyrsistent/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f389d7e6-a66a-4d44-ada1-731d833d0b76
location_href: 00008938-python-pyrsistent/python-pyrsistent-0.19.3-1.src.rpm
checksum_type: sha256
description:
  Pyrsistent is a number of persistent collections (by some referred to as functional data structures). Persistent in
  the sense that they are immutable.
  All methods on a data structure that would normally mutate it instead return a new copy of the structure containing the
  requested updates. The original structure is left untouched.
  This will simplify the reasoning about what a program does since no hidden side effects ever can take place to these
  data structures. You can rest assured that the object you hold a reference to will remain the same throughout its
  lifetime and need not worry that somewhere five stack levels below you in the darkest corner of your application
  someone has decided to remove that element that you expected to be there.
  Pyrsistent is influenced by persistent data structures such as those found in the standard library of Clojure. The
  data structures are designed to share common elements through path copying.
  It aims at taking these concepts and make them as pythonic as possible so that they can be easily integrated into any python
  program without hassle.
  If you want use literal syntax to define them in your code rather
  than function calls check out Pyrthon_. Be aware, that one is experimental, unmaintained and alpha software.
  If you cannot find the persistent data structure you're looking for here you may want to take a look at
  Pyrsistent_extras_ which is maintained by @mingmingrr. If you still don't find what you're looking for please
  open an issue for discussion. If we agree that functionality is missing you may want to go ahead and create
  a Pull Request implement the missing functionality.


pkgId: 27d91e2f446badd7ed044e7435ba16248d22b5d785fc3e92e1fe4a10634a5956
name: python-pyrsistent-debuginfo
arch: aarch64
version: 0.19.3
epoch: 0
release: 1
summary: Debug information for package python-pyrsistent
url: https://github.com/tobgu/pyrsistent/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f389d7e6-a66a-4d44-ada1-731d833d0b76
rpm_sourcerpm: python-pyrsistent-0.19.3-1.src.rpm
location_href: 00008938-python-pyrsistent/python-pyrsistent-debuginfo-0.19.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyrsistent.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 6f68e02aeb9f0b7b72a50a575e7cd0a7ff2a0e0bdfe94398ef1e39108d1d58ec
name: python-pyrsistent-debugsource
arch: aarch64
version: 0.19.3
epoch: 0
release: 1
summary: Debug sources for package python-pyrsistent
url: https://github.com/tobgu/pyrsistent/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f389d7e6-a66a-4d44-ada1-731d833d0b76
rpm_sourcerpm: python-pyrsistent-0.19.3-1.src.rpm
location_href: 00008938-python-pyrsistent/python-pyrsistent-debugsource-0.19.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyrsistent.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 278e8889c7066356d64194d4e136c1f76b8e1c0f6dec63c6eed3df5eb55482ec
name: python-pyrtlsdr
arch: src
version: 0.2.93
epoch: 0
release: 1
summary: A Python wrapper for librtlsdr (a driver for Realtek RTL2832U based SDR's)
url: https://github.com/pyrtlsdr/pyrtlsdr
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d879bfc-6a9f-46c5-8f6a-c5860885afb3
location_href: 00004788-python-pyrtlsdr/python-pyrtlsdr-0.2.93-1.src.rpm
checksum_type: sha256
description:
  A Python wrapper for librtlsdr (a driver for Realtek RTL2832U based SDR's)

  [![PyPI](https://img.shields.io/pypi/v/pyrtlsdr)](https://pypi.org/project/pyrtlsdr) ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/pyrtlsdr/pyrtlsdr/Python%20package) ![PyPI - Downloads](https://img.shields.io/pypi/dm/pyrtlsdr) [![Coveralls](https://img.shields.io/coveralls/github/pyrtlsdr/pyrtlsdr)](https://coveralls.io/github/pyrtlsdr/pyrtlsdr)



  pyrtlsdr is a simple Python interface to devices supported by the RTL-SDR project, which turns certain USB DVB-T dongles
  employing the Realtek RTL2832U chipset into low-cost, general purpose software-defined radio receivers. It wraps many of the
  functions in the [librtlsdr library](https://github.com/librtlsdr/librtlsdr) including asynchronous read support
  and also provides a more Pythonic API.



  * Documentation:
    * https://pyrtlsdr.readthedocs.io/
  * Releases:
    * https://pypi.org/project/pyrtlsdr/
  * Source code and project home:
    * https://github.com/pyrtlsdr/pyrtlsdr
  * Releases for `librtlsdr`:
    * https://github.com/librtlsdr/librtlsdr/releases



  pyrtlsdr can be installed by downloading the source files and running `python setup.py install`, or using [pip](https://pip.pypa.io/en/stable/) and
  `pip install pyrtlsdr`.

  All functions in librtlsdr are accessible via librtlsdr.py and a Pythonic interface is available in rtlsdr.py (recommended).
  Some documentation can be found in docstrings in the latter file.





  ```python
  from rtlsdr import RtlSdr

  sdr = RtlSdr()


  sdr.sample_rate = 2.048e6  # Hz
  sdr.center_freq = 70e6     # Hz
  sdr.freq_correction = 60   # PPM
  sdr.gain = 'auto'

  print(sdr.read_samples(512))
  ```



  ```python
  from pylab import *
  from rtlsdr import *

  sdr = RtlSdr()


  sdr.sample_rate = 2.4e6
  sdr.center_freq = 95e6
  sdr.gain = 4

  samples = sdr.read_samples(256*1024)
  sdr.close()


  psd(samples, NFFT=1024, Fs=sdr.sample_rate/1e6, Fc=sdr.center_freq/1e6)
  xlabel('Frequency (MHz)')
  ylabel('Relative power (dB)')

  show()
  ```


  ![](https://i.imgur.com/hFhg8.png "Resulting Plot")

  See the files 'demo_waterfall.py' and 'test.py' for more examples.


  *(added in v2.5.6)*
  ```python
  from rtlsdr import RtlSdr


  serial_numbers = RtlSdr.get_device_serial_addresses()


  device_index = RtlSdr.get_device_index_by_serial('00000001')

  sdr = RtlSdr(device_index)



  sdr = RtlSdr(serial_number='00000001')
  ```


  Most devices by default have the same serial number: '0000001'. This can be set
  to a custom value by using the [rtl_eeprom][rtl_eeprom] utility packaged with `librtlsdr`.

  [rtl_eeprom]: https://manpages.ubuntu.com/manpages/trusty/man1/rtl_eeprom.1.html



  Two new submodules are available for testing: **rtlsdraio**, which adds native Python 3 asynchronous support (asyncio module), and **rtlsdrtcp** which adds a TCP server/client for accessing a device over the network. See the respective modules in the rtlsdr folder for more details and feel free to test and report any bugs!


  Note that the rtlsdraio module is automatically imported and adds `stream()` and `stop()` methods to the normal `RtlSdr` class. It also requires the new `async`/`await` syntax introduced in Python 3.5+.

  The syntax is basically:

  ```python
  import asyncio
  from rtlsdr import RtlSdr

  async def streaming():
      sdr = RtlSdr()

      async for samples in sdr.stream():
          
          

      
      await sdr.stop()

      
      sdr.close()

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


  The `RtlSdrTcpServer` class is meant to be connected physically to an SDR dongle and communicate with an instance of `RtlSdrTcpClient`. The client is intended to function as closely as possible to the base RtlSdr class (as if it had a physical dongle attached to it).

  Both of these classes have the same arguments as the base `RtlSdr` class with the addition of `hostname` and `port`:
  ```python
  server = RtlSdrTcpServer(hostname='192.168.1.100', port=12345)
  server.run_forever()

  ```
  ```python

  client = RtlSdrTcpClient(hostname='192.168.1.100', port=12345)
  client.center_freq = 2e6
  data = client.read_samples()
  ```


  On platforms where the `librtlsdr` library cannot be installed/compiled, it is possible to import the `RtlSdrTcpClient` only by setting the environment variable `"RTLSDR_CLIENT_MODE"` to `"true"`. If this is set, no other modules will be available.

  *Feature added in v0.2.4*




  * Windows/Linux/OSX
  * Python 2.7.x/3.3+
  * [librtlsdr](https://github.com/librtlsdr/librtlsdr/releases)
  * **Optional**: NumPy (wraps samples in a more convenient form)

  matplotlib is also useful for plotting data. The librtlsdr binaries (rtlsdr.dll in Windows and librtlsdr.so in Linux)
  should be in the pyrtlsdr directory, or a system path. Note that these binaries may have additional dependencies.



  There are a few remaining functions in librtlsdr that haven't been wrapped yet. It's a simple process if there's an additional
  function you need to add support for, and please send a pull request if you'd like to share your changes.



  * Some operating systems (Linux, OS X) seem to result in libusb buffer issues when performing small reads. Try reading 1024
  (or higher powers of two) samples at a time if you have problems.

  * If you're having librtlsdr import errors:
    * **Windows**: Make sure all the librtlsdr DLL files (librtlsdr.dll, libusb-1.0.dll) are in your system path, or the same folder
  as this README file. Also make sure you have all of *their* dependencies (e.g. libgcc_s_dw2-1.dll or possibly the Visual Studio runtime files). If rtl_sdr.exe
  works, then you should be okay. Also note that you can't mix the 64 bit version of Python with 32 bit builds of librtlsdr, and vice versa.
    * **Linux**: Make sure your LD_LIBRARY_PATH environment variable contains the directory where the librtlsdr.so.0 library is located. You can do this in a shell with (for example): `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib`. See [this issue](https://github.com/roger-/pyrtlsdr/issues/7) for more details.



  All of the code contained here is licensed by the GNU General Public License v3.



  Credit to dbasden for his earlier wrapper [python-librtlsdr](https://github.com/dbasden/python-librtlsdr) and all the
  contributors on GitHub.

  Copyright (C) 2013 by Roger <https://github.com/pyrtlsdr/pyrtlsdr>


pkgId: b05c52839e87464971b9b20adb2924ff2caf5e0a731d2ebf6e3d67b6163ce454
name: python-pysb
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: Python Systems Biology modeling framework
url: http://pysb.org/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-245e2fce-748d-4c0e-96b2-f660175093dc
location_href: 00004789-python-pysb/python-pysb-1.14.0-1.src.rpm
checksum_type: sha256
description:
  Python Systems Biology modeling framework
  http://pysb.org/
  PySB (pronounced "Pie Ess Bee") is a framework for building rule-based
  mathematical models of biochemical systems. It works nicely with
  scientific Python libraries such as NumPy, SciPy and SymPy for model
  simulation and analysis.


pkgId: 15fd7539aa2540bf48464245a905d82b81f371eb8acabbe99a3201f3743f02e1
name: python-pyscreenshot
arch: src
version: 3.1
epoch: 0
release: 1
summary: python screenshot
url: https://github.com/ponty/pyscreenshot
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c03f6ec4-c2ed-484b-b61d-1d7c41e24a03
location_href: 00011789-python-pyscreenshot/python-pyscreenshot-3.1-1.src.rpm
checksum_type: sha256
description:
  The pyscreenshot module is obsolete in most cases.
  It was created because PIL ImageGrab module worked on Windows only,
  but now Linux and macOS are also supported.
  There are some features in pyscreenshot which can be useful in special cases:
  flexible backends, Wayland support, sometimes better performance, optional subprocessing.

  The module can be used to copy the contents of the screen to a Pillow image memory using various back-ends.
  Replacement for the ImageGrab Module.

  Documentation: https://github.com/ponty/pyscreenshot/tree/3.1


pkgId: 6473dea9907746511d766b5d7c45ae8a9306c6135f4c582c021d8fe2def83222
name: python-pysctp
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: pysctp is a python module for the SCTP protocol stack and library
url: https://github.com/p1sec/pysctp
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0af8941b-f08f-4695-b8db-09af8e5f1716
location_href: 00004793-python-pysctp/python-pysctp-0.7.2-1.src.rpm
checksum_type: sha256
description:
  pysctp is a python wrapper for the SCTP protocol stack and library. On Mac OS X you will need the SCTP NKE (Kernel Extensions). On Linux systems, you need an SCTP-aware kernel (most are) and install the following packages (debian): apt install libsctp-dev libsctp1 lksctp-tools


pkgId: 2008fc4ca7c6c76584cdf98a9f5afe81222dde42ae6245dc9c79af75d3ebaffe
name: python-pyserial-asyncio
arch: src
version: 0.6
epoch: 0
release: 1
summary: Python Serial Port Extension - Asynchronous I/O support
url: https://github.com/pyserial/pyserial-asyncio
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61a5ac5a-8d6b-4516-a1d3-f510d3ef9b27
location_href: 00004795-python-pyserial-asyncio/python-pyserial-asyncio-0.6-1.src.rpm
checksum_type: sha256
description:
  Async I/O extension package for the Python Serial Port Extension for OSX, Linux, BSD

  - Documentation: http://pyserial-asyncio.readthedocs.io
  - Project Homepage: https://github.com/pyserial/pyserial-asyncio


pkgId: 61f9a6c41f79016528377eebf9e6990f83f98a2a613f3c345616258202dcd3da
name: python-pysftp
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: A friendly face on SFTP
url: https://bitbucket.org/dundeemt/pysftp
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-20737fe4-305b-4ccc-85d1-d9bda93bbb1f
location_href: 00009153-python-pysftp/python-pysftp-0.2.9-1.src.rpm
checksum_type: sha256
description:
  A simple interface to SFTP.  The module offers high level abstractions and
  task based routines to handle your SFTP needs.  Checkout the Cook Book, in the
  docs, to see what pysftp can do for you.


pkgId: 7fc48b628c795edbb9e22acd3fe3d61e4e58f08f994c3640dc5160ba581844ef
name: python-pyshark
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Python wrapper for tshark, allowing python packet parsing using wireshark dissectors
url: https://github.com/KimiNewt/pyshark
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bf1835d5-7705-457d-b1cf-07bb9270f16e
location_href: 00004796-python-pyshark/python-pyshark-0.5.3-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for tshark, allowing python packet parsing using wireshark dissectors.

  See https://github.com/KimiNewt/pyshark/ for documentation.


pkgId: c4ce614d6576195aa1042ff59184ad3ceb9859f30f147f5553b04c96fe06e4a9
name: python-pyshorteners
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A Python lib to wrap and consume the most used shorteners APIs
url: https://github.com/ellisonleao/pyshorteners/
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-365f9fa2-8a0c-48e7-b996-6c13c5bbf6d4
location_href: 00011307-python-pyshorteners/python-pyshorteners-1.0.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
      <img src="https://blog.shareaholic.com/wp-content/uploads/2015/06/shortlink.png" alt="logo"/><br>
      pyshorteners
  </h1>

  <hr/>

  <p align="center">
      <a href="https://github.com/ellisonleao/pyshorteners/actions"><img src="https://github.com/ellisonleao/pyshorteners/workflows/build/badge.svg" alt="Travis"/></a>
      <a href="https://saythanks.io/to/ellisonleao"><img src="https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg" alt=""/></a>
      <a href="https://pyshorteners.readthedocs.io/en/latest/"><img src="https://img.shields.io/pypi/dw/pyshorteners.svg" alt="Download stats"/></a>
  </p>

  A simple URL shortening API wrapper Python library.



      pip install pyshorteners



  https://pyshorteners.readthedocs.io/en/latest/


pkgId: d4b1e34159f116b726f6d32dc1d64b8802cf31703e84214ecc0863582acd3110
name: python-pyshp
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Pure Python read/write support for ESRI Shapefile format
url: https://github.com/GeospatialPython/pyshp
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-940b2d68-4fd4-4a9e-a9d9-2374d066cd42
location_href: 00004797-python-pyshp/python-pyshp-2.3.1-1.src.rpm
checksum_type: sha256
description:
  The Python Shapefile Library (PyShp) reads and writes ESRI Shapefiles in pure Python.

  ![pyshp logo](http://4.bp.blogspot.com/_SBi37QEsCvg/TPQuOhlHQxI/AAAAAAAAAE0/QjFlWfMx0tQ/S350/GSP_Logo.png "PyShp")

  ![build status](https://github.com/GeospatialPython/pyshp/actions/workflows/build.yml/badge.svg)

  - **Author**: [Joel Lawhead](https://github.com/GeospatialPython)
  - **Maintainers**: [Karim Bahgat](https://github.com/karimbahgat)
  - **Version**: 2.3.0
  - **Date**: 30 April, 2022
  - **License**: [MIT](https://github.com/GeospatialPython/pyshp/blob/master/LICENSE.TXT)



  - [Overview](#overview)
  - [Version Changes](#version-changes)
  - [The Basics](#the-basics)
  	- [Reading Shapefiles](#reading-shapefiles)
  		- [The Reader Class](#the-reader-class)
  			- [Reading Shapefiles from Local Files](#reading-shapefiles-from-local-files)
  			- [Reading Shapefiles from Zip Files](#reading-shapefiles-from-zip-files)
  			- [Reading Shapefiles from URLs](#reading-shapefiles-from-urls)
  			- [Reading Shapefiles from File-Like Objects](#reading-shapefiles-from-file-like-objects)
  			- [Reading Shapefiles Using the Context Manager](#reading-shapefiles-using-the-context-manager)
  			- [Reading Shapefile Meta-Data](#reading-shapefile-meta-data)
  		- [Reading Geometry](#reading-geometry)
  		- [Reading Records](#reading-records)
  		- [Reading Geometry and Records Simultaneously](#reading-geometry-and-records-simultaneously)
  	- [Writing Shapefiles](#writing-shapefiles)
  		- [The Writer Class](#the-writer-class)
  			- [Writing Shapefiles to Local Files](#writing-shapefiles-to-local-files)
  			- [Writing Shapefiles to File-Like Objects](#writing-shapefiles-to-file-like-objects)
  			- [Writing Shapefiles Using the Context Manager](#writing-shapefiles-using-the-context-manager)
  			- [Setting the Shape Type](#setting-the-shape-type)
  		- [Adding Records](#adding-records)
  		- [Adding Geometry](#adding-geometry)
  		- [Geometry and Record Balancing](#geometry-and-record-balancing)
  - [Advanced Use](#advanced-use)
      - [Common Errors and Fixes](#common-errors-and-fixes)
          - [Warnings and Logging](#warnings-and-logging)
          - [Shapefile Encoding Errors](#shapefile-encoding-errors)
  	- [Reading Large Shapefiles](#reading-large-shapefiles)
  		- [Iterating through a shapefile](#iterating-through-a-shapefile)
  		- [Limiting which fields to read](#limiting-which-fields-to-read)
  		- [Attribute filtering](#attribute-filtering)
  		- [Spatial filtering](#spatial-filtering)
  	- [Writing large shapefiles](#writing-large-shapefiles)
  		- [Merging multiple shapefiles](#merging-multiple-shapefiles)
  		- [Editing shapefiles](#editing-shapefiles)
  	- [3D and Other Geometry Types](#3d-and-other-geometry-types)
      	- [Shapefiles with measurement (M) values](#shapefiles-with-measurement-m-values)
  		- [Shapefiles with elevation (Z) values](#shapefiles-with-elevation-z-values)
  		- [3D MultiPatch Shapefiles](#3d-multipatch-shapefiles)
  - [Testing](#testing)
  - [Contributors](#contributors)




  The Python Shapefile Library (PyShp) provides read and write support for the
  Esri Shapefile format. The Shapefile format is a popular Geographic
  Information System vector data format created by Esri. For more information
  about this format please read the well-written "ESRI Shapefile Technical
  Description - July 1998" located at [http://www.esri.com/library/whitepapers/p
  dfs/shapefile.pdf](http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf)
  . The Esri document describes the shp and shx file formats. However a third
  file format called dbf is also required. This format is documented on the web
  as the "XBase File Format Description" and is a simple file-based database
  format created in the 1960's. For more on this specification see: [http://www.clicketyclick.dk/databases/xbase/format/index.html](http://www.clicketyclick.dk/databases/xbase/format/index.html)

  Both the Esri and XBase file-formats are very simple in design and memory
  efficient which is part of the reason the shapefile format remains popular
  despite the numerous ways to store and exchange GIS data available today.

  Pyshp is compatible with Python 2.7-3.x.

  This document provides examples for using PyShp to read and write shapefiles. However
  many more examples are continually added to the blog [http://GeospatialPython.com](http://GeospatialPython.com),
  and by searching for PyShp on [https://gis.stackexchange.com](https://gis.stackexchange.com).

  Currently the sample census blockgroup shapefile referenced in the examples is available on the GitHub project site at
  [https://github.com/GeospatialPython/pyshp](https://github.com/GeospatialPython/pyshp). These
  examples are straight-forward and you can also easily run them against your
  own shapefiles with minimal modification.

  Important: If you are new to GIS you should read about map projections.
  Please visit: [https://github.com/GeospatialPython/pyshp/wiki/Map-Projections](https://github.com/GeospatialPython/pyshp/wiki/Map-Projections)

  I sincerely hope this library eliminates the mundane distraction of simply
  reading and writing data, and allows you to focus on the challenging and FUN
  part of your geospatial project.








  - Fix recently introduced issue where Reader/Writer closes file-like objects provided by user (#244)





  - Added support for pathlib and path-like shapefile filepaths (@mwtoews).
  - Allow reading individual file extensions via filepaths.



  - Simplified setup and deployment (@mwtoews)
  - Faster shape access when missing shx file
  - Switch to named logger (see #240)



  - More robust handling of corrupt shapefiles (fixes #235)
  - Fix errors when writing to individual file-handles (fixes #237)
  - Revert previous decision to enforce geojson output ring orientation (detailed explanation at https://github.com/SciTools/cartopy/issues/2012)
  - Fix test issues in environments without network access (@sebastic, @musicinmybrain).





  - Read shapefiles directly from zipfiles.
  - Read shapefiles directly from urls.
  - Allow fast extraction of only a subset of dbf fields through a `fields` arg.
  - Allow fast filtering which shapes to read from the file through a `bbox` arg.



  - More examples and restructuring of README.
  - More informative Shape to geojson warnings (see #219).
  - Add shapefile.VERBOSE flag to control warnings verbosity (default True).
  - Shape object information when calling repr().
  - Faster ring orientation checks, enforce geojson output ring orientation.



  - Remove null-padding at end of some record character fields.
  - Fix dbf writing error when the number of record list or dict entries didn't match the number of fields.
  - Handle rare garbage collection issue after deepcopy (https://github.com/mattijn/topojson/issues/120)
  - Fix bug where records and shapes would be assigned incorrect record number (@karanrn)
  - Fix typos in docs (@timgates)





  - Fix recent bug in geojson hole-in-polygon checking (see #205)
  - Misc fixes to allow geo interface dump to json (eg dates as strings)
  - Handle additional dbf date null values, and return faulty dates as unicode (see #187)
  - Add writer target typecheck
  - Fix bugs to allow reading shp/shx/dbf separately
  - Allow delayed shapefile loading by passing no args
  - Fix error with writing empty z/m shapefile (@mcuprjak)
  - Fix signed_area() so ignores z/m coords
  - Enforce writing the 11th field name character as null-terminator (only first 10 are used)
  - Minor README fixes
  - Added more tests





  - Fix issue where warnings.simplefilter('always') changes global warning behavior [see #203]





  - Handle shapes with no coords and represent as geojson with no coords (GeoJSON null-equivalent)
  - Expand testing to Python 3.6, 3.7, 3.8 and PyPy; drop 3.3 and 3.4 [@mwtoews]
  - Added pytest testing [@jmoujaes]



  - Fix incorrect geo interface handling of multipolygons with complex exterior-hole relations [see #202]
  - Enforce shapefile requirement of at least one field, to avoid writing invalid shapefiles [@Jonty]
  - Fix Reader geo interface including DeletionFlag field in feature properties [@nnseva]
  - Fix polygons not being auto closed, which was accidentally dropped
  - Fix error for null geometries in feature geojson
  - Misc docstring cleanup [@fiveham]





  - Added back read/write support for unicode field names.
  - Improved Record representation
  - More support for geojson on Reader, ShapeRecord, ShapeRecords, and shapes()



  - Fixed error when reading optional m-values
  - Fixed Record attribute autocomplete in Python 3
  - Misc readme cleanup



  The newest version of PyShp, version 2.0 introduced some major new improvements.
  A great thanks to all who have contributed code and raised issues, and for everyone's
  patience and understanding during the transition period.
  Some of the new changes are incompatible with previous versions.
  Users of the previous version 1.x should therefore take note of the following changes
  (Note: Some contributor attributions may be missing):



  - Full support for unicode text, with custom encoding, and exception handling.
    - Means that the Reader returns unicode, and the Writer accepts unicode.
  - PyShp has been simplified to a pure input-output library using the Reader and Writer classes, dropping the Editor class.
  - Switched to a new streaming approach when writing files, keeping memory-usage at a minimum:
    - Specify filepath/destination and text encoding when creating the Writer.
    - The file is written incrementally with each call to shape/record.
    - Adding shapes is now done using dedicated methods for each shapetype.
  - Reading shapefiles is now more convenient:
    - Shapefiles can be opened using the context manager, and files are properly closed.
    - Shapefiles can be iterated, have a length, and supports the geo interface.
    - New ways of inspecting shapefile metadata by printing. [@megies]
    - More convenient accessing of Record values as attributes. [@philippkraft]
    - More convenient shape type name checking. [@megies]
  - Add more support and documentation for MultiPatch 3D shapes.
  - The Reader "elevation" and "measure" attributes now renamed "zbox" and "mbox", to make it clear they refer to the min/max values.
  - Better documentation of previously unclear aspects, such as field types.



  - More reliable/robust:
    - Fixed shapefile bbox error for empty or point type shapefiles. [@mcuprjak]
    - Reading and writing Z and M type shapes is now more robust, fixing many errors, and has been added to the documentation. [@ShinNoNoir]
    - Improved parsing of field value types, fixed errors and made more flexible.
    - Fixed bug when writing shapefiles with datefield and date values earlier than 1900 [@megies]
  - Fix some geo interface errors, including checking polygon directions.
  - Bug fixes for reading from case sensitive file names, individual files separately, and from file-like objects. [@gastoneb, @kb003308, @erickskb]
  - Enforce maximum field limit. [@mwtoews]




  Before doing anything you must import the library.


  	>>> import shapefile

  The examples below will use a shapefile created from the U.S. Census Bureau
  Blockgroups data set near San Francisco, CA and available in the git
  repository of the PyShp GitHub site.







  To read a shapefile create a new "Reader" object and pass it the name of an
  existing shapefile. The shapefile format is actually a collection of three
  files. You specify the base filename of the shapefile or the complete filename
  of any of the shapefile component files.


  	>>> sf = shapefile.Reader("shapefiles/blockgroups")

  OR


  	>>> sf = shapefile.Reader("shapefiles/blockgroups.shp")

  OR


  	>>> sf = shapefile.Reader("shapefiles/blockgroups.dbf")

  OR any of the other 5+ formats which are potentially part of a shapefile. The
  library does not care about file extensions. You can also specify that you only
  want to read some of the file extensions through the use of keyword arguments:


  	>>> sf = shapefile.Reader(dbf="shapefiles/blockgroups.dbf")



  If your shapefile is wrapped inside a zip file, the library is able to handle that too, meaning you don't have to worry about unzipping the contents:


  	>>> sf = shapefile.Reader("shapefiles/blockgroups.zip")

  If the zip file contains multiple shapefiles, just specify which shapefile to read by additionally specifying the relative path after the ".zip" part:


  	>>> sf = shapefile.Reader("shapefiles/blockgroups_multishapefile.zip/blockgroups2.shp")



  Finally, you can use all of the above methods to read shapefiles directly from the internet, by giving a url instead of a local path, e.g.:


  	>>> # from a zipped shapefile on website
  	>>> sf = shapefile.Reader("https://biogeo.ucdavis.edu/data/diva/rrd/NIC_rrd.zip")

  	>>> # from a shapefile collection of files in a github repository
  	>>> sf = shapefile.Reader("https://github.com/nvkelso/natural-earth-vector/blob/master/110m_cultural/ne_110m_admin_0_tiny_countries.shp?raw=true")

  This will automatically download the file(s) to a temporary location before reading, saving you a lot of time and repetitive boilerplate code when you just want quick access to some external data.



  You can also load shapefiles from any Python file-like object using keyword
  arguments to specify any of the three files. This feature is very powerful and
  allows you to custom load shapefiles from arbitrary storage formats, such as a protected url or zip file, a serialized object, or in some cases a database.


  	>>> myshp = open("shapefiles/blockgroups.shp", "rb")
  	>>> mydbf = open("shapefiles/blockgroups.dbf", "rb")
  	>>> r = shapefile.Reader(shp=myshp, dbf=mydbf)

  Notice in the examples above the shx file is never used. The shx file is a
  very simple fixed-record index for the variable-length records in the shp
  file. This file is optional for reading. If it's available PyShp will use the
  shx file to access shape records a little faster but will do just fine without
  it.



  The "Reader" class can be used as a context manager, to ensure open file
  objects are properly closed when done reading the data:

      >>> with shapefile.Reader("shapefiles/blockgroups.shp") as shp:
      ...     print(shp)
      shapefile Reader
          663 shapes (type 'POLYGON')
          663 records (44 fields)



  Shapefiles have a number of attributes for inspecting the file contents.
  A shapefile is a container for a specific type of geometry, and this can be checked using the
  shapeType attribute.


  	>>> sf = shapefile.Reader("shapefiles/blockgroups.dbf")
  	>>> sf.shapeType
  	5

  Shape types are represented by numbers between 0 and 31 as defined by the
  shapefile specification and listed below. It is important to note that the numbering system has
  several reserved numbers that have not been used yet, therefore the numbers of
  the existing shape types are not sequential:

  - NULL = 0
  - POINT = 1
  - POLYLINE = 3
  - POLYGON = 5
  - MULTIPOINT = 8
  - POINTZ = 11
  - POLYLINEZ = 13
  - POLYGONZ = 15
  - MULTIPOINTZ = 18
  - POINTM = 21
  - POLYLINEM = 23
  - POLYGONM = 25
  - MULTIPOINTM = 28
  - MULTIPATCH = 31

  Based on this we can see that our blockgroups shapefile contains
  Polygon type shapes. The shape types are also defined as constants in
  the shapefile module, so that we can compare types more intuitively:


  	>>> sf.shapeType == shapefile.POLYGON
  	True

  For convenience, you can also get the name of the shape type as a string:


  	>>> sf.shapeTypeName == 'POLYGON'
  	True

  Other pieces of meta-data that we can check include the number of features
  and the bounding box area the shapefile covers:


  	>>> len(sf)
  	663
  	>>> sf.bbox
  	[-122.515048, 37.652916, -122.327622, 37.863433]

  Finally, if you would prefer to work with the entire shapefile in a different
  format, you can convert all of it to a GeoJSON dictionary, although you may lose
  some information in the process, such as z- and m-values:


  	>>> sf.__geo_interface__['type']
  	'FeatureCollection'



  A shapefile's geometry is the collection of points or shapes made from
  vertices and implied arcs representing physical locations. All types of
  shapefiles just store points. The metadata about the points determine how they
  are handled by software.

  You can get a list of the shapefile's geometry by calling the shapes()
  method.


  	>>> shapes = sf.shapes()

  The shapes method returns a list of Shape objects describing the geometry of
  each shape record.


  	>>> len(shapes)
  	663

  To read a single shape by calling its index use the shape() method. The index
  is the shape's count from 0. So to read the 8th shape record you would use its
  index which is 7.


  	>>> s = sf.shape(7)
  	>>> s
  	Shape #7: POLYGON

  	>>> # Read the bbox of the 8th shape to verify
  	>>> # Round coordinates to 3 decimal places
  	>>> ['%.3f' % coord for coord in s.bbox]
  	['-122.450', '37.801', '-122.442', '37.808']

  Each shape record (except Points) contains the following attributes. Records of
  shapeType Point do not have a bounding box 'bbox'.


  	>>> for name in dir(shapes[3]):
  	...     if not name.startswith('_'):
  	...         name
  	'bbox'
  	'oid'
  	'parts'
  	'points'
  	'shapeType'
  	'shapeTypeName'

    * `oid`: The shape's index position in the original shapefile.


  		>>> shapes[3].oid
  		3

    * `shapeType`: an integer representing the type of shape as defined by the
  	  shapefile specification.


  		>>> shapes[3].shapeType
  		5

    * `shapeTypeName`: a string representation of the type of shape as defined by shapeType. Read-only.


  		>>> shapes[3].shapeTypeName
  		'POLYGON'

    * `bbox`: If the shape type contains multiple points this tuple describes the
  	  lower left (x,y) coordinate and upper right corner coordinate creating a
  	  complete box around the points. If the shapeType is a
  	  Null (shapeType == 0) then an AttributeError is raised.


  		>>> # Get the bounding box of the 4th shape.
  		>>> # Round coordinates to 3 decimal places
  		>>> bbox = shapes[3].bbox
  		>>> ['%.3f' % coord for coord in bbox]
  		['-122.486', '37.787', '-122.446', '37.811']

    * `parts`: Parts simply group collections of points into shapes. If the shape
  	  record has multiple parts this attribute contains the index of the first
  	  point of each part. If there is only one part then a list containing 0 is
  	  returned.


  		>>> shapes[3].parts
  		[0]

    * `points`: The points attribute contains a list of tuples containing an
  	  (x,y) coordinate for each point in the shape.


  		>>> len(shapes[3].points)
  		173
  		>>> # Get the 8th point of the fourth shape
  		>>> # Truncate coordinates to 3 decimal places
  		>>> shape = shapes[3].points[7]
  		>>> ['%.3f' % coord for coord in shape]
  		['-122.471', '37.787']

  In most cases, however, if you need to do more than just type or bounds checking, you may want
  to convert the geometry to the more human-readable [GeoJSON format](http://geojson.org),
  where lines and polygons are grouped for you:


  	>>> s = sf.shape(0)
  	>>> geoj = s.__geo_interface__
  	>>> geoj["type"]
  	'MultiPolygon'

  The results from the shapes() method similarly supports converting to GeoJSON:


  	>>> shapes.__geo_interface__['type']
  	'GeometryCollection'

  Note: In some cases, if the conversion from shapefile geometry to GeoJSON encountered any problems
  or potential issues, a warning message will be displayed with information about the affected
  geometry. To ignore or suppress these warnings, you can disable this behavior by setting the
  module constant VERBOSE to False:


  	>>> shapefile.VERBOSE = False




  A record in a shapefile contains the attributes for each shape in the
  collection of geometries. Records are stored in the dbf file. The link between
  geometry and attributes is the foundation of all geographic information systems.
  This critical link is implied by the order of shapes and corresponding records
  in the shp geometry file and the dbf attribute file.

  The field names of a shapefile are available as soon as you read a shapefile.
  You can call the "fields" attribute of the shapefile as a Python list. Each
  field is a Python list with the following information:

    * Field name: the name describing the data at this column index.
    * Field type: the type of data at this column index. Types can be:
         * "C": Characters, text.
  	   * "N": Numbers, with or without decimals.
  	   * "F": Floats (same as "N").
  	   * "L": Logical, for boolean True/False values.
  	   * "D": Dates.
  	   * "M": Memo, has no meaning within a GIS and is part of the xbase spec instead.
    * Field length: the length of the data found at this column index. Older GIS
  	   software may truncate this length to 8 or 11 characters for "Character"
  	   fields.
    * Decimal length: the number of decimal places found in "Number" fields.

  To see the fields for the Reader object above (sf) call the "fields"
  attribute:


  	>>> fields = sf.fields

  	>>> assert fields == [("DeletionFlag", "C", 1, 0), ["AREA", "N", 18, 5],
  	... ["BKG_KEY", "C", 12, 0], ["POP1990", "N", 9, 0], ["POP90_SQMI", "N", 10, 1],
  	... ["HOUSEHOLDS", "N", 9, 0],
  	... ["MALES", "N", 9, 0], ["FEMALES", "N", 9, 0], ["WHITE", "N", 9, 0],
  	... ["BLACK", "N", 8, 0], ["AMERI_ES", "N", 7, 0], ["ASIAN_PI", "N", 8, 0],
  	... ["OTHER", "N", 8, 0], ["HISPANIC", "N", 8, 0], ["AGE_UNDER5", "N", 8, 0],
  	... ["AGE_5_17", "N", 8, 0], ["AGE_18_29", "N", 8, 0], ["AGE_30_49", "N", 8, 0],
  	... ["AGE_50_64", "N", 8, 0], ["AGE_65_UP", "N", 8, 0],
  	... ["NEVERMARRY", "N", 8, 0], ["MARRIED", "N", 9, 0], ["SEPARATED", "N", 7, 0],
  	... ["WIDOWED", "N", 8, 0], ["DIVORCED", "N", 8, 0], ["HSEHLD_1_M", "N", 8, 0],
  	... ["HSEHLD_1_F", "N", 8, 0], ["MARHH_CHD", "N", 8, 0],
  	... ["MARHH_NO_C", "N", 8, 0], ["MHH_CHILD", "N", 7, 0],
  	... ["FHH_CHILD", "N", 7, 0], ["HSE_UNITS", "N", 9, 0], ["VACANT", "N", 7, 0],
  	... ["OWNER_OCC", "N", 8, 0], ["RENTER_OCC", "N", 8, 0],
  	... ["MEDIAN_VAL", "N", 7, 0], ["MEDIANRENT", "N", 4, 0],
  	... ["UNITS_1DET", "N", 8, 0], ["UNITS_1ATT", "N", 7, 0], ["UNITS2", "N", 7, 0],
  	... ["UNITS3_9", "N", 8, 0], ["UNITS10_49", "N", 8, 0],
  	... ["UNITS50_UP", "N", 8, 0], ["MOBILEHOME", "N", 7, 0]]

  The first field of a dbf file is always a 1-byte field called "DeletionFlag",
  which indicates records that have been deleted but not removed. However,
  since this flag is very rarely used, PyShp currently will return all records
  regardless of their deletion flag, and the flag is also not included in the list of
  record values. In other words, the DeletionFlag field has no real purpose, and
  should in most cases be ignored. For instance, to get a list of all fieldnames:


  	>>> fieldnames = [f[0] for f in sf.fields[1:]]

  You can get a list of the shapefile's records by calling the records() method:


  	>>> records = sf.records()

  	>>> len(records)
  	663

  To read a single record call the record() method with the record's index:


  	>>> rec = sf.record(3)

  Each record is a list-like Record object containing the values corresponding to each field in
  the field list (except the DeletionFlag). A record's values can be accessed by positional indexing or slicing.
  For example in the blockgroups shapefile the 2nd and 3rd fields are the blockgroup id
  and the 1990 population count of that San Francisco blockgroup:


  	>>> rec[1:3]
  	['060750601001', 4715]

  For simpler access, the fields of a record can also accessed via the name of the field,
  either as a key or as an attribute name. The blockgroup id (BKG_KEY) of the blockgroups shapefile
  can also be retrieved as:


      >>> rec['BKG_KEY']
      '060750601001'

      >>> rec.BKG_KEY
      '060750601001'

  The record values can be easily integrated with other programs by converting it to a field-value dictionary:


  	>>> dct = rec.as_dict()
  	>>> sorted(dct.items())
  	[('AGE_18_29', 1467), ('AGE_30_49', 1681), ('AGE_50_64', 92), ('AGE_5_17', 848), ('AGE_65_UP', 30), ('AGE_UNDER5', 597), ('AMERI_ES', 6), ('AREA', 2.34385), ('ASIAN_PI', 452), ('BKG_KEY', '060750601001'), ('BLACK', 1007), ('DIVORCED', 149), ('FEMALES', 2095), ('FHH_CHILD', 16), ('HISPANIC', 416), ('HOUSEHOLDS', 1195), ('HSEHLD_1_F', 40), ('HSEHLD_1_M', 22), ('HSE_UNITS', 1258), ('MALES', 2620), ('MARHH_CHD', 79), ('MARHH_NO_C', 958), ('MARRIED', 2021), ('MEDIANRENT', 739), ('MEDIAN_VAL', 337500), ('MHH_CHILD', 0), ('MOBILEHOME', 0), ('NEVERMARRY', 703), ('OTHER', 288), ('OWNER_OCC', 66), ('POP1990', 4715), ('POP90_SQMI', 2011.6), ('RENTER_OCC', 3733), ('SEPARATED', 49), ('UNITS10_49', 49), ('UNITS2', 160), ('UNITS3_9', 672), ('UNITS50_UP', 0), ('UNITS_1ATT', 302), ('UNITS_1DET', 43), ('VACANT', 93), ('WHITE', 2962), ('WIDOWED', 37)]

  If at a later point you need to check the record's index position in the original
  shapefile, you can do this through the "oid" attribute:


  	>>> rec.oid
  	3



  You may want to examine both the geometry and the attributes for a record at
  the same time. The shapeRecord() and shapeRecords() method let you do just
  that.

  Calling the shapeRecords() method will return the geometry and attributes for
  all shapes as a list of ShapeRecord objects. Each ShapeRecord instance has a
  "shape" and "record" attribute. The shape attribute is a Shape object as
  discussed in the first section "Reading Geometry". The record attribute is a
  list-like object containing field values as demonstrated in the "Reading Records" section.


  	>>> shapeRecs = sf.shapeRecords()

  Let's read the blockgroup key and the population for the 4th blockgroup:


  	>>> shapeRecs[3].record[1:3]
  	['060750601001', 4715]

  The results from the shapeRecords() method is a list-like object that can be easily converted
  to GeoJSON through the _\_geo_interface\_\_:


  	>>> shapeRecs.__geo_interface__['type']
  	'FeatureCollection'

  The shapeRecord() method reads a single shape/record pair at the specified index.
  To get the 4th shape record from the blockgroups shapefile use the third index:


  	>>> shapeRec = sf.shapeRecord(3)
  	>>> shapeRec.record[1:3]
  	['060750601001', 4715]

  Each individual shape record also supports the _\_geo_interface\_\_ to convert it to a GeoJSON feature:


  	>>> shapeRec.__geo_interface__['type']
  	'Feature'






  PyShp tries to be as flexible as possible when writing shapefiles while
  maintaining some degree of automatic validation to make sure you don't
  accidentally write an invalid file.

  PyShp can write just one of the component files such as the shp or dbf file
  without writing the others. So in addition to being a complete shapefile
  library, it can also be used as a basic dbf (xbase) library. Dbf files are a
  common database format which are often useful as a standalone simple database
  format. And even shp files occasionally have uses as a standalone format. Some
  web-based GIS systems use an user-uploaded shp file to specify an area of
  interest. Many precision agriculture chemical field sprayers also use the shp
  format as a control file for the sprayer system (usually in combination with
  custom database file formats).



  To create a shapefile you begin by initiating a new Writer instance, passing it
  the file path and name to save to:


  	>>> w = shapefile.Writer('shapefiles/test/testfile')
  	>>> w.field('field1', 'C')

  File extensions are optional when reading or writing shapefiles. If you specify
  them PyShp ignores them anyway. When you save files you can specify a base
  file name that is used for all three file types. Or you can specify a name for
  one or more file types:


  	>>> w = shapefile.Writer(dbf='shapefiles/test/onlydbf.dbf')
  	>>> w.field('field1', 'C')

  In that case, any file types not assigned will not
  save and only file types with file names will be saved.



  Just as you can read shapefiles from python file-like objects you can also
  write to them:


  	>>> try:
  	...     from StringIO import StringIO
  	... except ImportError:
  	...     from io import BytesIO as StringIO
  	>>> shp = StringIO()
  	>>> shx = StringIO()
  	>>> dbf = StringIO()
  	>>> w = shapefile.Writer(shp=shp, shx=shx, dbf=dbf)
  	>>> w.field('field1', 'C')
  	>>> w.record()
  	>>> w.null()
  	>>> w.close()

  	>>> # To read back the files you could call the "StringIO.getvalue()" method later.
  	>>> assert shp.getvalue()
  	>>> assert shx.getvalue()
  	>>> assert dbf.getvalue()

  	>>> # In fact, you can read directly from them using the Reader
  	>>> r = shapefile.Reader(shp=shp, shx=shx, dbf=dbf)
  	>>> len(r)
  	1





  The "Writer" class automatically closes the open files and writes the final headers once it is garbage collected.
  In case of a crash and to make the code more readable, it is nevertheless recommended
  you do this manually by calling the "close()" method:


  	>>> w.close()

  Alternatively, you can also use the "Writer" class as a context manager, to ensure open file
  objects are properly closed and final headers written once you exit the with-clause:


  	>>> with shapefile.Writer("shapefiles/test/contextwriter") as w:
  	... 	w.field('field1', 'C')
  	... 	pass



  The shape type defines the type of geometry contained in the shapefile. All of
  the shapes must match the shape type setting.

  There are three ways to set the shape type:
    * Set it when creating the class instance.
    * Set it by assigning a value to an existing class instance.
    * Set it automatically to the type of the first non-null shape by saving the shapefile.

  To manually set the shape type for a Writer object when creating the Writer:


  	>>> w = shapefile.Writer('shapefiles/test/shapetype', shapeType=3)
  	>>> w.field('field1', 'C')

  	>>> w.shapeType
  	3

  OR you can set it after the Writer is created:


  	>>> w.shapeType = 1

  	>>> w.shapeType
  	1




  Before you can add records you must first create the fields that define what types of
  values will go into each attribute.

  There are several different field types, all of which support storing None values as NULL.

  Text fields are created using the 'C' type, and the third 'size' argument can be customized to the expected
  length of text values to save space:


  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('TEXT', 'C')
  	>>> w.field('SHORT_TEXT', 'C', size=5)
  	>>> w.field('LONG_TEXT', 'C', size=250)
  	>>> w.null()
  	>>> w.record('Hello', 'World', 'World'*50)
  	>>> w.close()

  	>>> r = shapefile.Reader('shapefiles/test/dtype')
  	>>> assert r.record(0) == ['Hello', 'World', 'World'*50]

  Date fields are created using the 'D' type, and can be created using either
  date objects, lists, or a YYYYMMDD formatted string.
  Field length or decimal have no impact on this type:


  	>>> from datetime import date
  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('DATE', 'D')
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.record(date(1898,1,30))
  	>>> w.record([1998,1,30])
  	>>> w.record('19980130')
  	>>> w.record(None)
  	>>> w.close()

  	>>> r = shapefile.Reader('shapefiles/test/dtype')
  	>>> assert r.record(0) == [date(1898,1,30)]
  	>>> assert r.record(1) == [date(1998,1,30)]
  	>>> assert r.record(2) == [date(1998,1,30)]
  	>>> assert r.record(3) == [None]

  Numeric fields are created using the 'N' type (or the 'F' type, which is exactly the same).
  By default the fourth decimal argument is set to zero, essentially creating an integer field.
  To store floats you must set the decimal argument to the precision of your choice.
  To store very large numbers you must increase the field length size to the total number of digits
  (including comma and minus).


  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('INT', 'N')
  	>>> w.field('LOWPREC', 'N', decimal=2)
  	>>> w.field('MEDPREC', 'N', decimal=10)
  	>>> w.field('HIGHPREC', 'N', decimal=30)
  	>>> w.field('FTYPE', 'F', decimal=10)
  	>>> w.field('LARGENR', 'N', 101)
  	>>> nr = 1.3217328
  	>>> w.null()
  	>>> w.null()
  	>>> w.record(INT=nr, LOWPREC=nr, MEDPREC=nr, HIGHPREC=-3.2302e-25, FTYPE=nr, LARGENR=int(nr)*10**100)
  	>>> w.record(None, None, None, None, None, None)
  	>>> w.close()

  	>>> r = shapefile.Reader('shapefiles/test/dtype')
  	>>> assert r.record(0) == [1, 1.32, 1.3217328, -3.2302e-25, 1.3217328, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
  	>>> assert r.record(1) == [None, None, None, None, None, None]


  Finally, we can create boolean fields by setting the type to 'L'.
  This field can take True or False values, or 1 (True) or 0 (False).
  None is interpreted as missing.


  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('BOOLEAN', 'L')
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.record(True)
  	>>> w.record(1)
  	>>> w.record(False)
  	>>> w.record(0)
  	>>> w.record(None)
  	>>> w.record("Nonesense")
  	>>> w.close()

  	>>> r = shapefile.Reader('shapefiles/test/dtype')
  	>>> r.record(0)
  	Record #0: [True]
  	>>> r.record(1)
  	Record #1: [True]
  	>>> r.record(2)
  	Record #2: [False]
  	>>> r.record(3)
  	Record #3: [False]
  	>>> r.record(4)
  	Record #4: [None]
  	>>> r.record(5)
  	Record #5: [None]

  You can also add attributes using keyword arguments where the keys are field names.


  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('FIRST_FLD','C','40')
  	>>> w.field('SECOND_FLD','C','40')
  	>>> w.null()
  	>>> w.null()
  	>>> w.record('First', 'Line')
  	>>> w.record(FIRST_FLD='First', SECOND_FLD='Line')
  	>>> w.close()



  Geometry is added using one of several convenience methods. The "null" method is used
  for null shapes, "point" is used for point shapes, "multipoint" is used for multipoint shapes, "line" for lines,
  "poly" for polygons.

  **Adding a Null shape**

  A shapefile may contain some records for which geometry is not available, and may be set using the "null" method.
  Because Null shape types (shape type 0) have no geometry the "null" method is called without any arguments.


  	>>> w = shapefile.Writer('shapefiles/test/null')
  	>>> w.field('name', 'C')

  	>>> w.null()
  	>>> w.record('nullgeom')

  	>>> w.close()

  **Adding a Point shape**

  Point shapes are added using the "point" method. A point is specified by an x and
  y value.


  	>>> w = shapefile.Writer('shapefiles/test/point')
  	>>> w.field('name', 'C')

  	>>> w.point(122, 37)
  	>>> w.record('point1')

  	>>> w.close()

  **Adding a MultiPoint shape**

  If your point data allows for the possibility of multiple points per feature, use "multipoint" instead.
  These are specified as a list of xy point coordinates.


  	>>> w = shapefile.Writer('shapefiles/test/multipoint')
  	>>> w.field('name', 'C')

  	>>> w.multipoint([[122,37], [124,32]])
  	>>> w.record('multipoint1')

  	>>> w.close()

  **Adding a LineString shape**

  For LineString shapefiles, each shape is given as a list of one or more linear features.
  Each of the linear features must have at least two points.


  	>>> w = shapefile.Writer('shapefiles/test/line')
  	>>> w.field('name', 'C')

  	>>> w.line([
  	...			[[1,5],[5,5],[5,1],[3,3],[1,1]], # line 1
  	...			[[3,2],[2,6]] # line 2
  	...			])

  	>>> w.record('linestring1')

  	>>> w.close()

  **Adding a Polygon shape**

  Similarly to LineString, Polygon shapes consist of multiple polygons, and must be given as a list of polygons.
  The main difference is that polygons must have at least 4 points and the last point must be the same as the first.
  It's also okay if you forget to repeat the first point at the end; PyShp automatically checks and closes the polygons
  if you don't.

  It's important to note that for Polygon shapefiles, your polygon coordinates must be ordered in a clockwise direction.
  If any of the polygons have holes, then the hole polygon coordinates must be ordered in a counterclockwise direction.
  The direction of your polygons determines how shapefile readers will distinguish between polygon outlines and holes.


  	>>> w = shapefile.Writer('shapefiles/test/polygon')
  	>>> w.field('name', 'C')

  	>>> w.poly([
  	...	        [[113,24], [112,32], [117,36], [122,37], [118,20]], # poly 1
  	...	        [[116,29],[116,26],[119,29],[119,32]], # hole 1
  	...         [[15,2], [17,6], [22,7]]  # poly 2
  	...        ])
  	>>> w.record('polygon1')

  	>>> w.close()

  **Adding from an existing Shape object**

  Finally, geometry can be added by passing an existing "Shape" object to the "shape" method.
  You can also pass it any GeoJSON dictionary or _\_geo_interface\_\_ compatible object.
  This can be particularly useful for copying from one file to another:


  	>>> r = shapefile.Reader('shapefiles/test/polygon')

  	>>> w = shapefile.Writer('shapefiles/test/copy')
  	>>> w.fields = r.fields[1:] # skip first deletion field

  	>>> # adding existing Shape objects
  	>>> for shaperec in r.iterShapeRecords():
  	...     w.record(*shaperec.record)
  	...     w.shape(shaperec.shape)

  	>>> # or GeoJSON dicts
  	>>> for shaperec in r.iterShapeRecords():
  	...     w.record(*shaperec.record)
  	...     w.shape(shaperec.shape.__geo_interface__)

  	>>> w.close()




  Because every shape must have a corresponding record it is critical that the
  number of records equals the number of shapes to create a valid shapefile. You
  must take care to add records and shapes in the same order so that the record
  data lines up with the geometry data. For example:


  	>>> w = shapefile.Writer('shapefiles/test/balancing', shapeType=shapefile.POINT)
  	>>> w.field("field1", "C")
  	>>> w.field("field2", "C")

  	>>> w.record("row", "one")
  	>>> w.point(1, 1)

  	>>> w.record("row", "two")
  	>>> w.point(2, 2)

  To help prevent accidental misalignment PyShp has an "auto balance" feature to
  make sure when you add either a shape or a record the two sides of the
  equation line up. This way if you forget to update an entry the
  shapefile will still be valid and handled correctly by most shapefile
  software. Autobalancing is NOT turned on by default. To activate it set
  the attribute autoBalance to 1 or True:


      >>> w.autoBalance = 1
  	>>> w.record("row", "three")
  	>>> w.record("row", "four")
  	>>> w.point(4, 4)

  	>>> w.recNum == w.shpNum
  	True

  You also have the option of manually calling the balance() method at any time
  to ensure the other side is up to date. When balancing is used
  null shapes are created on the geometry side or records
  with a value of "NULL" for each field is created on the attribute side.
  This gives you flexibility in how you build the shapefile.
  You can create all of the shapes and then create all of the records or vice versa.


      >>> w.autoBalance = 0
  	>>> w.record("row", "five")
  	>>> w.record("row", "six")
  	>>> w.record("row", "seven")
  	>>> w.point(5, 5)
  	>>> w.point(6, 6)
  	>>> w.balance()

  	>>> w.recNum == w.shpNum
  	True

  If you do not use the autoBalance() or balance() method and forget to manually
  balance the geometry and attributes the shapefile will be viewed as corrupt by
  most shapefile software.







  Below we list some commonly encountered errors and ways to fix them.



  By default, PyShp chooses to be transparent and provide the user with logging information and warnings about non-critical issues when reading or writing shapefiles. This behavior is controlled by the module constant `VERBOSE` (which defaults to True). If you would rather suppress this information, you can simply set this to False:


  	>>> shapefile.VERBOSE = False

  All logging happens under the namespace `shapefile`. So another way to suppress all PyShp warnings would be to alter the logging behavior for that namespace:


  	>>> import logging
  	>>> logging.getLogger('shapefile').setLevel(logging.ERROR)



  PyShp supports reading and writing shapefiles in any language or character encoding, and provides several options for decoding and encoding text.
  Most shapefiles are written in UTF-8 encoding, PyShp's default encoding, so in most cases you don't have to specify the encoding.
  If you encounter an encoding error when reading a shapefile, this means the shapefile was likely written in a non-utf8 encoding.
  For instance, when working with English language shapefiles, a common reason for encoding errors is that the shapefile was written in Latin-1 encoding.
  For reading shapefiles in any non-utf8 encoding, such as Latin-1, just
  supply the encoding option when creating the Reader class.


  	>>> r = shapefile.Reader("shapefiles/test/latin1.shp", encoding="latin1")
  	>>> r.record(0) == [2, u'Ñandú']
  	True

  Once you have loaded the shapefile, you may choose to save it using another more supportive encoding such
  as UTF-8. Assuming the new encoding supports the characters you are trying to write, reading it back in
  should give you the same unicode string you started with.


  	>>> w = shapefile.Writer("shapefiles/test/latin_as_utf8.shp", encoding="utf8")
  	>>> w.fields = r.fields[1:]
  	>>> w.record(*r.record(0))
  	>>> w.null()
  	>>> w.close()

  	>>> r = shapefile.Reader("shapefiles/test/latin_as_utf8.shp", encoding="utf8")
  	>>> r.record(0) == [2, u'Ñandú']
  	True

  If you supply the wrong encoding and the string is unable to be decoded, PyShp will by default raise an
  exception. If however, on rare occasion, you are unable to find the correct encoding and want to ignore
  or replace encoding errors, you can specify the "encodingErrors" to be used by the decode method. This
  applies to both reading and writing.


  	>>> r = shapefile.Reader("shapefiles/test/latin1.shp", encoding="ascii", encodingErrors="replace")
  	>>> r.record(0) == [2, u'�and�']
  	True





  Despite being a lightweight library, PyShp is designed to be able to read shapefiles of any size, allowing you to work with hundreds of thousands or even millions
  of records and complex geometries.



  As an example, let's load this Natural Earth shapefile of more than 4000 global administrative boundary polygons:


  	>>> sf = shapefile.Reader("https://github.com/nvkelso/natural-earth-vector/blob/master/10m_cultural/ne_10m_admin_1_states_provinces?raw=true")

  When first creating the Reader class, the library only reads the header information
  and leaves the rest of the file contents alone. Once you call the records() and shapes()
  methods however, it will attempt to read the entire file into memory at once.
  For very large files this can result in MemoryError. So when working with large files
  it is recommended to use instead the iterShapes(), iterRecords(), or iterShapeRecords()
  methods instead. These iterate through the file contents one at a time, enabling you to loop
  through them while keeping memory usage at a minimum.


  	>>> for shape in sf.iterShapes():
  	...     # do something here
  	...     pass

  	>>> for rec in sf.iterRecords():
  	...     # do something here
  	...     pass

  	>>> for shapeRec in sf.iterShapeRecords():
  	...     # do something here
  	...     pass

  	>>> for shapeRec in sf: # same as iterShapeRecords()
  	...     # do something here
  	...     pass



  By default when reading the attribute records of a shapefile, pyshp unpacks and returns the data for all of the dbf fields, regardless of whether you actually need that data or not. To limit which field data is unpacked when reading each record and speed up processing time, you can specify the `fields` argument to any of the methods involving record data. Note that the order of the specified fields does not matter, the resulting records will list the specified field values in the order that they appear in the original dbf file. For instance, if we are only interested in the country and name of each admin unit, the following is a more efficient way of iterating through the file:


  	>>> fields = ["geonunit", "name"]
  	>>> for rec in sf.iterRecords(fields=fields):
  	... 	# do something
  	... 	pass
  	>>> rec
  	Record #4595: ['Birgu', 'Malta']



  In many cases, we aren't interested in all entries of a shapefile, but rather only want to retrieve a small subset of records by filtering on some attribute. To avoid wasting time reading records and shapes that we don't need, we can start by iterating only the records and fields of interest, check if the record matches some condition as a way to filter the data, and finally load the full record and shape geometry for those that meet the condition:


  	>>> filter_field = "geonunit"
  	>>> filter_value = "Eritrea"
  	>>> for rec in sf.iterRecords(fields=[filter_field]):
  	...     if rec[filter_field] == filter_value:
  	... 		# load full record and shape
  	... 		shapeRec = sf.shapeRecord(rec.oid)
  	... 		shapeRec.record["name"]
  	'Debubawi Keyih Bahri'
  	'Debub'
  	'Semenawi Keyih Bahri'
  	'Gash Barka'
  	'Maekel'
  	'Anseba'

  Selectively reading only the necessary data in this way is particularly useful for efficiently processing a limited subset of data from very large files or when looping through a large number of files, especially if they contain large attribute tables or complex shape geometries.



  Another common use-case is that we only want to read those records that are located in some region of interest. Because the shapefile stores the bounding box of each shape separately from the geometry data, it's possible to quickly retrieve all shapes that might overlap a given bounding box region without having to load the full shape geometry data for every shape. This can be done by specifying the `bbox` argument to any of the record or shape methods:


  	>>> bbox = [36.423, 12.360, 43.123, 18.004] # ca bbox of Eritrea
  	>>> fields = ["geonunit","name"]
  	>>> for shapeRec in sf.iterShapeRecords(bbox=bbox, fields=fields):
  	... 	shapeRec.record
  	Record #368: ['Afar', 'Ethiopia']
  	Record #369: ['Tadjourah', 'Djibouti']
  	Record #375: ['Obock', 'Djibouti']
  	Record #376: ['Debubawi Keyih Bahri', 'Eritrea']
  	Record #1106: ['Amhara', 'Ethiopia']
  	Record #1107: ['Gedarif', 'Sudan']
  	Record #1108: ['Tigray', 'Ethiopia']
  	Record #1414: ['Sa`dah', 'Yemen']
  	Record #1415: ['`Asir', 'Saudi Arabia']
  	Record #1416: ['Hajjah', 'Yemen']
  	Record #1417: ['Jizan', 'Saudi Arabia']
  	Record #1598: ['Debub', 'Eritrea']
  	Record #1599: ['Red Sea', 'Sudan']
  	Record #1600: ['Semenawi Keyih Bahri', 'Eritrea']
  	Record #1601: ['Gash Barka', 'Eritrea']
  	Record #1602: ['Kassala', 'Sudan']
  	Record #1603: ['Maekel', 'Eritrea']
  	Record #2037: ['Al Hudaydah', 'Yemen']
  	Record #3741: ['Anseba', 'Eritrea']

  This functionality means that shapefiles can be used as a bare-bones spatially indexed database, with very fast bounding box queries for even the largest of shapefiles. Note that, as with all spatial indexing, this method does not guarantee that the *geometries* of the resulting matches overlap the queried region, only that their *bounding boxes* overlap.





  Similar to the Reader class, the shapefile Writer class uses a streaming approach to keep memory
  usage at a minimum and allow writing shapefiles of arbitrarily large sizes. The library takes care of this under-the-hood by immediately
  writing each geometry and record to disk the moment they
  are added using shape() or record(). Once the writer is closed, exited, or garbage
  collected, the final header information is calculated and written to the beginning of
  the file.



  This means that it's possible to merge hundreds or thousands of shapefiles, as
  long as you iterate through the source files to avoid loading everything into
  memory. The following example copies the contents of a shapefile to a new file 10 times:

  	>>> # create writer
  	>>> w = shapefile.Writer('shapefiles/test/merge')

  	>>> # copy over fields from the reader
  	>>> r = shapefile.Reader("shapefiles/blockgroups")
  	>>> for field in r.fields[1:]:
  	...     w.field(*field)

  	>>> # copy the shapefile to writer 10 times
  	>>> repeat = 10
  	>>> for i in range(repeat):
  	...     r = shapefile.Reader("shapefiles/blockgroups")
  	...     for shapeRec in r.iterShapeRecords():
  	...         w.record(*shapeRec.record)
  	...         w.shape(shapeRec.shape)

  	>>> # check that the written file is 10 times longer
  	>>> len(w) == len(r) * 10
  	True

  	>>> # close the writer
  	>>> w.close()

  In this trivial example, we knew that all files had the exact same field names, ordering, and types. In other scenarios, you will have to additionally make sure that all shapefiles have the exact same fields in the same order, and that they all contain the same geometry type.



  If you need to edit a shapefile you would have to read the
  file one record at a time, modify or filter the contents, and write it back out. For instance, to create a copy of a shapefile that only keeps a subset of relevant fields:

  	>>> # create writer
  	>>> w = shapefile.Writer('shapefiles/test/edit')

  	>>> # define which fields to keep
  	>>> keep_fields = ['BKG_KEY', 'MEDIANRENT']

  	>>> # copy over the relevant fields from the reader
  	>>> r = shapefile.Reader("shapefiles/blockgroups")
  	>>> for field in r.fields[1:]:
  	...     if field[0] in keep_fields:
  	...         w.field(*field)

  	>>> # write only the relevant attribute values
  	>>> for shapeRec in r.iterShapeRecords(fields=keep_fields):
  	...     w.record(*shapeRec.record)
  	...     w.shape(shapeRec.shape)

  	>>> # close writer
  	>>> w.close()



  Most shapefiles store conventional 2D points, lines, or polygons. But the shapefile format is also capable
  of storing various other types of geometries as well, including complex 3D surfaces and objects.



  Measured shape types are shapes that include a measurement value at each vertex, for instance
  speed measurements from a GPS device. Shapes with measurement (M) values are added with the following
  methods: "pointm", "multipointm", "linem", and "polygonm". The M-values are specified by adding a
  third M value to each XY coordinate. Missing or unobserved M-values are specified with a None value,
  or by simply omitting the third M-coordinate.


  	>>> w = shapefile.Writer('shapefiles/test/linem')
  	>>> w.field('name', 'C')

  	>>> w.linem([
  	...			[[1,5,0],[5,5],[5,1,3],[3,3,None],[1,1,0]], # line with one omitted and one missing M-value
  	...			[[3,2],[2,6]] # line without any M-values
  	...			])

  	>>> w.record('linem1')

  	>>> w.close()

  Shapefiles containing M-values can be examined in several ways:

  	>>> r = shapefile.Reader('shapefiles/test/linem')

  	>>> r.mbox # the lower and upper bound of M-values in the shapefile
  	[0.0, 3.0]

  	>>> r.shape(0).m # flat list of M-values
  	[0.0, None, 3.0, None, 0.0, None, None]




  Elevation shape types are shapes that include an elevation value at each vertex, for instance elevation from a GPS device.
  Shapes with elevation (Z) values are added with the following methods: "pointz", "multipointz", "linez", and "polyz".
  The Z-values are specified by adding a third Z value to each XY coordinate. Z-values do not support the concept of missing data,
  but if you omit the third Z-coordinate it will default to 0. Note that Z-type shapes also support measurement (M) values added
  as a fourth M-coordinate. This too is optional.


  	>>> w = shapefile.Writer('shapefiles/test/linez')
  	>>> w.field('name', 'C')

  	>>> w.linez([
  	...			[[1,5,18],[5,5,20],[5,1,22],[3,3],[1,1]], # line with some omitted Z-values
  	...			[[3,2],[2,6]], # line without any Z-values
  	...			[[3,2,15,0],[2,6,13,3],[1,9,14,2]] # line with both Z- and M-values
  	...			])

  	>>> w.record('linez1')

  	>>> w.close()

  To examine a Z-type shapefile you can do:

  	>>> r = shapefile.Reader('shapefiles/test/linez')

  	>>> r.zbox # the lower and upper bound of Z-values in the shapefile
  	[0.0, 22.0]

  	>>> r.shape(0).z # flat list of Z-values
  	[18.0, 20.0, 22.0, 0.0, 0.0, 0.0, 0.0, 15.0, 13.0, 14.0]



  Multipatch shapes are useful for storing composite 3-Dimensional objects.
  A MultiPatch shape represents a 3D object made up of one or more surface parts.
  Each surface in "parts" is defined by a list of XYZM values (Z and M values optional), and its corresponding type is
  given in the "partTypes" argument. The part type decides how the coordinate sequence is to be interpreted, and can be one
  of the following module constants: TRIANGLE_STRIP, TRIANGLE_FAN, OUTER_RING, INNER_RING, FIRST_RING, or RING.
  For instance, a TRIANGLE_STRIP may be used to represent the walls of a building, combined with a TRIANGLE_FAN to represent
  its roof:

  	>>> from shapefile import TRIANGLE_STRIP, TRIANGLE_FAN

  	>>> w = shapefile.Writer('shapefiles/test/multipatch')
  	>>> w.field('name', 'C')

  	>>> w.multipatch([
  	...				 [[0,0,0],[0,0,3],[5,0,0],[5,0,3],[5,5,0],[5,5,3],[0,5,0],[0,5,3],[0,0,0],[0,0,3]], # TRIANGLE_STRIP for house walls
  	...				 [[2.5,2.5,5],[0,0,3],[5,0,3],[5,5,3],[0,5,3],[0,0,3]], # TRIANGLE_FAN for pointed house roof
  	...				 ],
  	...				 partTypes=[TRIANGLE_STRIP, TRIANGLE_FAN]) # one type for each part

  	>>> w.record('house1')

  	>>> w.close()

  For an introduction to the various multipatch part types and examples of how to create 3D MultiPatch objects see [this
  ESRI White Paper](http://downloads.esri.com/support/whitepapers/ao_/J9749_MultiPatch_Geometry_Type.pdf).





  The testing framework is pytest, and the tests are located in test_shapefile.py.
  This includes an extensive set of unit tests of the various pyshp features,
  and tests against various input data. Some of the tests that require
  internet connectivity will be skipped in offline testing environments.
  In the same folder as README.md and shapefile.py, from the command line run
  ```
  $ python -m pytest
  ```

  Additionally, all the code and examples located in this file, README.md,
  is tested and verified with the builtin doctest framework.
  A special routine for invoking the doctest is run when calling directly on shapefile.py.
  In the same folder as README.md and shapefile.py, from the command line run
  ```
  $ python shapefile.py
  ```

  Linux/Mac and similar platforms will need to run `$ dos2unix README.md` in order
  to correct line endings in README.md.



  ```
  Atle Frenvik Sveen
  Bas Couwenberg
  Ben Beasley
  Casey Meisenzahl
  Charles Arnold
  David A. Riggs
  davidh-ssec
  Evan Heidtmann
  ezcitron
  fiveham
  geospatialpython
  Hannes
  Ignacio Martinez Vazquez
  Jason Moujaes
  Jonty Wareing
  Karim Bahgat
  karanrn
  Kyle Kelley
  Louis Tiao
  Marcin Cuprjak
  mcuprjak
  Micah Cochran
  Michael Davis
  Michal Čihař
  Mike Toews
  Miroslav Šedivý
  Nilo
  pakoun
  Paulo Ernesto
  Raynor Vliegendhart
  Razzi Abuissa
  RosBer97
  Ross Rogers
  Ryan Brideau
  Tim Gates
  Tobias Megies
  Tommi Penttinen
  Uli Köhler
  Vsevolod Novikov
  Zac Miller
  ```


pkgId: ebb25354e2307f45ef53942ab203830b562fa4bd47228b7f6fe5991e266e340c
name: python-pyshtools
arch: src
version: 4.10.1
epoch: 0
release: 1
summary: SHTOOLS - Spherical Harmonic Tools
url: https://shtools.github.io/SHTOOLS/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6c8b31d0-ff85-48fc-a789-bfa1bf076175
location_href: 00004798-python-pyshtools/python-pyshtools-4.10.1-1.src.rpm
checksum_type: sha256
description:
  |Documentation| |DOI| |Paper| |Binder| |Chat on matrix| |Chat at gitter|
  |Twitter| |Mastodon Follow|

  SHTOOLS/pyshtools is a Fortran-95/Python library that can be used for
  spherical harmonic transforms, multitaper spectral analyses, expansions
  of gridded data into Slepian basis functions, and standard operations on
  global gravitational and magnetic field data.

  FEATURES
  ~~~~~~~~

  -  Supports all standard normalizations and phase conventions of the
     spherical harmonic functions.

  -  Effortless conversion between real and complex harmonics, between
     phase conventions, and between 4π normalized, Schmidt
     semi-normalized, orthonormalized, and unnormalized harmonics.

  -  Use of both regularly sampled geographic grids and grids appropriate
     for Gauss-Legendre quadrature.

  -  Spherical harmonic transforms proven to be accurate up to about
     degree 2800 for the Fortran 95 code, and beyond using the DUCC0
     backend.

  -  Perform localized multitaper spectral analyses, or expand gridded
     data in terms of localized Slepian basis functions.

  -  Support for standard data and file formats, including *xarray* and
     *netcdf*.

  -  Import research-grade gravity, topography, and magnetic field
     datasets with a single command.

  -  Creation of publication quality maps using
     `Cartopy <https://scitools.org.uk/cartopy>`__ and
     `pygmt <https://www.pygmt.org/>`__.

  -  OpenMP compatible and OpenMP thread-safe versions of the Fortran
     routines.

  INSTALLATION
  ~~~~~~~~~~~~

  pyshtools (for Python)
  ^^^^^^^^^^^^^^^^^^^^^^

  Install using ``conda``:

  .. code:: bash

     conda install -c conda-forge pyshtools  # Linux and macOS only
     conda update -c conda-forge pyshtools  # to upgrade a pre-existing installation

  Install using ``pip``:

  .. code:: bash

     pip install pyshtools
     pip install --upgrade pyshtools  # to upgrade a pre-existing installation
     pip install pyshtools --no-binary pyshtools  # build from source
     pip install git+https://github.com/SHTOOLS/SHTOOLS@develop  # install the develop branch from source

  For developers, install the requirements

  .. code:: bash

     
     sudo apt-get install g++ gfortran libfftw3-dev libblas-dev liblapack-dev
     
     brew install fftw
     sudo port install fftw-3
     

  then clone the shtools repo and install manually:

  .. code:: bash

     git clone https://github.com/SHTOOLS/SHTOOLS.git
     cd shtools
     git checkout develop
     pip install -e .  # install into the shtools folder and link to the active python environment

  SHTOOLS (for Fortran 95)
  ^^^^^^^^^^^^^^^^^^^^^^^^

  Install using the `brew <http://brew.sh/>`__ package manager (macOS,
  linux, windows):

  .. code:: bash

     brew install shtools

  Install using the `macports <https://www.macports.org/>`__ package
  manager (macOS)

  .. code:: bash

     sudo port install shtools

  Install from source. Clone or download the shtools repo, and then
  execute one (or both) of the following commands in the shtools
  directory:

  .. code:: bash

     make fortran
     make fortran-mp  # for OpenMP Fortran routines

  Further installation instructions and options can be found in the `web
  documentation <https://shtools.github.io/SHTOOLS/>`__.

  HOW TO USE
  ~~~~~~~~~~

  SHTOOLS can be invoked in any Fortran 95 or Python program. The core
  software is written in Fortran 95, and Python wrappers and dedicated
  classes allow simple access to the fortran-compiled routines. A variety
  of Python tutorials and guides are included that demonstrate the major
  features of the library.

  To get started, click on the following Python tutorials and then run
  them interactively in Binder:

  -  `Spherical harmonic coefficients and
     grids <https://nbviewer.jupyter.org/github/SHTOOLS/SHTOOLS/blob/master/examples/notebooks/grids-and-coefficients.ipynb>`__
  -  `Localization windows and spectral
     analysis <https://nbviewer.jupyter.org/github/SHTOOLS/SHTOOLS/blob/master/examples/notebooks/localized-spectral-analysis.ipynb>`__
  -  `Gravity and magnetic
     fields <https://nbviewer.jupyter.org/github/SHTOOLS/SHTOOLS/blob/master/examples/notebooks/gravity-and-magnetic-fields.ipynb>`__
  -  `Plotting
     maps <https://nbviewer.jupyter.org/github/SHTOOLS/SHTOOLS/blob/master/examples/notebooks/plotting-maps.ipynb>`__

  DEVELOPERS
  ~~~~~~~~~~

  We work on the ``develop`` branch and only push releases to ``master``.
  Please base all pull requests on ``develop``.

  REFERENCE
  ~~~~~~~~~

  Mark A. Wieczorek and Matthias Meschede (2018). SHTools — Tools for
  working with spherical harmonics, *Geochemistry, Geophysics,
  Geosystems*, 19, 2574-2592,
  doi:`10.1029/2018GC007529 <https://doi.org/10.1029/2018GC007529>`__.

  .. |Documentation| image:: https://img.shields.io/badge/documentation-shtools.github.io%2FSHTOOLS%2F-yellow.svg
     :target: https://shtools.github.io/SHTOOLS/
  .. |DOI| image:: https://zenodo.org/badge/doi/10.5281/zenodo.592762.svg
     :target: https://doi.org/10.5281/zenodo.592762
  .. |Paper| image:: https://img.shields.io/badge/paper-10.1029/2018GC007529-orange.svg
     :target: https://doi.org/10.1029/2018GC007529
  .. |Binder| image:: https://mybinder.org/badge_logo.svg
     :target: https://mybinder.org/v2/gh/SHTOOLS/SHTOOLS/master?filepath=examples%2Fnotebooks%2F
  .. |Chat on matrix| image:: https://img.shields.io/badge/chat-on_%5Bmatrix%5D-4bb596.svg
     :target: https://matrix.to/#/#pyshtools:matrix.org?via=matrix.org&via=gitter.im
  .. |Chat at gitter| image:: https://badges.gitter.im/SHTOOLS/SHTOOLS.svg
     :target: https://gitter.im/SHTOOLS/SHTOOLS?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
  .. |Twitter| image:: https://img.shields.io/twitter/follow/pyshtools.svg?style=social&label=Follow
     :target: https://twitter.com/intent/follow?screen_name=pyshtools
  .. |Mastodon Follow| image:: https://img.shields.io/mastodon/follow/108112567255227248?domain=https%3A%2F%2Ffosstodon.org&style=social
     :target: https://fosstodon.org/users/shtools/remote_follow


pkgId: 40dbdb25931adf9bdcb6686de7faa42bf91484089adb87198a1b9e94ac7de822
name: python-pysimdjson
arch: src
version: 5.0.2
epoch: 0
release: 1
summary: simdjson bindings for python
url: https://github.com/TkTech/pysimdjson
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9fd7ace8-4702-4285-a714-9a1b45f5c860
location_href: 00011853-python-pysimdjson/python-pysimdjson-5.0.2-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - License](https://img.shields.io/pypi/l/pysimdjson.svg?style=flat-square)
  ![Tests](https://github.com/TkTech/pysimdjson/workflows/Run%20tests/badge.svg)



  Python bindings for the [simdjson][] project, a SIMD-accelerated JSON parser.
  If SIMD instructions are unavailable a fallback parser is used, making
  pysimdjson safe to use anywhere.

  Bindings are currently tested on OS X, Linux, and Windows for Python version
  3.6 to 3.9.



  The latest documentation can be found at https://pysimdjson.tkte.ch.

  If you've checked out the source code (for example to review a PR), you can
  build the latest documentation by running `cd docs && make html`.



  pysimdjson compares well against most libraries. The full benchmarks can be
  found in its sister project [json_benchmark][].

  [simdjson]: https://github.com/lemire/simdjson
  [json_benchmark]: https://github.com/tktech/json_benchmark


pkgId: f5ec49bf1de3d07df6401d24f6e945724c00174bf6e7d472d898629e2169f83d
name: python-pysimdjson-debuginfo
arch: aarch64
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-9fd7ace8-4702-4285-a714-9a1b45f5c860
rpm_sourcerpm: python-pysimdjson-5.0.2-1.src.rpm
location_href: 00011853-python-pysimdjson/python-pysimdjson-debuginfo-5.0.2-1.aarch64.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: e0a00cac9394df2a9d2044f27fe8b3f01ca5ac17891fde41b689c40f3ab417b9
name: python-pysimdjson-debugsource
arch: aarch64
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-9fd7ace8-4702-4285-a714-9a1b45f5c860
rpm_sourcerpm: python-pysimdjson-5.0.2-1.src.rpm
location_href: 00011853-python-pysimdjson/python-pysimdjson-debugsource-5.0.2-1.aarch64.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: 97779ffbafa736180bdcbb6b7ed4783b479d3f0b449f6a37d04c41e668ad6e23
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-17c9ab18-191a-41d4-89a5-72fb779db392
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: 0617808b108660995751f478a0095ac7b34dbfc1e9d25aff7f27aaa7ae7738ed
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-8483a585-4157-4f1e-ad5b-aa7d05e49f02
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: 54da4b9dd4738ce1f349f393ba1cf907112eb5a581e20c50f83b9ee9034e4024
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-3be40bc5-1c5d-4af8-b025-92e1383a7523
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: c8c9746e465151e5ba89176a369e1f4435a8341712309cd0239f58a0fd145ef6
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-78182323-0fc1-4408-9c51-5c19df4d9a9f
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: 09792ec09f5473632ba9b76e097b1efa8e2c95ccdb33b10b6d79ca4c6e60ba3f
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-10bc5847-a2ac-42d1-8869-a10f19d8ccca
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: 625010d05d2c4100ef0913252da581aa0c64570a5b277c34a8940a98512a84f5
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-ea4fdac4-f96a-4a16-95bc-3ea184e6f432
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: 69fbc8d0b2507dcfda3fb0c4ff4d4a5d9e2a5d12fb7136fe16af79214ff235a9
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-7fd58dfc-98b2-4bb6-9a44-c90571d595eb
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: a8cc50b247674da5e058c67bf597e8bbb05da287afb17d680c95f7021bfb3495
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-5596bbbb-d8e0-40ba-9eab-64095c4bb515
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: 8fbda254a909ccc2e4f9a52e07072ca2aadd67e7523cca936d431c06e7210b4a
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-f0fc2295-65bc-48d0-b0e0-aee87c79b11f
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: da452e9788719617282d0b34c0f293a5b3e87feb26edc09fb39b939ec17c244c
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-f683afc5-6605-4403-9325-61b7774d6b9e
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: 3d96841a47a8800cd2ec4797fc69f56edaedcfe631f7e2f77f7b5e8d7c9e8cfa
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-cfe9eb9c-45dd-45c3-8deb-ec662faa9696
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: 3aead678ab5cf6a906f3dd371d2694a38d5991996bc316513dba084b1d5b12ee
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-a375e733-e214-4158-a6aa-e4b4b7ce0cfb
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: c780e395fd0a3631f209cce2cfb5d328d4f2599fcd344ca3f72fc7179bd3fbf0
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-19b3503a-aa7b-4f97-a57f-bde81a22d27c
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: ef9e64c2b97d2e868b4f79f0ae74fb83b9ed566bb5e783e2e4a672f8f8cf97b3
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-34a3d685-ea3f-43d7-8850-0392392ac0e9
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: f6b5e08f7bbcc90492d8b83c92b01b2592b4f6705aff7f79531e38736e003062
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-594a87bd-3911-41e2-b650-cc9221b16588
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: 9134bdbd2f0fe9508a40e29e745ae4d719784e05b987b6d8752c0e2771db7fb9
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-0e8b0622-7639-44a7-9a9c-9d6186d0fd84
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: a4e5a1ff23abc2d09b551fde1e68120e9d0a83e4c3096b312107ddb9979f94df
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-53f43884-e839-42ce-85be-758b7c4b195b
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: 5b3315d25c1b44b04c254182c34ab851e70ab12e6deca9cb8e4f4a1bee22a41f
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-5c83c445-4397-4052-8310-7a90d2e4426c
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: 764063ea243a3ea06e46f39933614851f2167e4f4c8437f196eeed2d6dff20bc
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-8e887947-20e4-40cf-aada-c6aa72b44055
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: f4f26c8950d45b5c2c8f9c5a6766006a0defda8305f200e4ca8c41c4f9446290
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-ef6c910a-5f0b-4b02-b5b3-16c9c694be14
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: 88dff2437d776fef7fb77ad0ae40734ce68094a15a2659bd7d3b10b03cab0bc6
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-bfa0ffff-659d-4d67-b30a-400825f9d393
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: 4e161cde4d55f93e37924df9c994dceda658d4837cd782919ac6a8b1bd677a7e
name: python-pytest-base-url
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: pytest plugin for URL based testing
url: https://github.com/pytest-dev/pytest-base-url
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6427ff9-8640-457f-9734-8ee32fa08f0f
location_href: 00011072-python-pytest-base-url/python-pytest-base-url-2.0.0-1.src.rpm
checksum_type: sha256
description:
  pytest-base-url is a simple plugin for pytest_ that provides an optional base
  URL via the command line or configuration file.


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


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


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

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

  Separate test code from test cases in `pytest`.

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

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


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

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



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

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

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


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

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

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



  Follow these steps to make a new release:

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

  Travis will deploy to PyPI automatically.

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



  MIT.


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

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


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


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


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

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

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

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

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

  All fixtures have `session` scope.

  Determine the IP address for TCP connections to Docker containers.

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

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

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

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

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

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

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

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


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


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



  Install the plugin with `pip`:

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



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






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

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

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



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

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



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


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


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


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

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



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



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



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

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

     db_session.add(row)
     db_session.commit()

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

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

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

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

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

  ```ini


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

  ```python


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

  ```python


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

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

  ```python


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

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







  Install using pip:

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

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



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

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

  You can install using pip:

  ```
  pip install .
  ```



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

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





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

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

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

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

      init_postgresql_database(pg_user, pg_host, pg_port, pg_db)

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


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

      app.config['SQLALCHEMY_DATABASE_URI'] = DB_CONN

      return app


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

      return db
  ```

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

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

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



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

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

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



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

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

  Example:

  ```python


  engine = sqlalchemy.create_engine(DATABASE_URI)
  ```

  ```ini


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

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

  ```ini


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



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

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

  Example:

  ```python


  db = SQLAlchemy()
  ```

  ```ini


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

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

  ```ini


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



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

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

  Example:

  ```python


  WorkerSessionmaker = sessionmaker()
  ```

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

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

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



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

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

  ```python

  def transactional_test(db_session):
      ...



  def non_transactional_test():
      ...
  ```

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

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



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



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

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

  Example:

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

     db_session.add(row)
     db_session.commit()

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



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

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

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

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

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

  Example:

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

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



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

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

  ```python

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

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





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

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

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

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

  Finally, run the tests using pytest:

  ```
  pytest
  ```



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

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

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



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

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


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


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


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

  ```yaml
  name: test

  on:
    push:

  jobs:
    test:
      runs-on: ubuntu-latest

      steps:
      - uses: actions/checkout@v3

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

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

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

      - run: pytest
  ```

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

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


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

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


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


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

  ```yaml
  name: test

  on:
    push:

  jobs:
    test:
      runs-on: ubuntu-latest

      steps:
      - uses: actions/checkout@v3

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

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

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

      - run: pytest
  ```

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

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


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

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


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

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

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

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

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

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


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


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

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


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

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


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


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


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

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

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

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

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



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

  ```python
  import pytest
  import httpx


  def test_something(httpx_mock):
      httpx_mock.add_response()

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


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

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

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

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

  ```python
  import pytest

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

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



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

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

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



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

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

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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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



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

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

  Matching is performed on equality.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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


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

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


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

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


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

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


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

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

  ```



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

  Matching is performed on equality for each provided header.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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



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

  Matching is performed on equality.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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



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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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

  ```

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



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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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

  ```

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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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

  ```

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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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

  ```



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

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

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

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


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

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

  ```



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

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

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


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

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

  ```



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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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

  ```



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

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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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


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

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


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

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

  ```



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

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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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


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

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

  ```




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

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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

  ```



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

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

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

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

  ```python
  import pytest

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

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



  Callback should return a `httpx.Response`.

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

      httpx_mock.add_callback(custom_response)

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

  ```

  Alternatively, callbacks can also be asynchronous.

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

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


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

      httpx_mock.add_callback(simulate_network_latency)
      httpx_mock.add_response()

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

  ```



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

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

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


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

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

  ```

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

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


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

  ```



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

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

  As in the following samples:

  ```python
  import httpx
  from pytest_httpx import HTTPXMock


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

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

      requests = httpx_mock.get_requests()


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

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

      request = httpx_mock.get_request()


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



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



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

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



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

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

  Matching is performed on equality.



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

  Matching is performed on equality for each provided header.



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

  Matching is performed on equality.



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

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

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

  ```python
  import pytest

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

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

  ```python
  import pytest
  import httpx

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


  def test_partial_mock(httpx_mock):
      httpx_mock.add_response()

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



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



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



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

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

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

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

  ```

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

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

  ```



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



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

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

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


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


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

  ```

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

  ```


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

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

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



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



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



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



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

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

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

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

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

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

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

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





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

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

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

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

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



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

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



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

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

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

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

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

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

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



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

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

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

  You can then access the `report` object:

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

  And save the report manually:

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




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

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



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



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

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



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



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



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



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

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

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

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



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



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

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



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




  A test stage item.

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



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



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

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



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




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

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



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



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

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


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

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

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




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

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

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

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

  To load your custom Docker image and apply deployment manifests:

  ```python
  import requests
  from pykube import Pod

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

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

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

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




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

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

  KindCluster has the following attributes:

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

  You can also use KindCluster directly without pytest:

  ```python
  from pytest_kind import KindCluster

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

  cluster.delete()
  ```




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

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

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

  ```bash

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




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


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

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

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

      $ [sudo] pip install pytest-logger

  Plugin puts logs on per-logger basis to:

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

  You can setup plugin using hook::

      
      import os

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

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

  have logging tests or libraries (including fixtures)::

      
      import pytest
      import logging

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

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

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

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

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

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

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

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

  being able to change this output by cmdline option::

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

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

  and - the same - in filesystem::

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

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

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


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


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

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

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


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

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


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

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


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


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


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


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



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



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

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

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



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



  `pip install pytest-parallel`



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



  ```bash

  pytest --workers 2


  pytest --workers auto


  pytest --tests-per-worker 4


  pytest --tests-per-worker auto


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



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

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

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



  MIT


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


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


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

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

  ```python
  from threading import Thread

  def test_assert():

      def run():
          assert False

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

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

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

  ```python
  from threading import Thread

  def test_assert(reraise):

      def run():
          with reraise:
              assert False

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

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





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

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

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

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



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

  ```python
  def test_assert(reraise):

      def run():
          with reraise:
              assert False

      reraise() # This will not raise anything yet

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

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

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



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

  ```python
  def test_assert(reraise):

      def run():
          with reraise:
              assert False

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



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

  ```python
  def test_assert(reraise):

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

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

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



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

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

  ```python
  def test_assert(reraise):

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

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

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



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

  Here's a quick demonstration test case that passes:

  ```python
  def test_assert(reraise):

      def run():
          with reraise:
              assert False

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

      
      assert type(reraise.exception) is AssertionError

      
      reraise.exception = Exception()

      
      assert type(reraise.reset()) is AssertionError

      
      assert reraise.exception is None
  ```


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


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


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



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



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

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

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

  ```

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

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

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

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



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

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

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



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

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



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



  This software is MIT licensed.


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




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




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






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

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

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



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

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

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

  or

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

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



  You can configure the indicator displayed when test passed.

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



  You can configure the indicator displated when test failed.

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



  You can configure the indicator displated when test is skipped.

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



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

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



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



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




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



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



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



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



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

  Copyright (C) 2014-2021 Pawel Chomicki

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

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


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


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

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

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

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

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


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

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

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

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



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



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

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



  To install pytest-sugar:

      pip install pytest-sugar

  Then run your tests with:

      $ pytest

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

      $ pytest --verbose

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

      $ pytest -p no:sugar



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


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


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


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

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



      pip install pytest-testmon

      
      pytest --testmon

      

      
      pytest --testmon

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



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


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

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



      pip install pytest-testmon

      
      pytest --testmon

      

      
      pytest --testmon

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



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


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


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

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


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


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


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


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


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

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

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

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

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

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


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


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

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

  $ pip3 install -r requirements.txt



  $ apt-get install nmap


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

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


  $ sudo nmap -O your-host.com

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


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


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

   - Nmap
   - NmapHostDiscovery
   - NmapScanTechniques


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

  The following nmaps commands have been added to the following scripts

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


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

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

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

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

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

  NmapHostDiscovery

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

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


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

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


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

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


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


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


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


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

  ```python
  from pythonping import ping

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

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

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



  Yes, you need to be root to use pythonping.


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


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




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

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

  A UML Diagram of the code structure is below:

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

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


  Simply generates random text. See function random_text.


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


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


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


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


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


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

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

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

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

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

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

  ```
  pytest test
  ```

  To test for coverage simply run:

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


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


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

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


