# packages

pkgId: 669f14042af89387485d8b6bf53f064bf4117d959a53c584c31b54eccd6288fb
name: python-pyhdfe
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: High dimensional fixed effect absorption with Python 3
url: https://github.com/jeffgortmaker/pyhdfe
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de987201-ba42-4587-b027-52233dcc08eb
location_href: 00011609-python-pyhdfe/python-pyhdfe-0.1.2-1.src.rpm
checksum_type: sha256
description:
  The PyHDFE package has been tested on `Python <https://www.python.org/downloads/>`_ versions 3.6 through 3.9. The `SciPy instructions <https://scipy.org/install/>`_ for installing related packages is a good guide for how to install a scientific Python environment. A good choice is the `Anaconda Distribution <https://www.anaconda.com/products/distribution>`_, since, along with many other packages that are useful for scientific computing, it comes packaged with PyHDFE's only required dependencies: `NumPy <https://numpy.org/>`_ and `SciPy <https://scipy.org/>`_.
  You can install the current release of PyHDFE with `pip <https://pip.pypa.io/en/latest/>`_::
      pip install pyhdfe
  You can upgrade to a newer release with the ``--upgrade`` flag::
      pip install --upgrade pyhdfe
  If you lack permissions, you can install PyHDFE in your user directory with the ``--user`` flag::
      pip install --user pyhdfe
  Alternatively, you can download a wheel or source archive from `PyPI <https://pypi.org/project/pyhdfe/>`_. You can find the latest development code on `GitHub <https://github.com/jeffgortmaker/pyhdfe/>`_ and the latest development documentation `here <https://pyhdfe.readthedocs.io/en/latest/>`_.


pkgId: 63ea87462a4765d0c7312bd429d5bf8c6ae4b7e7e38f4a7599653692c3ab676f
name: python-pyhumps
arch: src
version: 3.8.0
epoch: 0
release: 1
url: https://github.com/nficano/humps
rpm_license: The Unlicense (Unlicense)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9ed04839-dcd6-45d4-b78f-c63b17d8fde5
location_href: 00010203-python-pyhumps/python-pyhumps-3.8.0-1.src.rpm
checksum_type: sha256
summary:
  🐫  Convert strings (and dictionary keys) between snake case, camel case and pascal case in Python. Inspired by Humps for Node

description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/nficano/humps/master/artwork/humps.png" alt="Humps logo" width="245" height="118">
  </p>

  <div align="center">
    <a href="http://humps.readthedocs.io/en/latest/?badge=latest">
      <img src="https://readthedocs.org/projects/humps/badge/?version=latest" />
    </a>
    <a href="https://coveralls.io/github/nficano/humps?branch=master">
      <img src="https://coveralls.io/repos/github/nficano/humps/badge.svg?branch=master#cachebus" />
    </a>
    <a href="https://pypi.org/project/pyhumps/">
      <img src="https://img.shields.io/pypi/v/pyhumps.svg#cachebust" />
    </a>
    <a href="https://pypi.org/project/pyhumps/">
      <img src="https://img.shields.io/pypi/dm/pyhumps.svg" />
    </a>
    <a href="https://pypi.python.org/pypi/pyhumps/">
      <img src="https://img.shields.io/pypi/pyversions/pyhumps.svg" />
    </a>
  </div>
  </p>

  Convert strings (and dictionary keys) between snake case, camel case and pascal case in Python. Inspired by [Humps](https://github.com/domchristie/humps) for Node.



  Please email me at nficano@gmail.com.



  To install humps, simply use pipenv (or pip, of course):

  ```bash
  $ pipenv install pyhumps
  ```





  ```python
  import humps

  humps.camelize("jack_in_the_box")  # jackInTheBox
  humps.decamelize("rubyTuesdays")  # ruby_tuesdays
  humps.pascalize("red_robin")  # RedRobin
  humps.kebabize("white_castle")  # white-castle
  ```



  ```python
  import humps

  array = [{"attrOne": "foo"}, {"attrOne": "bar"}]
  humps.decamelize(array) # [{"attr_one": "foo"}, {"attr_one": "bar"}]

  array = [{"attr_one": "foo"}, {"attr_one": "bar"}]
  humps.camelize(array)  # [{"attrOne": "foo"}, {"attrOne": "bar"}]

  array = [{'attr_one': 'foo'}, {'attr_one': 'bar'}]
  humps.kebabize(array)  # [{'attr-one': 'foo'}, {'attr-one': 'bar'}]

  array = [{"attr_one": "foo"}, {"attr_one": "bar"}]
  humps.pascalize(array)  # [{"AttrOne": "foo"}, {"AttrOne": "bar"}]
  ```



  ```python
  import humps

  humps.is_camelcase("illWearYourGranddadsClothes")  # True
  humps.is_pascalcase("ILookIncredible")  # True
  humps.is_snakecase("im_in_this_big_ass_coat")  # True
  humps.is_kebabcase('from-that-thrift-shop')  # True
  humps.is_camelcase("down_the_road")  # False

  humps.is_snakecase("imGonnaPopSomeTags")  # False
  humps.is_kebabcase('only_got_twenty_dollars_in_my_pocket')  # False



  humps.decamelize("APIResponse")  # api_response
  ```

  <hr>





  ```python

  import humps
  import boto3

  def api(service, decamelize=True, *args, **kwargs):
      service, func = service.split(":")
      client = boto3.client(service)
      kwargs = humps.pascalize(kwargs)
      response = getattr(client, func)(*args, **kwargs)
      return (depascalize(response) if decamelize else response)


  api("s3:download_file", bucket="bucket", key="hello.png", filename="hello.png")
  ```


pkgId: b53582bb788267be8dbb17c22e5c201fc2c2c37d2f1ea21b2c5fcb7e9844c063
name: python-pyi2cflash
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: I2C eeprom device drivers (pure Python)
url: http://github.com/eblot/pyi2cflash
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f056fd9f-926c-4053-8c43-b71c743c3b84
location_href: 00004705-python-pyi2cflash/python-pyi2cflash-0.2.2-1.src.rpm
checksum_type: sha256
description:
  I2C eeprom device drivers (pure Python)
  I2C flash devices, also known as *DataFlash* are commonly found in embedded
  products, to store firmware, microcode or configuration parameters.
  PyI2CFlash_ comes with several pure Python drivers for those flash devices, that
  demonstrate use of I2C devices with PyFtdi_. It could also be useful to dump
  flash contents or recover from a bricked devices.


pkgId: 6c046765c02113c809208bc79922d7d5a41a906736bfe0308ce83cf8c5b9afec
name: python-pyinels
arch: src
version: 0.6.11
epoch: 0
release: 1
summary: Python library for iNels BUS
url: https://github.com/JH-Soft-Technology/pyinels
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0a4023e6-45fe-4787-97e9-f2fba71b4a20
location_href: 00004707-python-pyinels/python-pyinels-0.6.11-1.src.rpm
checksum_type: sha256
description:
  A Python library that handles communication with proprietary home intelligent system
  named [iNels](https://www.inels.com/) by ElkoEP company.
  This package is developed against iNels BUS version. It is not tested on older
  version CU2 and does not support RF components.


pkgId: f514c7fc2d4c736ca5eec285447bc68bcf00b71a7e58fef72dfcf722a33db2a7
name: python-pyinsane2
arch: src
version: 2.0.13
epoch: 0
release: 1
summary: Python library to access and use image scanners (Linux/Windows/etc)
url: https://github.com/openpaperwork/pyinsane
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b6988d6-e396-4cfd-9cbc-e9d5e0b26f68
location_href: 00004708-python-pyinsane2/python-pyinsane2-2.0.13-1.src.rpm
checksum_type: sha256
description:
  Python library to access and use image scanners (devices). Works on GNU/Linux (Sane), *BSD (Sane), Windows >= Vista (WIA 2), MacOSX (Sane), etc.


pkgId: 6cab0f4f381c596034055c65a0dba3f4dba93348211fc53159d8544d05249ecb
name: python-pyinstrument
arch: src
version: 4.4.0
epoch: 0
release: 1
summary: Call stack profiler for Python. Shows you why your code is slow!
url: https://github.com/joerick/pyinstrument
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0556c0fb-d134-4ae5-8593-9c0ffef171b5
location_href: 00010436-python-pyinstrument/python-pyinstrument-4.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/pyinstrument.svg)](https://badge.fury.io/py/pyinstrument)
  [![.github/workflows/test.yml](https://github.com/joerick/pyinstrument/actions/workflows/test.yml/badge.svg)](https://github.com/joerick/pyinstrument/actions/workflows/test.yml)
  [![Build wheels](https://github.com/joerick/pyinstrument/actions/workflows/wheels.yml/badge.svg)](https://github.com/joerick/pyinstrument/actions/workflows/wheels.yml)
  [Documentation](https://pyinstrument.readthedocs.io/)
  <!-- MARK intro start -->
  [![Screenshot](docs/img/screenshot.jpg)](https://raw.githubusercontent.com/joerick/pyinstrument/main/docs/img/screenshot.jpg)
  Pyinstrument is a Python profiler. A profiler is a tool to help you optimize
  your code - make it faster. To get the biggest speed increase you should
  [focus on the slowest part of your program](https://en.wikipedia.org/wiki/Amdahl%27s_law).
  Pyinstrument helps you find it!
  > ☕️ Not sure where to start? Check out this [video tutorial from calmcode.io](https://calmcode.io/pyinstrument/introduction.html)!
  <!-- MARK intro end -->


pkgId: 76ece6ac5d1f1760a84f12423f9959c4a5070c375d2d7d812fca33457f5bef78
name: python-pyinstrument-debuginfo
arch: aarch64
version: 4.4.0
epoch: 0
release: 1
summary: Debug information for package python-pyinstrument
url: https://github.com/joerick/pyinstrument
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-0556c0fb-d134-4ae5-8593-9c0ffef171b5
rpm_sourcerpm: python-pyinstrument-4.4.0-1.src.rpm
location_href: 00010436-python-pyinstrument/python-pyinstrument-debuginfo-4.4.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyinstrument.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: fda49f1fc5c030a38a619d7bed424f574a8eaae34e07494895cf8476555ecaeb
name: python-pyinstrument-debugsource
arch: aarch64
version: 4.4.0
epoch: 0
release: 1
summary: Debug sources for package python-pyinstrument
url: https://github.com/joerick/pyinstrument
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-0556c0fb-d134-4ae5-8593-9c0ffef171b5
rpm_sourcerpm: python-pyinstrument-4.4.0-1.src.rpm
location_href: 00010436-python-pyinstrument/python-pyinstrument-debugsource-4.4.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyinstrument.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e03e2c161be46f1f8e3614bba8fd69595959ea6f7a566940867711b2a7fdbc9e
name: python-pyiqvia
arch: src
version: 2022.10.0
epoch: 0
release: 1
summary: A clean, async-focused Python3 API for IQVIA data
url: https://github.com/bachya/pyiqvia
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c75f103c-930d-4f61-96ad-26ee6c8fb696
location_href: 00004709-python-pyiqvia/python-pyiqvia-2022.10.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bachya/pyiqvia/workflows/CI/badge.svg)](https://github.com/bachya/pyiqvia/actions)
  [![PyPi](https://img.shields.io/pypi/v/pyiqvia.svg)](https://pypi.python.org/pypi/pyiqvia)
  [![Version](https://img.shields.io/pypi/pyversions/pyiqvia.svg)](https://pypi.python.org/pypi/pyiqvia)
  [![License](https://img.shields.io/pypi/l/pyiqvia.svg)](https://github.com/bachya/pyiqvia/blob/master/LICENSE)
  [![Code Coverage](https://codecov.io/gh/bachya/pyiqvia/branch/dev/graph/badge.svg)](https://codecov.io/gh/bachya/pyiqvia)
  [![Maintainability](https://api.codeclimate.com/v1/badges/3bf37f9cabf73b5d991e/maintainability)](https://codeclimate.com/github/bachya/pyiqvia/maintainability)
  [![Say Thanks](https://img.shields.io/badge/SayThanks-!-1EAEDB.svg)](https://saythanks.io/to/bachya)

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

  `pyiqvia` is an async-focused Python3 library for allergen, asthma, and disease
  data from the [IQVIA™](https://www.iqvia.com) family of websites (such as
  https://pollen.com, https://flustar.com, and more).

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



  `pyiqvia` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  ```bash
  pip install pyiqvia
  ```



  ```python
  import asyncio

  from aiohttp import ClientSession

  from pyiqvia import Client


  async def main() -> None:
      """Run!"""
      
      client = Client("80012")

      
      await client.allergens.current()

      
      await client.allergens.outlook()

      
      await client.allergens.extended()

      
      await client.allergens.historic()

      
      await client.asthma.current()

      
      await client.asthma.extended()

      
      await client.asthma.historic()

      
      await client.disease.current()

      
      await client.disease.extended()

      
      await client.disease.historic()


  asyncio.run(main())
  ```



  By default, `pyiqvia` will retry appropriate errors 4 times (with an exponentially
  increasing delay in-between). This logic can be changed by passing a different value for
  `request_retries` to the `Client` constructor:

  ```python
  import asyncio

  from pyiqvia import Client


  async def main():
      client = Client("80012", request_retries=5)

      


  asyncio.run(main())
  ```



  By default, the library creates a new connection to IQVIA with each coroutine. If you
  are calling a large number of coroutines (or merely want to squeeze out every second of
  runtime savings possible), an
  [`aiohttp`](https://github.com/aio-libs/aiohttp) `ClientSession` can be used for connection
  pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pyiqvia import Client


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          client = Client("80012", session=session)

          


  asyncio.run(main())
  ```



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


pkgId: a23b03c2947e57ea97d1a5b307687d850650d0a80f7ba53e8386cd7ea1a8912f
name: python-pyiso8583
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: A serializer and deserializer of ISO8583 data.
url: https://github.com/knovichikhin/pyiso8583
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-15f83900-d039-4112-8b9c-89d60c601b91
location_href: 00011698-python-pyiso8583/python-pyiso8583-2.2.0-1.src.rpm
checksum_type: sha256
description:
  |pypi| |docs| |coverage|
  ``iso8583`` package serializes and deserializes ISO8583 data between
  raw ``bytes`` ISO8583 data and a regular Python ``dict``.
  ``iso8583`` package supports custom `specifications <https://pyiso8583.readthedocs.io/en/latest/specifications.html>`_
  that can define:
  - Field length and data encoding, such as BCD, ASCII, EBCDIC, etc.
  - Field length count measured in bytes or nibbles.
  - Field type, such as fixed, LLVAR, LLLVAR, etc.
  - Maximum length
  - Optional field description
  Multiple specifications can co-exist to support ISO8583 messages for POS, ATM,
  file actions, and so on. Simply define a new specification dictionary. ``iso8583``
  package includes a starter specification in ``iso8583.specs`` module that can be
  used as a base to create own custom/proprietary specifications.
  Additional information is available on `Read The Docs <http://pyiso8583.readthedocs.org>`_.


pkgId: d069433e1ac11a99efa568df854e46cc61803c2ef4a467778edc8cd820d674ba
name: python-pyjks
arch: src
version: 20.0.0
epoch: 0
release: 1
summary: Pure-Python Java Keystore (JKS) library
url: http://github.com/kurtbrose/pyjks
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-88f687dd-0d23-4b6b-9cb2-1c4f95438249
location_href: 00010949-python-pyjks/python-pyjks-20.0.0-1.src.rpm
checksum_type: sha256
description:
  PyJKS enables Python projects to load and manipulate Java KeyStore
  (JKS) data without a JVM dependency. PyJKS supports JKS, JCEKS, BKS
  and UBER (BouncyCastle) keystores. Simply::

    pip install pyjks

  Or::

    easy_install pyjks

  Then::

    import jks

    keystore = jks.KeyStore.load('keystore.jks', 'passphrase')

    print(keystore.private_keys)
    print(keystore.certs)
    print(keystore.secret_keys)

  And that's barely scratching the surface. Check out `the usage examples on
  GitHub <https://github.com/kurtbrose/pyjks#usage-examples>`_ for
  more!


pkgId: 56e85ac9d13e1e9fed0410a2d8580a9b16a67bdf2a2157f3655fb8891a090293
name: python-pyjnius
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: A Python module to access Java classes as Python classes using JNI.
url: https://github.com/kivy/pyjnius
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ad949ef1-c0fb-422a-8f44-cc0e0c5298b4
location_href: 00004710-python-pyjnius/python-pyjnius-1.4.2-1.src.rpm
checksum_type: sha256
description:
  A Python module to access Java classes as Python classes using the Java Native
  Interface (JNI).
  Warning: the pypi name is now `pyjnius` instead of `jnius`.
  [![Tests](https://github.com/kivy/pyjnius/workflows/Continuous%20Integration/badge.svg)](https://github.com/kivy/pyjnius/actions)
  [![Tests (x86)](https://github.com/kivy/pyjnius/workflows/Continuous%20Integration%20(x86)/badge.svg)](https://github.com/kivy/pyjnius/actions)
  [![Builds](https://github.com/kivy/pyjnius/workflows/Continuous%20Delivery/badge.svg)](https://github.com/kivy/pyjnius/actions)
  [![PyPI](https://img.shields.io/pypi/v/pyjnius.svg)]()
  [![Backers on Open Collective](https://opencollective.com/kivy/backers/badge.svg)](#backers)
  [![Sponsors on Open Collective](https://opencollective.com/kivy/sponsors/badge.svg)](#sponsors)


pkgId: 6b6fc7a8343e6069a2b89bdd7f5eccb1938a2e4ef17aeca86d9e71cabfd8fb78
name: python-pykafka
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: Full-Featured Pure-Python Kafka Client
url: https://github.com/Parsely/pykafka
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d993d98d-fd51-42bc-89cd-4752b4278fca
location_href: 00004712-python-pykafka/python-pykafka-2.8.0-1.src.rpm
checksum_type: sha256
description:
  PyKafka is a programmer-friendly Kafka client for Python. It includes Python
  implementations of Kafka producers and consumers, which are optionally backed
  by a C extension built on `librdkafka`_. It runs under Python 2.7+, Python 3.4+,
  and PyPy, and supports versions of Kafka 0.8.2 and newer.
  PyKafka's primary goal is to provide a similar level of abstraction to the
  `JVM Kafka client`_ using idioms familiar to Python programmers and exposing
  the most Pythonic API possible.
  You can install PyKafka from PyPI with
      $ pip install pykafka
  or from conda-forge with
      $ conda install -c conda-forge pykafka
  Full documentation and usage examples for PyKafka can be found on `readthedocs`_.
  You can install PyKafka for local development and testing by cloning this repository and
  running
      $ python setup.py develop


pkgId: 8779ee1eedc38cad734fc03a4ca05c29b0d6219e028350add0e93821effdf68f
name: python-pykdtree-debuginfo
arch: aarch64
version: 1.3.6
epoch: 0
release: 1
summary: Debug information for package python-pykdtree
url: https://github.com/storpipfugl/pykdtree
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a09fa327-85de-4bf9-9428-ca1b80106534
rpm_sourcerpm: python-pykdtree-1.3.6-1.src.rpm
location_href: 00004714-python-pykdtree/python-pykdtree-debuginfo-1.3.6-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pykdtree.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 6d482c63942f15f62d2164198cc6cc45a8655dcd9ce8f08a23dba341f534da3a
name: python-pykdtree-debugsource
arch: aarch64
version: 1.3.6
epoch: 0
release: 1
summary: Debug sources for package python-pykdtree
url: https://github.com/storpipfugl/pykdtree
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a09fa327-85de-4bf9-9428-ca1b80106534
rpm_sourcerpm: python-pykdtree-1.3.6-1.src.rpm
location_href: 00004714-python-pykdtree/python-pykdtree-debugsource-1.3.6-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pykdtree.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 34448f2246c6d3e89418d9bcb8e4846c30f7c89e6a36fdb92b520264adf28e1a
name: python-pykeepass
arch: src
version: 4.0.3
epoch: 0
release: 1
summary: Python library to interact with keepass databases (supports KDBX3 and KDBX4)
url: https://github.com/libkeepass/pykeepass
rpm_license: GPL3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fcf1d96e-76f8-4f9e-a911-8c5040d9b788
location_href: 00004717-python-pykeepass/python-pykeepass-4.0.3-1.src.rpm
checksum_type: sha256
description:
  This library allows you to write entries to a KeePass database.
  Come chat at `#pykeepass`_ on Freenode or `#pykeepass:matrix.org`_ on Matrix.


pkgId: d73388e0f394fc9552b882e155dcff75c16ab8b101f0a134eac3a655c4886443
name: python-pykka
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: Pykka is a Python implementation of the actor model
url: https://github.com/jodal/pykka
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92b6c62b-e3eb-487f-8f96-ccaf988dcdee
location_href: 00002877-python-Pykka/python-pykka-3.1.1-1.src.rpm
checksum_type: sha256
description:
  Pykka is a Python implementation of the
  [actor model](https://en.wikipedia.org/wiki/Actor_model).
  The actor model introduces some simple rules to control
  the sharing of state and cooperation between execution units,
  which makes it easier to build concurrent applications.
  For a quickstart guide and a complete API reference,
  see the [documentation](https://pykka.readthedocs.io/).

  Pykka requires Python 3.7 or newer.
  Pykka is available from [PyPI](https://pypi.org/project/pykka/):
  ```
  python3 -m pip install pykka
  ```

  - [Documentation](https://pykka.readthedocs.io/)
  - [Source code](https://github.com/jodal/pykka)
  - [Releases](https://github.com/jodal/pykka/releases)
  - [Issue tracker](https://github.com/jodal/pykka/issues)
  - [Contributors](https://github.com/jodal/pykka/graphs/contributors)
  - [Users](https://github.com/jodal/pykka/wiki/Users)

  Pykka is copyright 2010-2022 Stein Magnus Jodal and contributors.
  Pykka is licensed under the
  [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: bb7cf418658589c9c861b6e90374b58f21fb9d5b5a16031387c185ded273dc61
name: python-pyknp
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Python module for JUMAN/KNP
url: https://github.com/ku-nlp/pyknp
rpm_license: See COPYING
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a7b8d55a-a134-49c7-a1c0-c20e72fc3486
location_href: 00012380-python-pyknp/python-pyknp-0.6.1-1.src.rpm
checksum_type: sha256
description:
  形態素解析器JUMAN++(JUMAN)と構文解析器KNPのPythonバインディング (Python2系と3系の両方に対応)。


  - Python
      - Verified Versions: 2.7.15,  3.7.11
  - 形態素解析器 [JUMAN++](http://nlp.ist.i.kyoto-u.ac.jp/index.php?JUMAN++) [[EN](http://nlp.ist.i.kyoto-u.ac.jp/EN/index.php?JUMAN++)]
  (or [JUMAN](http://nlp.ist.i.kyoto-u.ac.jp/index.php?JUMAN)[[EN](http://nlp.ist.i.kyoto-u.ac.jp/EN/index.php?JUMAN)])
      - JUMAN++ はJUMANの後継にあたる形態素解析器
  - 構文解析器 [KNP](http://nlp.ist.i.kyoto-u.ac.jp/index.php?KNP) [[EN](http://nlp.ist.i.kyoto-u.ac.jp/EN/index.php?KNP)]


  ```
  $ pip install pyknp
  ```


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



  京都大学 黒橋・河原研究室 (contact@nlp.ist.i.kyoto-u.ac.jp)
  - John Richardson, Tomohide Shibata, Yuta Hayashibe, Tomohiro Sakaguchi


pkgId: 7edbe4035077068e175dc0277a4483c2986e59603897ee16a45827afd45f92e7
name: python-pykube-ng
arch: src
version: 22.9.0
epoch: 0
release: 1
summary: Python client library for Kubernetes
url: https://codeberg.org/hjacobs/pykube-ng
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-15fae336-1569-408b-bca8-4fdb64baaae8
location_href: 00012292-python-pykube-ng/python-pykube-ng-22.9.0-1.src.rpm
checksum_type: sha256
description:
  Pykube (pykube-ng) is a lightweight Python 3.6+ client library for Kubernetes.
  This is a fork of `kelproject/pykube <https://github.com/kelproject/pykube>`_ which is no longer maintained (archived). Here the original text of the pykube README:
      Kel is an open source Platform as a Service (PaaS) from Eldarion, Inc. that
      makes it easy to manage web application deployment and hosting through the
      entire lifecycle from development through testing to production. It adds
      components and tools on top of Kubernetes that help developers manage their
      application infrastructure. Kel builds on Eldarion's 7+ years experience running
      one of the leading Python and Django PaaSes.
      For more information about Kel, see `kelproject.com`_ or follow us on Twitter
      `@projectkel`_.


pkgId: 79e575729b7152fb6a8f883cbcaef6f8a5d517643357d141a6734948ce7949cd
name: python-pylama
arch: src
version: 8.4.1
epoch: 0
release: 1
summary: Code audit tool for python
url: https://github.com/klen/pylama
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e55a3d2f-68a8-4a06-8df1-dce4e412070d
location_href: 00011801-python-pylama/python-pylama-8.4.1-1.src.rpm
checksum_type: sha256
description:
  - Python (3.7, 3.8, 3.9, 3.10)
  - If your tests are failing on Win platform you are missing: ``curses`` -
    http://www.lfd.uci.edu/~gohlke/pythonlibs/ (The curses library supplies a
    terminal-independent screen-painting and keyboard-handling facility for
    text-based terminals)
  For python versions < 3.7 install pylama 7.7.1


pkgId: 5923361b95a07b6249bd943eb3a584f903a17004fe1a313298a0c05c86188d26
name: python-pylast
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: A Python interface to Last.fm and Libre.fm
url: https://github.com/pylast/pylast
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92c06e18-86c3-4a77-bb1d-9e7dc3004d55
location_href: 00004719-python-pylast/python-pylast-5.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/pylast.svg)](https://pypi.org/project/pylast/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/pylast.svg)](https://pypi.org/project/pylast/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/pylast.svg)](https://pypistats.org/packages/pylast)
  [![Test](https://github.com/pylast/pylast/workflows/Test/badge.svg)](https://github.com/pylast/pylast/actions)
  [![Coverage (Codecov)](https://codecov.io/gh/pylast/pylast/branch/main/graph/badge.svg)](https://codecov.io/gh/pylast/pylast)
  [![Code style: Black](https://img.shields.io/badge/code%20style-Black-000000.svg)](https://github.com/psf/black)
  [![DOI](https://zenodo.org/badge/7803088.svg)](https://zenodo.org/badge/latestdoi/7803088)

  A Python interface to [Last.fm](https://www.last.fm/) and other API-compatible websites
  such as [Libre.fm](https://libre.fm/).

  Use the pydoc utility for help on usage or see [tests/](tests/) for examples.



  Install via pip:

  ```sh
  python3 -m pip install pylast
  ```

  Install latest development version:

  ```sh
  python3 -m pip install -U git+https://github.com/pylast/pylast
  ```

  Or from requirements.txt:

  ```txt
  -e https://github.com/pylast/pylast.git#egg=pylast
  ```

  Note:

  * pyLast 5.1+ supports Python 3.7-3.11.
  * pyLast 5.0+ supports Python 3.7-3.10.
  * pyLast 4.3+ supports Python 3.6-3.10.
  * pyLast 4.0 - 4.2 supports Python 3.6-3.9.
  * pyLast 3.2 - 3.3 supports Python 3.5-3.8.
  * pyLast 3.0 - 3.1 supports Python 3.5-3.7.
  * pyLast 2.2 - 2.4 supports Python 2.7.10+, 3.4-3.7.
  * pyLast 2.0 - 2.1 supports Python 2.7.10+, 3.4-3.6.
  * pyLast 1.7 - 1.9 supports Python 2.7, 3.3-3.6.
  * pyLast 1.0 - 1.6 supports Python 2.7, 3.3-3.4.
  * pyLast 0.5 supports Python 2, 3.
  * pyLast < 0.5 supports Python 2.



   * Simple public interface.
   * Access to all the data exposed by the Last.fm web services.
   * Scrobbling support.
   * Full object-oriented design.
   * Proxy support.
   * Internal caching support for some web services calls (disabled by default).
   * Support for other API-compatible networks like Libre.fm.




  Here's some simple code example to get you started. In order to create any object from
  pyLast, you need a `Network` object which represents a social music network that is
  Last.fm or any other API-compatible one. You can obtain a pre-configured one for Last.fm
  and use it as follows:

  ```python
  import pylast



  API_KEY = "b25b959554ed76058ac220b7b2e0a026"  # this is a sample key
  API_SECRET = "425b55975eed76058ac220b7b4e8a054"


  username = "your_user_name"
  password_hash = pylast.md5("your_password")

  network = pylast.LastFMNetwork(
      api_key=API_KEY,
      api_secret=API_SECRET,
      username=username,
      password_hash=password_hash,
  )


  track = network.get_track("Iron Maiden", "The Nomad")
  track.love()
  track.add_tags(("awesome", "favorite"))



  ```

  More examples in
  <a href="https://github.com/hugovk/lastfm-tools">hugovk/lastfm-tools</a> and
  [tests/](https://github.com/pylast/pylast/tree/main/tests).



  The [tests/](https://github.com/pylast/pylast/tree/main/tests) directory contains
  integration and unit tests with Last.fm, and plenty of code examples.

  For integration tests you need a test account at Last.fm that will become cluttered with
  test data, and an API key and secret. Either copy
  [example_test_pylast.yaml](example_test_pylast.yaml) to test_pylast.yaml and fill out
  the credentials, or set them as environment variables like:

  ```sh
  export PYLAST_USERNAME=TODO_ENTER_YOURS_HERE
  export PYLAST_PASSWORD_HASH=TODO_ENTER_YOURS_HERE
  export PYLAST_API_KEY=TODO_ENTER_YOURS_HERE
  export PYLAST_API_SECRET=TODO_ENTER_YOURS_HERE
  ```

  To run all unit and integration tests:

  ```sh
  python3 -m pip install -e ".[tests]"
  pytest
  ```

  Or run just one test case:

  ```sh
  pytest -k test_scrobble
  ```

  To run with coverage:

  ```sh
  pytest -v --cov pylast --cov-report term-missing
  coverage report # for command-line report
  coverage html   # for HTML report
  open htmlcov/index.html
  ```



  To enable from your own code:

  ```python
  import logging
  import pylast

  logging.basicConfig(level=logging.INFO)


  network = pylast.LastFMNetwork(...)
  ```

  To enable from pytest:

  ```sh
  pytest --log-cli-level info -k test_album_search_images
  ```

  To also see data returned from the API, use `level=logging.DEBUG` or
  `--log-cli-level debug` instead.


pkgId: fd9f50a6f3d1a781b69e248cb17f03c6266c6861b3138357c824c427e6c3a3cf
name: python-pylev
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: A pure Python Levenshtein implementation that's not freaking GPL'd.
url: http://github.com/toastdriven/pylev
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-80f20b03-ae93-4464-b4f3-c3d2534d0be1
location_href: 00004721-python-pylev/python-pylev-1.4.0-1.src.rpm
checksum_type: sha256
description:
  A pure Python Levenshtein implementation that's not freaking GPL'd.
  Based off the Wikipedia code samples at
  http://en.wikipedia.org/wiki/Levenshtein_distance.


pkgId: ea8ff611a357e13de1a564916fcc9d4f19ccdcfbab195b9a40d533caa281d47b
name: python-pylibacl
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: POSIX.1e ACLs for python
url: https://pylibacl.k1024.org/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f19cb1a4-85dc-4b9a-b5c5-f0301d577b70
location_href: 00004722-python-pylibacl/python-pylibacl-0.6.0-1.src.rpm
checksum_type: sha256
description:
  This is a C extension module for Python which
  implements POSIX ACLs manipulation. It is a wrapper on top
  of the systems's acl C library - see acl(5).


pkgId: d66a326ab8739f332345c2912d73482be2d28e9d7f55319e7fd3370805de91d2
name: python-pylibftdi
arch: src
version: 0.20.0
epoch: 0
release: 1
summary: Pythonic interface to FTDI devices using libftdi
url: https://github.com/codedstructure/pylibftdi
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-385d7dca-d7be-4edb-b723-d455608b845b
location_href: 00010719-python-pylibftdi/python-pylibftdi-0.20.0-1.src.rpm
checksum_type: sha256
description:
  pylibftdi is a minimal Pythonic interface to FTDI devices using libftdi_.
   - No dependencies beyond standard library and a `libftdi` install.
   - Supports parallel and serial devices
   - Support for multiple devices
   - File-like interface wherever appropriate
   - Cross-platform
   - The API might change prior to reaching a 1.0 release.


pkgId: c7d1ca93c7461993d93b6d229b7f19357e871a9faab733109e75b6904845be97
name: python-pylibjpeg
arch: src
version: 1.4.0
epoch: 0
release: 1
url: https://github.com/pydicom/pylibjpeg
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-89ed811d-8f87-43d4-b819-7aa90a8f491f
location_href: 00013512-python-pylibjpeg/python-pylibjpeg-1.4.0-1.src.rpm
checksum_type: sha256
summary:
  A Python framework for decoding JPEG and decoding/encoding DICOM RLE data, with a focus on supporting pydicom

description:
  [![codecov](https://codecov.io/gh/pydicom/pylibjpeg/branch/master/graph/badge.svg)](https://codecov.io/gh/pydicom/pylibjpeg)
  [![Build Status](https://github.com/pydicom/pylibjpeg/workflows/build/badge.svg)](https://github.com/pydicom/pylibjpeg/actions?query=workflow%3Abuild)
  [![PyPI version](https://badge.fury.io/py/pylibjpeg.svg)](https://badge.fury.io/py/pylibjpeg)
  [![Python versions](https://img.shields.io/pypi/pyversions/pylibjpeg.svg)](https://img.shields.io/pypi/pyversions/pylibjpeg.svg)



  A Python 3.7+ framework for decoding JPEG images and decoding/encoding RLE datasets, with a focus on providing support for [pydicom](https://github.com/pydicom/pydicom).





  ```
  pip install pylibjpeg
  ```



  The package can be installed with extra requirements to enable support for JPEG (with `libjpeg`), JPEG 2000 (with `openjpeg`) and Run-Length Encoding (RLE) (with `rle`), respectively:

  ```
  pip install pylibjpeg[libjpeg,openjpeg,rle]
  ```

  Or alternatively with just `all`:

  ```
  pip install pylibjpeg[all]
  ```



  Make sure [Git](https://git-scm.com/) is installed, then
  ```bash
  git clone https://github.com/pydicom/pylibjpeg
  python -m pip install pylibjpeg
  ```



  One or more plugins are required before *pylibjpeg* is able to handle JPEG images or RLE datasets. To handle a given format or DICOM Transfer Syntax
  you first have to install the corresponding package:


  |Format                   |Decode?|Encode?|Plugin                 |Based on     |
  |---                      |------ |---    |---                    |---          |
  |JPEG, JPEG-LS and JPEG XT|Yes    |No     |[pylibjpeg-libjpeg][1] |[libjpeg][2] |
  |JPEG 2000                |Yes    |No     |[pylibjpeg-openjpeg][3]|[openjpeg][4]|
  |RLE Lossless (PackBits)  |Yes    |Yes    |[pylibjpeg-rle][5]     |-            |



  |UID                   | Description                                    | Plugin                |
  |---                   |---                                             |----                   |
  |1.2.840.10008.1.2.4.50|JPEG Baseline (Process 1)                       |[pylibjpeg-libjpeg][1] |
  |1.2.840.10008.1.2.4.51|JPEG Extended (Process 2 and 4)                 |[pylibjpeg-libjpeg][1] |
  |1.2.840.10008.1.2.4.57|JPEG Lossless, Non-Hierarchical (Process 14)    |[pylibjpeg-libjpeg][1] |
  |1.2.840.10008.1.2.4.70|JPEG Lossless, Non-Hierarchical, First-Order Prediction</br>(Process 14, Selection Value 1) | [pylibjpeg-libjpeg][1]|
  |1.2.840.10008.1.2.4.80|JPEG-LS Lossless                                |[pylibjpeg-libjpeg][1] |
  |1.2.840.10008.1.2.4.81|JPEG-LS Lossy (Near-Lossless) Image Compression |[pylibjpeg-libjpeg][1] |
  |1.2.840.10008.1.2.4.90|JPEG 2000 Image Compression (Lossless Only)     |[pylibjpeg-openjpeg][4]|
  |1.2.840.10008.1.2.4.91|JPEG 2000 Image Compression                     |[pylibjpeg-openjpeg][4]|
  |1.2.840.10008.1.2.5   |RLE Lossless                                    |[pylibjpeg-rle][5]     |

  If you're not sure what the dataset's *Transfer Syntax UID* is, it can be
  determined with:
  ```python
  >>> from pydicom import dcmread
  >>> ds = dcmread('path/to/dicom_file')
  >>> ds.file_meta.TransferSyntaxUID.name
  ```

  [1]: https://github.com/pydicom/pylibjpeg-libjpeg
  [2]: https://github.com/thorfdbg/libjpeg
  [3]: https://github.com/pydicom/pylibjpeg-openjpeg
  [4]: https://github.com/uclouvain/openjpeg
  [5]: https://github.com/pydicom/pylibjpeg-rle





  Assuming you have *pydicom* v2.1+ and suitable plugins installed:

  ```python
  from pydicom import dcmread
  from pydicom.data import get_testdata_file


  ds = dcmread(get_testdata_file('JPEG-LL.dcm'))
  jpg_arr = ds.pixel_array


  ds = dcmread(get_testdata_file('JPEG2000.dcm'))
  j2k_arr = ds.pixel_array


  ds = dcmread(get_testdata_file('OBXXXX1A_rle.dcm'))


  ds.decompress("pylibjpeg")
  rle_arr = ds.pixel_array
  ```

  For datasets with multiple frames you can reduce your memory usage by
  processing each frame separately using the ``generate_frames()`` generator
  function:
  ```python
  from pydicom import dcmread
  from pydicom.data import get_testdata_file
  from pydicom.pixel_data_handlers.pylibjpeg_handler import generate_frames

  ds = dcmread(get_testdata_file('color3d_jpeg_baseline.dcm'))
  frames = generate_frames(ds)
  arr = next(frames)
  ```


  You can also just use *pylibjpeg* to decode JPEG images to a [numpy ndarray](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html), provided you have a suitable plugin installed:
  ```python
  from pylibjpeg import decode


  arr = decode('filename.jpg')


  with open('filename.jpg', 'rb') as f:
      arr = decode(f)


  with open('filename.jpg', 'rb') as f:
      arr  = decode(f.read())
  ```




  Assuming you have *pydicom* v2.2+ and suitable plugins installed:

  ```python
  from pydicom import dcmread
  from pydicom.data import get_testdata_file
  from pydicom.uid import RLELossless

  ds = dcmread(get_testdata_file("CT_small.dcm"))



  ds.compress(uid)


  ds.save_as("CT_small_rle.dcm")
  ```


pkgId: 390c03de4e405690b9cbdfdcaa7878bfe68e2eebd7791dd7ee7bfd6f6251c973
name: python-pylibmc
arch: src
version: 1.6.3
epoch: 0
release: 1
summary: Quick and small memcached client for Python
url: https://sendapatch.se/projects/pylibmc/
rpm_license: 3-clause BSD <https://opensource.org/licenses/bsd-license.php>
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ed6bb89-9aa5-4be7-9701-435fc9975615
location_href: 00004724-python-pylibmc/python-pylibmc-1.6.3-1.src.rpm
checksum_type: sha256
description:
  Though no major feature overhauls have taken place, this release is partially
  incompatible with 1.5.0. This stems from the fact that python-memcached is now
  using a flag that pylibmc has been using for some years. python-memcached uses
  it for a different purpose, and an incompatible one. We deemed that it would be
  better to support this interoperability. The change also means that Unicode
  strings are now stored as UTF-8 rather than pickled, which may or may not
  result in a slight performance improvement for this type of data.
  We have also introduced a `pickle_protocol` behavior to enable seamless
  interoperability between Python 2.x and 3.x. Also, this release introduces a
  ManyLinux wheel, making installation a breeze on ManyLinux systems (which I
  suppose is many linuxes.)


pkgId: 67fbcf0ee48d7241cb23cdee835ee91e3e463540bf9c00b679ed38a8843565ed
name: python-pylint-celery
arch: src
version: 0.3
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/landscapeio/pylint-celery
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4deee19e-8a98-4c0a-91f5-d6ea34e9a34a
location_href: 00010616-python-pylint-celery/python-pylint-celery-0.3-1.src.rpm
checksum_type: sha256
summary:
  pylint-celery is a Pylint plugin to aid Pylint in recognising and understandingerrors caused when using the Celery library


pkgId: f8a7f44c0a6767ea66ec94657755a31e691a3f4c49ba1a82808732e814ae41f8
name: python-pylint-fail-under
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Pylint wrapper that verifies code reaches a minimum quality score.
url: https://github.com/TNThieding/pylint-fail-under
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2c357778-fd34-42c6-8ed7-60169ee8e5e2
location_href: 00013738-python-pylint-fail-under/python-pylint-fail-under-0.3.0-1.src.rpm
checksum_type: sha256
description:
      Your code has been rated at 9.49/10 (previous run: 9.49/10, +0.00)
  Otherwise, if the Pylint score is under the minimum, the script exits with a non-zero exit code. For
  example::
      $ pylint-fail-under --fail_under 9.75 my_package
      ************* Module my_package
      my_package\__init__.py:1:0: C0111: Missing module docstring (missing-docstring)


pkgId: a9e64c4121fc2cfe1024b4f46e4eb26eb8a8e612006ad2e70e740e5ac13cdb5f
name: python-pylint-flask
arch: src
version: 0.6
epoch: 0
release: 1
url: https://github.com/jschaf/pylint-flask
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4958a23-4153-4b5a-8de9-8d82c8913499
location_href: 00010794-python-pylint-flask/python-pylint-flask-0.6-1.src.rpm
checksum_type: sha256
summary:
  pylint-flask is a Pylint plugin to aid Pylint in recognizing and understanding errors caused when using Flask


pkgId: 0823b7a00f1085f97d552d879f25b6992ecdc1408702d028a71ff8c3fcedb1b5
name: python-pylint-protobuf
arch: src
version: 0.20.2
epoch: 0
release: 1
summary: A plugin for making Pylint aware of the fields of protobuf-generated classes
url: https://github.com/nelfin/pylint-protobuf
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8caf77bc-6715-471d-aa3b-4418be42a545
location_href: 00012649-python-pylint-protobuf/python-pylint-protobuf-0.20.2-1.src.rpm
checksum_type: sha256
description:
  `pylint-protobuf` is a Pylint plugin for making Pylint aware of generated
  fields from Protobuf types.

  Install from PyPI via:
      pip install pylint-protobuf
  Add or update `pylintrc` to load `pylint-protobuf`:
      [MASTER]
      load-plugins=pylint_protobuf

      $ cat <<EOF >person.proto
      message Person {
        required string name = 1;
      }
      EOF
      $ protoc person.proto --python_out=.
      $ cat <<EOF >readme.py
      from person_pb2 import Person
      p = Person('all arguments must be kwargs')
      p.invalid_field = 'value'
      p.name = 123
      EOF
      $ pip install pylint-protobuf
      $ pylint --load-plugins=pylint_protobuf readme.py
      ************* Module readme
      readme.py:2:4: E5904: Positional arguments are not allowed in message constructors and will raise TypeError (protobuf-no-posargs)
      readme.py:3:0: E5901: Field 'invalid_field' does not appear in the declared fields of protobuf-generated class 'Person' and will raise AttributeError on access (protobuf-undefined-attribute)
      readme.py:4:0: E5903: Field "Person.name" is of type 'str' and value 123 will raise TypeError at runtime (protobuf-type-error)

  `pylint-protobuf` supports Python 3.5 at a minimum.

  `pylint-protobuf` does not currently support the following concepts:
  * Some features of extensions: non-nested extensions, HasExtension(),
    ClearExtension(), type checking


  A `protoc` compiler plugin for generating `.pyi` stubs from `.proto` files.
  Fully-featured and well supported, a useful extension to a `mypy` workflow.
  May be better suited to your usecase if you control the entire pipeline. May
  _not_ be suited if you are a downstream consumer of generated `_pb2.py` modules
  with no access to the original `.proto` definitions, in which case
  `pylint-protobuf` may be better suited for your use.


pkgId: 1e6910627b6debf44befbfab1a1433c69d1067ee92f28e3aa33e3739d2a6e013
name: python-pylotoncycle
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Module to access your Peloton workout data
url: https://github.com/justmedude/pylotoncycle
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cb3274c1-03da-400f-8893-29afa8e26589
location_href: 00004726-python-pylotoncycle/python-pylotoncycle-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Python Library for getting your Peloton workout data.


  * [General info](#general-info)
  * [Example Usage](#example-usage)


  As someone who wants to see my progress over time, I've been wanting a way
  to pull and play with my ride data. However, I'm also cautious about linking
  myself to too many external parties. As I've been playing with other libraries
  out there, I wanted something that was a bit more intuitive and would play
  nicer with the rest of my python code. So, PylotonCycle is born.


  ```
  import pylotoncycle

  username = 'your username or email address'
  password = 'your password'
  conn = pylotoncycle.PylotonCycle(username, password)
  workouts = conn.GetRecentWorkouts(5)
  ```
  `workouts` is a list of workouts.

  An example of a list element

  ```
  {'achievement_templates': [{'description': 'Awarded for working out with a '
                                             'friend.',
                              'id': '<some id hash>',
                              'image_url': 'https://s3.amazonaws.com/peloton-achievement-images-prod/702495cd985d4791bfd3d25f36e0df72',
                              'name': 'Dynamic Duo',
                              'slug': 'two_to_tango'},
                             {'description': 'Awarded for achieving Silver in '
                                             'the May Cycling Challenge.',
                              'id': '<some id hash>',
                              'image_url': 'https://s3.amazonaws.com/challenges-and-tiers-image-prod/6b772477ccd04f189fba16f2f877faad',
                              'name': 'May Cycling Challenge',
                              'slug': 'may_cycling_challenge_silver'}],
   'created': 1589642476,
   'created_at': 1589642476,
   'device_time_created_at': 1589617276,
   'device_type': 'home_bike_v1',
   'device_type_display_name': 'Bike',
   'end_time': 1589644336,
   'fitbit_id': None,
   'fitness_discipline': 'cycling',
   'ftp_info': {'ftp': 111,
                'ftp_source': 'ftp_workout_source',
                'ftp_workout_id': '<some id hash>'},
   'has_leaderboard_metrics': True,
   'has_pedaling_metrics': True,
   'id': '<some id hash>',
   'instructor_name': 'Matt Wilpers',
   'is_total_work_personal_record': False,
   'leaderboard_rank': 5015,
   'metrics_type': 'cycling',
   'name': 'Cycling Workout',
   'overall_summary': {'avg_cadence': 85.48,
                       'avg_heart_rate': 0.0,
                       'avg_power': 179.24,
                       'avg_resistance': 47.61,
                       'avg_speed': 20.39,
                       'cadence': 0.0,
                       'calories': 496.71,
                       'distance': 10.19,
                       'heart_rate': 0.0,
                       'id': '<some id hash>',
                       'instant': 1589644336,
                       'max_cadence': 122.0,
                       'max_heart_rate': 0.0,
                       'max_power': 255.8,
                       'max_resistance': 60.95,
                       'max_speed': 23.48,
                       'power': 0.0,
                       'resistance': 0.0,
                       'seconds_since_pedaling_start': 0,
                       'speed': 0.0,
                       'total_work': 322417.21,
                       'workout_id': '<some id hash>'},
   'peloton_id': '<some id hash>',
   'platform': 'home_bike',
   'ride': {'captions': ['en-US'],
            'class_type_ids': ['<some id hash>'],
            'content_format': 'video',
            'content_provider': 'peloton',
            'description': 'Max out the effectiveness of your training with this '
                           'ride. Instructors will expertly guide you through '
                           'specific output ranges 1 through 7 to help you build '
                           'endurance, strength and speed.',
            'difficulty_estimate': 6.3779,
            'difficulty_level': None,
            'difficulty_rating_avg': 6.3779,
            'difficulty_rating_count': 17157,
            'duration': 1800,
            'equipment_ids': [],
            'equipment_tags': [],
            'excluded_platforms': [],
            'extra_images': [],
            'fitness_discipline': 'cycling',
            'fitness_discipline_display_name': 'Cycling',
            'has_closed_captions': True,
            'has_free_mode': False,
            'has_pedaling_metrics': True,
            'home_peloton_id': '<some id hash>',
            'id': '<some id hash>',
            'image_url': 'https://s3.amazonaws.com/peloton-ride-images/58aa8ebc7d51d09d6513e1a2fab53c4c62c076c6/img_1580922399_a5f1fd0e3a2e48d38ecdd6a3d874820f.png',
            'instructor_id': '<some id hash>',
            'is_archived': True,
            'is_closed_caption_shown': True,
            'is_explicit': False,
            'is_live_in_studio_only': False,
            'language': 'english',
            'length': 1940,
            'live_stream_id': '<some id hash>-live',
            'live_stream_url': None,
            'location': 'nyc',
            'metrics': ['heart_rate', 'cadence', 'calories'],
            'origin_locale': 'en-US',
            'original_air_time': 1580919480,
            'overall_estimate': 0.9956,
            'overall_rating_avg': 0.9956,
            'overall_rating_count': 20737,
            'pedaling_duration': 1800,
            'pedaling_end_offset': 1860,
            'pedaling_start_offset': 60,
            'rating': 0,
            'ride_type_id': '<some id hash>',
            'ride_type_ids': ['<some id hash>'],
            'sample_vod_stream_url': None,
            'scheduled_start_time': 1580920200,
            'series_id': '<some id hash>',
            'sold_out': False,
            'studio_peloton_id': '<some id hash>',
            'title': '30 min Power Zone Endurance Ride',
            'total_in_progress_workouts': 0,
            'total_ratings': 0,
            'total_workouts': 32489,
            'vod_stream_id': '<some id hash>-vod',
            'vod_stream_url': None},
   'start_time': 1589642537,
   'status': 'COMPLETE',
   'strava_id': None,
   'timezone': 'America/Los_Angeles',
   'title': None,
   'total_leaderboard_users': 31240,
   'total_work': 322417.21,
   'user_id': '<some id hash>',
   'workout_type': 'class'}
  ```

  An example of how you may fetch performance data for a ride
  ```
  import pprint

  conn = pylotoncycle.PylotonCycle(username, password)
  workouts = conn.GetRecentWorkouts(5)
  for w in workouts:
      workout_id = w['id']
      resp = conn.GetWorkoutMetricsById(workout_id)
      pprint.pprint(resp)

  ```


  This package is available via pip install.
  ```
  pip install pylotoncycle
  ```


  * Lots more to cover. I want to find the right format for pulling in the
  ride performance data.
  * Pull in GPS data for outdoor runs


  I'm very happy to take pull requests and fix bugs that come up. But, this is definitely a side project for me.


pkgId: 7fa9428be5ab58b980d045897542e167f336c0e3fb70d1f515bc26755105c855
name: python-pyls-black
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: Black plugin for the Python Language Server
url: https://github.com/rupert/pyls-black
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-70ca5fe8-7d0f-4dea-ad40-3d3d21f359f7
location_href: 00004728-python-pyls_black/python-pyls-black-0.4.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pyls-black.svg)](https://pypi.org/project/pyls-black/) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  > [Black](https://github.com/ambv/black) plugin for the [Python Language Server](https://github.com/palantir/python-language-server).

  In the same `virtualenv` as `python-language-server`:

  ```shell
  pip3 install pyls-black
  ```

  To avoid unexpected results you should make sure `yapf` and `autopep8` are not installed.

  * `pyls-black` can either format an entire file or just the selected text.
  * The code will only be formatted if it is syntactically valid Python.
  * Text selections are treated as if they were a separate Python file.
    Unfortunately this means you can't format an indented block of code.
  * `pyls-black` will use your project's [pyproject.toml](https://github.com/ambv/black#pyprojecttoml) if it has one.

  See the [wiki](https://github.com/rupert/pyls-black/wiki) for instructions on how to use `pyls-black` with popular text editors.


pkgId: 61274145f4859f598ed687dd64011adffefe9991f19c3d8ab62afb27a622015a
name: python-pyls-spyder
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Spyder extensions for the python-lsp-server
url: https://github.com/spyder-ide/pyls-spyder
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c8fa4f46-6372-4abe-b59b-eea3d3c9edbe
location_href: 00004727-python-pyls-spyder/python-pyls-spyder-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Project License - MIT](https://img.shields.io/pypi/l/pyls-spyder.svg)](https://raw.githubusercontent.com/spyder-ide/pyls-spyder/master/LICENSE)
  [![pypi version](https://img.shields.io/pypi/v/pyls-spyder.svg)](https://pypi.org/project/pyls-spyder/)
  [![conda version](https://img.shields.io/conda/vn/conda-forge/pyls-spyder.svg)](https://www.anaconda.com/download/)
  [![download count](https://img.shields.io/conda/dn/conda-forge/pyls-spyder.svg)](https://www.anaconda.com/download/)
  [![Downloads](https://pepy.tech/badge/pyls-spyder)](https://pepy.tech/project/pyls-spyder)
  [![PyPI status](https://img.shields.io/pypi/status/pyls-spyder.svg)](https://github.com/spyder-ide/pyls-spyder)
  ![PyLS-Spyder tests](https://github.com/spyder-ide/pyls-spyder/workflows/PyLS-Spyder%20tests/badge.svg)

  *Copyright © 2020– Spyder Project Contributors*



  Spyder extensions for the [python-lsp-server](https://github.com/python-lsp/python-lsp-server) (pylsp). This package provides Spyder-specific extras for the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/specifications/specification-current/) (LSP) on Python, such as document symbol searching and others.



  To install pyls-spyder, you can use both conda or pip package managers:

  ```bash

  conda install pyls-spyder -c spyder-ide


  pip install pyls-spyder
  ```


  This package depends on the [python-lsp-server](https://github.com/python-lsp/python-lsp-server) to integrate the Spyder-specific extensions.



  To install and develop spyder-pyls locally, you will need to install the python-lsp-server:

  ```bash

  conda install python-lsp-server


  pip install python-lsp-server
  ```

  Then, you can install the package locally using pip:

  ```bash
  pip install -U -e .
  ```


  We use pytest to run tests as it follows:

  ```bash
  pytest -x -v pyls_spyder/tests
  ```



  |          LSP method           |              Spyder extensions                   |
  |:-----------------------------:|:------------------------------------------------:|
  | `textDocument/documentSymbol` | Find code cells `# %` and block comments `# --` |
  | `textDocument/foldingRange`   | Return code cells `# %` as code folding regions |


  This plugin can be configured by using the key `pyls_spyder` when calling `workspace/didChangeConfiguration` on the pyls. Each configuration option is described below:

  <table>
      <thead>
          <tr>
              <th>LSP method</th>
              <th>Configuration Key</th>
              <th>Type</th>
              <th>Description</th>
          </tr>
      </thead>
      <tbody>
          <tr>
              <td rowspan=2><code>textDocument/documentSymbol</code></td>
              <td><code>group_cells</code></td>
              <td><code>bool</code></td>
              <td>Enable/Disable code cell grouping according to the total number of leading percentages</td>
          </tr>
          <tr>
              <td><code>enable_block_comments</code></td>
              <td><code>bool</code></td>
              <td>Enable/disable block comment detection</td>
          </tr>
      </tbody>
  </table>


  Please see our [CHANGELOG](https://github.com/spyder-ide/pyls-spyder/blob/master/CHANGELOG.md) file to learn more about our new features and improvements.



  We follow PEP8 and PEP257 for all Python modules. We use MyPy type annotations for all functions and classes declared on this package. Feel free to send a PR or create an issue if you have any problem/question.


pkgId: f5a2dd18b33739e2d1ab5a3ea7f26974070710c7a401991c78b0912af7f49bca
name: python-pylsqpack
arch: src
version: 0.3.17
epoch: 0
release: 1
summary: Python wrapper for the ls-qpack QPACK library
url: https://pypi.org/project/pylsqpack/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94649b9a-2de1-405c-9a71-45901a067bb6
location_href: 00013050-python-pylsqpack/python-pylsqpack-0.3.17-1.src.rpm
checksum_type: sha256
description:
  |rtd| |pypi-v| |pypi-pyversions| |pypi-l| |tests|
  ``pylsqpack`` is a wrapper around the `ls-qpack`_ library. It provides Python
  `Decoder` and `Encoder` objects to read or write HTTP/3 headers compressed
  with QPACK.
  To learn more about ``pylsqpack`` please `read the documentation`_.


pkgId: b7724ad0d67459bd66e89cebbd3f113f6cb08d952a42d2146d9df9e94d812c9e
name: python-pylsqpack-debuginfo
arch: aarch64
version: 0.3.17
epoch: 0
release: 1
summary: Debug information for package python-pylsqpack
url: https://pypi.org/project/pylsqpack/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-94649b9a-2de1-405c-9a71-45901a067bb6
rpm_sourcerpm: python-pylsqpack-0.3.17-1.src.rpm
location_href: 00013050-python-pylsqpack/python-pylsqpack-debuginfo-0.3.17-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pylsqpack.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: d1299e04fdc94a93fa274984def2bdf7d76e11352a1e8aad72eff99d4e4ac3a0
name: python-pylsqpack-debugsource
arch: aarch64
version: 0.3.17
epoch: 0
release: 1
summary: Debug sources for package python-pylsqpack
url: https://pypi.org/project/pylsqpack/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-94649b9a-2de1-405c-9a71-45901a067bb6
rpm_sourcerpm: python-pylsqpack-0.3.17-1.src.rpm
location_href: 00013050-python-pylsqpack/python-pylsqpack-debugsource-0.3.17-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pylsqpack.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 733a8201dccc2c49722c3dddebcc62196f2cf1ac4a3a01edadb765c31f5a95b4
name: python-pymannkendall
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: A python package for non-parametric Mann-Kendall family of trend tests.
url: https://github.com/mmhs013/pymannkendall
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-304e41a6-e765-4322-a4b8-92b04f6b0337
location_href: 00010083-python-pymannkendall/python-pymannkendall-1.4.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/mmhs013/pyMannKendall.svg?branch=master)](https://travis-ci.com/mmhs013/pyMannKendall)
  [![PyPI](https://img.shields.io/pypi/v/pymannkendall.svg)](https://pypi.org/project/pymannkendall/)
  [![PyPI - License](https://img.shields.io/pypi/l/pymannkendall.svg)](https://pypi.org/project/pymannkendall/)
  [![PyPI - Status](https://img.shields.io/pypi/status/pymannkendall.svg)](https://pypi.org/project/pymannkendall/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pymannkendall.svg)](https://pypi.org/project/pymannkendall/)

  [![Downloads](https://pepy.tech/badge/pymannkendall)](https://pepy.tech/project/pymannkendall)
  [![Conda](https://img.shields.io/conda/dn/conda-forge/pymannkendall?label=conda-downloads)](https://anaconda.org/conda-forge/pymannkendall)

  [![Google Scholar](https://github.com/mmhs013/Citation_Parser/blob/main/images/gs_pymk_cite.svg?raw=true)](https://scholar.google.com/scholar?q=pyMannKendall%3A+a+python+package+for+non+parametric+Mann+Kendall+family+of+trend+tests.)
  [![Researchgate](https://github.com/mmhs013/Citation_Parser/blob/main/images/rg_pymk_cite.svg?raw=true)](https://www.researchgate.net/publication/334688255_pyMannKendall_a_python_package_for_non_parametric_Mann_Kendall_family_of_trend_tests)

  [![status](http://joss.theoj.org/papers/14903dbd55343be89105112e585d262a/status.svg)](http://joss.theoj.org/papers/14903dbd55343be89105112e585d262a)
  [![DOI](https://zenodo.org/badge/174495388.svg)](https://zenodo.org/badge/latestdoi/174495388)


  The Mann-Kendall Trend Test (sometimes called the MK test) is used to analyze time series data for consistently increasing or decreasing trends (monotonic trends). It is a non-parametric test, which means it works for all distributions (i.e. data doesn't have to meet the assumption of normality), but data should have no serial correlation. If the data has a serial correlation, it could affect in significant level (p-value). It could lead to misinterpretation. To overcome this problem, researchers proposed several modified Mann-Kendall tests (Hamed and Rao Modified MK Test, Yue and Wang Modified MK Test, Modified MK test using Pre-Whitening method, etc.). Seasonal Mann-Kendall test also developed to remove the effect of seasonality.

  Mann-Kendall Test is a powerful trend test, so several others modified Mann-Kendall tests like Multivariate MK Test, Regional MK Test, Correlated MK test, Partial MK Test, etc. were developed for the spacial condition. `pyMannkendal` is a pure Python implementation of non-parametric Mann-Kendall trend analysis, which bring together almost all types of Mann-Kendall Test. Currently, this package has 11 Mann-Kendall Tests and 2 sen's slope estimator function. Brief description of functions are below:

  1.	**Original Mann-Kendall test (*original_test*):** Original Mann-Kendall test is a nonparametric test, which does not consider serial correlation or seasonal effects.

  2.	**Hamed and Rao Modified MK Test (*hamed_rao_modification_test*):** This modified MK test proposed by *Hamed and Rao (1998)* to address serial autocorrelation issues. They suggested a variance correction approach to improve trend analysis. User can consider first n significant lag by insert lag number in this function. By default, it considered all significant lags.

  3.	**Yue and Wang Modified MK Test (*yue_wang_modification_test*):** This is also a variance correction method for considered serial autocorrelation proposed by *Yue, S., & Wang, C. Y. (2004)*. User can also set their desired significant n lags for the calculation.

  4.	**Modified MK test using Pre-Whitening method (*pre_whitening_modification_test*):** This test suggested by *Yue and Wang (2002)* to using Pre-Whitening the time series before the application of trend test.

  5.	**Modified MK test using Trend free Pre-Whitening method (*trend_free_pre_whitening_modification_test*):** This test also proposed by *Yue and Wang (2002)* to remove trend component and then Pre-Whitening the time series before application of trend test.

  6.	**Multivariate MK Test (*multivariate_test*):** This is an MK test for multiple parameters proposed by *Hirsch (1982)*. He used this method for seasonal mk test, where he considered every month as a parameter.

  7.	**Seasonal MK Test (*seasonal_test*):** For seasonal time series data, *Hirsch, R.M., Slack, J.R. and Smith, R.A. (1982)* proposed this test to calculate the seasonal trend.

  8.	**Regional MK Test (*regional_test*):** Based on*Hirsch (1982)* proposed seasonal mk test, *Helsel, D.R. and Frans, L.M., (2006)* suggest regional mk test to calculate the overall trend in a regional scale.

  9.	**Correlated Multivariate MK Test (*correlated_multivariate_test*):** This multivariate mk test proposed by *Hipel (1994)* where the parameters are correlated.

  10.	**Correlated Seasonal MK Test (*correlated_seasonal_test*):** This method proposed by *Hipel (1994)* used, when time series significantly correlated with the preceding one or more months/seasons.

  11.	**Partial MK Test (*partial_test*):** In a real event, many factors are affecting the main studied response parameter, which can bias the trend results. To overcome this problem, *Libiseller (2002)* proposed this partial mk test. It required two parameters as input, where, one is response parameter and other is an independent parameter.

  12.	**Theil-Sen's Slope Estimator (*sens_slope*):** This method proposed by *Theil (1950)* and *Sen (1968)* to estimate the magnitude of the monotonic trend. Intercept is calculate using *Conover, W.J. (1980)* method.

  13.	**Seasonal Theil-Sen's Slope Estimator (*seasonal_sens_slope*):** This method proposed by *Hipel (1994)* to estimate the magnitude of the monotonic trend, when data has seasonal effects. Intercept is calculate using *Conover, W.J. (1980)* method.



  All Mann-Kendall test functions have almost similar input parameters. Those are:

  - **x**:   a vector (list, numpy array or pandas series) data
  - **alpha**: significance level (0.05 is the default)
  - **lag**: No. of First Significant Lags (Only available in hamed_rao_modification_test and yue_wang_modification_test)
  - **period**: seasonal cycle. For monthly data it is 12, weekly data it is 52 (Only available in seasonal tests)

  And all Mann-Kendall tests return a named tuple which contained:

  - **trend**: tells the trend (increasing, decreasing or no trend)
  - **h**: True (if trend is present) or False (if the trend is absence)
  - **p**: p-value of the significance test
  - **z**: normalized test statistics
  - **Tau**: Kendall Tau
  - **s**: Mann-Kendal's score
  - **var_s**: Variance S
  - **slope**: Theil-Sen estimator/slope
  - **intercept**: intercept of Kendall-Theil Robust Line, for seasonal test, full period cycle consider as unit time step

  sen's slope function required data vector. seasonal sen's slope also has optional input period, which by the default value is 12. Both sen's slope function return only slope value.



  For the installation of `pyMannKendall`, the following packages are required:
  - [numpy](https://www.numpy.org/)
  - [scipy](https://www.scipy.org/)



  You can install `pyMannKendall` using pip. For Linux users

  ```python
  sudo pip install pymannkendall
  ```

  or, for Windows user

  ```python
  pip install pymannkendall
  ```

  or, you can use conda
  ```python
  conda install -c conda-forge pymannkendall
  ```

  or you can clone the repo and install it:

  ```bash
  git clone https://github.com/mmhs013/pymannkendall
  cd pymannkendall
  python setup.py install
  ```



  `pyMannKendall` is automatically tested using `pytest` package on each commit [here](https://travis-ci.org/mmhs013/pyMannKendall/), but the tests can be manually run:

  ```
  pytest -v
  ```



  A quick example of `pyMannKendall` usage is given below. Several more examples are provided [here](https://github.com/mmhs013/pyMannKendall/blob/master/Examples/Example_pyMannKendall.ipynb).

  ```python
  import numpy as np
  import pymannkendall as mk


  data = np.random.rand(360,1)

  result = mk.original_test(data)
  print(result)
  ```
  Output are like this:
  ```python
  Mann_Kendall_Test(trend='no trend', h=False, p=0.9507221701045581, z=0.06179991635055463, Tau=0.0021974620860414733, s=142.0, var_s=5205500.0, slope=1.0353584906597959e-05, intercept=0.5232692553379981)
  ```
  Whereas, the output is a named tuple, so you can call by name for specific result:
  ```python
  print(result.slope)
  ```
  or, you can directly unpack your results like this:
  ```python
  trend, h, p, z, Tau, s, var_s, slope, intercept = mk.original_test(data)
  ```



  [![Google Scholar](https://github.com/mmhs013/Citation_Parser/blob/main/images/gs_pymk_cite.svg?raw=true)](https://scholar.google.com/scholar?q=pyMannKendall%3A+a+python+package+for+non+parametric+Mann+Kendall+family+of+trend+tests.)
  [![Researchgate](https://github.com/mmhs013/Citation_Parser/blob/main/images/rg_pymk_cite.svg?raw=true)](https://www.researchgate.net/publication/334688255_pyMannKendall_a_python_package_for_non_parametric_Mann_Kendall_family_of_trend_tests)

  If you publish results for which you used `pyMannKendall`, please give credit by citing [Hussain et al., (2019)](https://doi.org/10.21105/joss.01556):

  > Hussain et al., (2019). pyMannKendall: a python package for non parametric Mann Kendall family of trend tests.. Journal of Open Source Software, 4(39), 1556, https://doi.org/10.21105/joss.01556


  ```
  @article{Hussain2019pyMannKendall,
  	journal = {Journal of Open Source Software},
  	doi = {10.21105/joss.01556},
  	issn = {2475-9066},
  	number = {39},
  	publisher = {The Open Journal},
  	title = {pyMannKendall: a python package for non parametric Mann Kendall family of trend tests.},
  	url = {http://dx.doi.org/10.21105/joss.01556},
  	volume = {4},
  	author = {Hussain, Md. and Mahmud, Ishtiak},
  	pages = {1556},
  	date = {2019-07-25},
  	year = {2019},
  	month = {7},
  	day = {25},
  }
  ```



  `pyMannKendall` is a community project and welcomes contributions. Additional information can be found in the [contribution guidelines](https://github.com/mmhs013/pyMannKendall/blob/master/CONTRIBUTING.md).




  `pyMannKendall` wishes to maintain a positive community. Additional details can be found in the [Code of Conduct](https://github.com/mmhs013/pyMannKendall/blob/master/CODE_OF_CONDUCT.md).




  1. Bari, S. H., Rahman, M. T. U., Hoque, M. A., & Hussain, M. M. (2016). Analysis of seasonal and annual rainfall trends in the northern region of Bangladesh. *Atmospheric Research*, 176, 148-158. doi:[10.1016/j.atmosres.2016.02.008](https://doi.org/10.1016/j.atmosres.2016.02.008)

  2. Conover, W.J., (1980). Some methods based on ranks (Chapter 5), [Practical nonparametric statistics (2nd Ed.)](https://www.wiley.com/en-us/Practical+Nonparametric+Statistics%2C+3rd+Edition-p-9780471160687), *John Wiley and Sons*.

  3. Cox, D. R., & Stuart, A. (1955). Some quick sign tests for trend in location and dispersion. *Biometrika*, 42(1/2), 80-95. doi:[10.2307/2333424](https://doi.org/10.2307/2333424)

  4. Hamed, K. H., & Rao, A. R. (1998). A modified Mann-Kendall trend test for autocorrelated data. *Journal of hydrology*, 204(1-4), 182-196. doi:[10.1016/S0022-1694(97)00125-X](https://doi.org/10.1016/S0022-1694(97)00125-X)

  5. Helsel, D. R., & Frans, L. M. (2006). Regional Kendall test for trend. *Environmental science & technology*, 40(13), 4066-4073. doi:[10.1021/es051650b](https://doi.org/10.1021/es051650b)

  6. Hipel, K. W., & McLeod, A. I. (1994). Time series modelling of water resources and environmental systems (Vol. 45). Elsevier.

  7. Hirsch, R. M., Slack, J. R., & Smith, R. A. (1982). Techniques of trend analysis for monthly water quality data. *Water resources research*, 18(1), 107-121. doi:[10.1029/WR018i001p00107](https://doi.org/10.1029/WR018i001p00107)

  8. Jacquelin Dietz, E., (1987). A comparison of robust estimators in simple linear regression: A comparison of robust estimators. Communications in Statistics-Simulation and Computation, 16(4), pp.1209-1227. doi: [10.1080/03610918708812645](https://doi.org/10.1080/03610918708812645)

  9. Kendall, M. (1975). Rank correlation measures. *Charles Griffin*, London, 202, 15.

  10. Libiseller, C., & Grimvall, A. (2002). Performance of partial Mann-Kendall tests for trend detection in the presence of covariates. *Environmetrics: The official journal of the International Environmetrics Society*, 13(1), 71-84. doi:[10.1002/env.507](https://doi.org/1010.1002/env.507)

  11. Mann, H. B. (1945). Nonparametric tests against trend. *Econometrica: Journal of the Econometric Society*, 245-259. doi:[10.2307/1907187](https://doi.org/10.2307/1907187)

  12. Sen, P. K. (1968). Estimates of the regression coefficient based on Kendall's tau. *Journal of the American statistical association*, 63(324), 1379-1389. doi:[10.1080/01621459.1968.10480934](https://doi.org/10.1080/01621459.1968.10480934)

  13. Theil, H. (1950). A rank-invariant method of linear and polynominal regression analysis (parts 1-3). In *Ned. Akad. Wetensch. Proc. Ser. A* (Vol. 53, pp. 1397-1412).

  14. Yue, S., & Wang, C. (2004). The Mann-Kendall test modified by effective sample size to detect trend in serially correlated hydrological series. *Water resources management*, 18(3), 201-218. doi:[10.1023/B:WARM.0000043140.61082.60](https://doi.org/10.1023/B:WARM.0000043140.61082.60)

  15. Yue, S., & Wang, C. Y. (2002). Applicability of prewhitening to eliminate the influence of serial correlation on the Mann-Kendall test. *Water resources research*, 38(6), 4-1. doi:[10.1029/2001WR000861](https://doi.org/10.1029/2001WR000861)

  16. Yue, S., Pilon, P., Phinney, B., & Cavadias, G. (2002). The influence of autocorrelation on the ability to detect trend in hydrological series. *Hydrological processes*, 16(9), 1807-1829. doi:[10.1002/hyp.1095](https://doi.org/10.1002/hyp.1095)


pkgId: d89b0c4101a7ad89593f0d9ecf66590d0694a2e0180461b4131b8357f56397a3
name: python-pymatreader
arch: src
version: 0.0.30
epoch: 0
release: 1
summary: Convenient reader for Matlab mat files
url: https://gitlab.com/obob/pymatreader
rpm_license: BSD (2 clause)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-74e39c00-7454-402a-bdc6-aac238684383
location_href: 00004731-python-pymatreader/python-pymatreader-0.0.30-1.src.rpm
checksum_type: sha256
description:
  A Python module to read Matlab files. This module works with both the old (< 7.3) and the new (>= 7.3) HDF5 based format. The output should be the same for both kinds of files.


  ```python
  from pymatreader import read_mat

  data = read_mat(filename)
  ```

  `data` is a python `dict` containing all variables of the mat file.


  Documentation can be found here: <http://pymatreader.readthedocs.io/en/latest/>


  The source code can be found here: <https://gitlab.com/obob/pymatreader>


  This module is developed by Dirk Gütlin & Thomas Hartmann at the Universität Salzburg. You are free to use, copy, modify, distribute it under the terms of the BSD 2 clause license.


pkgId: be624111399410978d5d8a083a5b979267111e02424cecdc350876da27e457d1
name: python-pymc3
arch: src
version: 3.11.5
epoch: 0
release: 1
url: http://github.com/pymc-devs/pymc3
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5e13563c-f5cd-4ae7-82a4-e4438285a61f
location_href: 00004732-python-pymc3/python-pymc3-3.11.5-1.src.rpm
checksum_type: sha256
summary:
  Probabilistic Programming in Python: Bayesian Modeling and Probabilistic Machine Learning with Theano

description:
  There have been many questions and uncertainty around the future of PyMC3 since Theano
  stopped getting developed by the original authors, and we started experiments with a PyMC version based on tensorflow probability.
  Since then many things changed and we are happy to announce that PyMC3 will continue to rely on Theano,
  or rather its successors Theano-PyMC (`pymc3 <4)` and Aesara (`pymc3 >=4`).
  Check out <https://github.com/aesara-devs/aesara>`__) and specifically the latest developments on the `PyMC3 `main` branch <https://github.com/pymc-devs/pymc3/>`.


pkgId: 446373181a6da156253977c83615e30da21c3715e3c3697e5db88b2640bc079c
name: python-pymediainfo
arch: src
version: 6.0.1
epoch: 0
release: 1
summary: A Python wrapper for the mediainfo library.
url: https://github.com/sbraz/pymediainfo
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd304f6f-fbbf-47b3-a4d0-9be41ead8384
location_href: 00004734-python-pymediainfo/python-pymediainfo-6.0.1-1.src.rpm
checksum_type: sha256
description:
  This small package is a wrapper around the MediaInfo library.
  It works on Linux, Mac OS X and Windows and is tested with Python 3.7 to 3.11 and PyPy3.
  See https://pymediainfo.readthedocs.io/ for more information.


pkgId: 0a53c3d6b997698dfcd92aa970df00528e9d7e8dff75b80f4d52e42730252569
name: python-pymemcache
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: A comprehensive, fast, pure Python memcached client
url: https://github.com/pinterest/pymemcache
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ed720a4-8651-4391-9881-bc4231836dc3
location_href: 00004736-python-pymemcache/python-pymemcache-4.0.0-1.src.rpm
checksum_type: sha256
description:
  A comprehensive, fast, pure-Python memcached client.
  pymemcache supports the following features:
  * Complete implementation of the memcached text protocol.
  * Connections using UNIX sockets, or TCP over IPv4 or IPv6.
  * Configurable timeouts for socket connect and send/recv calls.
  * Access to the "noreply" flag, which can significantly increase the speed of writes.
  * Flexible, modular and simple approach to serialization and deserialization.
  * The (optional) ability to treat network and memcached errors as cache misses.


pkgId: 154fdc25c222d338b0ab3dbc65464c544ef00481e4b7c003215fc4a50d53b1ec
name: python-pymilter
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Python interface to sendmail milter API
url: https://www.pymilter.org/
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b57d04f3-ff61-488d-b233-4ab5d2f5e3b4
location_href: 00004738-python-pymilter/python-pymilter-1.0.5-1.src.rpm
checksum_type: sha256
description:
  This is a python extension module to enable python scripts to attach to
  Sendmail's libmilter API, enabling filtering of messages as they arrive.
  Since it's a script, you can do anything you want to the message - screen
  out viruses, collect statistics, add or modify headers, etc.  You can, at
  any point, tell Sendmail to reject, discard, or accept the message.

  Additional python modules provide for navigating and modifying MIME parts, and
  sending DSNs or doing CBVs.



  Python milter extension: https://pypi.python.org/pypi/pymilter/
  Python: http://www.python.org
  Sendmail: http://www.sendmail.org



   1. Build and install Sendmail, enabling libmilter (see libmilter/README).
   2. Build and install Python, enabling threading.
   3. Install this module: python setup.py --help
   4. Add these two lines to sendmail.cf[a]:

   O InputMailFilters=pythonfilter
   Xpythonfilter,        S=local:/home/username/pythonsock

   5. Run the sample.py example milter with: python sample.py
   Note that milters should almost certainly not run as root.

  That's it.  Incoming mail will cause the milter to print some things, and
  some email will be rejected (see the "header" method).  Edit and play.
  See spfmilter.py for a functional SPF milter, or see bms.py for an complex
  milter used in production.

  [a] This is for a quick test.  Your sendmail.cf in most distros will get
  overwritten whenever sendmail.mc is updated.  To make a milter permanent,
  add something like:
  ```
  INPUT_MAIL_FILTER(`pythonfilter', `S=local:/home/username/pythonsock, F=T, T=C:5m;S:20s;R:5m;E:5m')
  ```
  to sendmail.mc instead.



  First install Sendmail.  Make sure you read libmilter/README in the Sendmail
  source directory, and make sure you enable libmilter before you build.  The
  8.11 series had libmilter marked as FFR (For Future Release); 8.12
  officially supports libmilter, but it's still not built by default.

  Install Python, and enable threading in Modules/Setup.

  Install this miltermodule package; DistUtils Automatic Installation:

  $ python setup.py --help

  For versions of python prior to 2.0, you will need to download distutils
  separately or build manually.  You will need to download unittest
  separately to run the test programs.  The bdist_rpm distutils option seems
  not to work for python 2.0; upgrade to at least 2.1.1.

  Now that everything is installed, we need to tell sendmail that we're going
  to filter incoming email.  Add lines similar to the following to
  sendmail.cf:

  O InputMailFilters=pythonfilter
  Xpythonfilter,        S=local:/home/username/pythonsock

  The "O" line tells sendmail which filters to use in what order; here we're
  telling sendmail to use the filter named "pythonfilter".

  The next line, the "X" line (for "eXternal"), lists that filter along with
  some options associated with it.  In this case, we have the "S" option, which
  names the socket that sendmail will use to communicate with this particular
  milter.  This milter's socket is a unix-domain socket in the filesystem.
  See libmilter/README for the definitive list of options.

  NB: The name is specified in two places: here, in sendmail's cf file, and
  in the milter itself.  Make sure the two match.

  NB: The above lines can be added in your .mc file with this line:
  ```
  INPUT_MAIL_FILTER(`pythonfilter', `S=local:/home/username/pythonsock')
  ```
  For versions of sendmail prior to 8.12, you will need to enable
  `_FFR_MILTER` for the cf macros.  For example,

  m4 -D_FFR_MILTER ../m4/cf.m4 myconfig.mc > myconfig.cf



  The IPv6 protocol is supported if your operation system supports it
  and if sendmail was compiled with IPv6 support.  To determine if your
  sendmail supports IPv6, run "sendmail -d0" and check for the NETINET6
  compilation option.  To compile sendmail with IPv6 support, add this
  declaration to your site.config.m4 before building it:
  ```
  APPENDDEF(`confENVDEF', `-DNETINET6=1')
  ```
  IPv6 support can show up in two places; the communications socket
  between the milter and sendmail processes and in the host address
  argument to the connect() callback method.

  For sendmail to be able to accept IPv6 SMTP sessions, you must
  configure the daemon to listen on an IPv6 port.  Furthermore if you
  want to allow both IPv4 and IPv6 connections, some operating systems
  will require that each listens to different port numbers.  For an
  IPv6-only setup, your sendmail configuration should contain a line
  similar to (first line is for sendmail.mc, second is sendmail.cf):
  ```
  DAEMON_OPTIONS(`Name=MTA-v6, Family=inet6, Modify=C, Port=25')
  O DaemonPortOptions=Name=MTA-v6, Family=inet6, Modify=C, Port=25
  ```
  To allow sendmail and the milter process to communicate with each
  other over IPv6, you may use the "inet6" socket name prefix, as in:

  Xpythonfilter,        S=inet6:1234@fec0:0:0:7::5c

  The connect() callback method in the milter class will pass the
  IPv6-specific information in the 'hostaddr' argument as a tuple.  Note
  that the type of this value is dependent upon the protocol family, and
  is not compatible with IPv4 connections.  Therefore you should always
  check the family argument before attempting to use the hostaddr
  argument.  A quick example showing this follows:

    import socket

    class ipv6awareMilter(Milter.Milter):

       def connect(self,hostname,family,hostaddr):
  	if family==socket.AF_INET:
  	   ipaddress, port = hostaddr
  	elif family==socket.AF_INET6:
  	   ip6address, port, flowinfo, scopeid = hostaddr
  	elif family==socket.AF_UNIX:
  	   socketpath = hostaddr

  The hostname argument is always safe to use without interpreting the
  protocol family.  For IPv6 connections for which the hostname can not
  be determined the hostname will appear similar to the string
  "[IPv6:::1]" with the corresponding hostaddr[0] being "::1".  Refer to
  RFC 2553 for information on interpreting and using the flowinfo and
  scopeid socket attributes, both of which are integers.



  Jim Niemira (urmane@urmane.org) wrote the original C module and some quick
  and dirty python to use it.  Stuart D. Gathman (stuart@gathman.org) took that
  kludge and added threading and context objects to it, wrote a proper OO
  wrapper (Milter.py) that handles attachments, did lots of testing, packaged
  it with distutils, and generally transformed it from a quick hack to a
  real, usable Python extension.


pkgId: 6b67dde941d3e19cdcf999919ca90f71e1b8eb79cb6259996a4841f6da7f531e
name: python-pymitter
arch: src
version: 0.4.0
epoch: 0
release: 1
url: https://github.com/riga/pymitter
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c93d0ea6-52e6-4c2b-910f-1c19117b0e78
location_href: 00013346-python-pymitter/python-pymitter-0.4.0-1.src.rpm
checksum_type: sha256
summary:
  Python port of the extended Node.js EventEmitter 2 approach providing namespaces, wildcards and TTL.

description:
  [![Package Status](https://img.shields.io/pypi/v/pymitter.svg?style=flat)](https://pypi.python.org/pypi/pymitter) [![License](https://img.shields.io/github/license/riga/pymitter.svg)](https://github.com/riga/pymitter/blob/master/LICENSE)
  [![Lint and test](https://github.com/riga/pymitter/actions/workflows/lint_and_test.yml/badge.svg)](https://github.com/riga/pymitter/actions/workflows/lint_and_test.yml)

  Python port of the extended Node.js EventEmitter 2 approach of https://github.com/asyncly/EventEmitter2 providing namespaces, wildcards and TTL.




  - Namespaces with wildcards
  - Times to listen (TTL)
  - Usage via decorators or callbacks
  - Coroutine support
  - Lightweight implementation, good performance




  *pymitter* is a registered [PyPI module](https://pypi.python.org/pypi/pymitter), so the installation with *pip* is quite easy:

  ```shell
  pip install pymitter
  ```

  The last version with Python 2 support was v0.3.2 ([tag](https://github.com/riga/pymitter/tree/v0.3.2), [PypI](https://pypi.org/project/pymitter/0.3.2)).






  ```python
  from pymitter import EventEmitter


  ee = EventEmitter()



  @ee.on("my_event")
  def handler1(arg):
      print("handler1 called with", arg)



  def handler2(arg):
      print("handler2 called with", arg)


  ee.on("my_other_event", handler2)



  @ee.on("my_third_event")
  async def handler3(arg):
      print("handler3 called with", arg)



  ee.emit("my_event", "foo")


  ee.emit("my_other_event", "bar")


  ee.emit("my_third_event", "baz")

  ```




  Wrapping `async` functions outside an event loop will start an internal event loop and calls to `emit` return synchronously.

  ```python
  from pymitter import EventEmitter


  ee = EventEmitter()



  @ee.on("my_event")
  async def handler1(arg):
      print("handler1 called with", arg)



  ee.emit("my_event", "foo")

  ```

  Wrapping `async` functions inside an event loop a will use the running event loop and `emit_async` is awaitable.

  ```python
  from pymitter import EventEmitter


  ee = EventEmitter()


  async def main():
      
      awaitable = ee.emit_async("my_event", "foo")
      

      await awaitable
      
  ```




  ```python
  from pymitter import EventEmitter


  ee = EventEmitter()


  @ee.once("my_event")
  def handler1():
      print("handler1 called")


  @ee.on("my_event", ttl=2)
  def handler2():
      print("handler2 called")


  ee.emit("my_event")



  ee.emit("my_event")


  ee.emit("my_event")

  ```




  ```python
  from pymitter import EventEmitter


  ee = EventEmitter(wildcard=True)


  @ee.on("my_event.foo")
  def handler1():
      print("handler1 called")


  @ee.on("my_event.bar")
  def handler2():
      print("handler2 called")


  @ee.on("my_event.*")
  def hander3():
      print("handler3 called")


  ee.emit("my_event.foo")



  ee.emit("my_event.bar")



  ee.emit("my_event.*")



  ```






  EventEmitter constructor. **Note**: always use *kwargs* for configuration.
  When *wildcard* is *True*, wildcards are used as shown in [this example](#wildcards).
  *delimiter* is used to seperate namespaces within events.
  If *new_listener* is *True*, the *"new_listener"* event is emitted every time a new listener is registered.
  Functions listening to this event are passed ``(func, event=None)``.
  *max_listeners* defines the maximum number of listeners per event.
  Negative values mean infinity.

  - #### ``on(event, func=None, ttl=-1)``
      Registers a function to an event.
      When *func* is *None*, decorator usage is assumed.
      *ttl* defines the times to listen. Negative values mean infinity.
      Returns the function.

  - #### ``once(event, func=None)``
      Registers a function to an event with ``ttl = 1``.
      When *func* is *None*, decorator usage is assumed.
      Returns the function.

  - #### ``on_any(func=None)``
      Registers a function that is called every time an event is emitted.
      When *func* is *None*, decorator usage is assumed.
      Returns the function.

  - #### ``off(event, func=None)``
      Removes a function that is registered to an event.
      When *func* is *None*, decorator usage is assumed.
      Returns the function.

  - #### ``off_any(func=None)``
      Removes a function that was registered via ``on_any()``.
      When *func* is *None*, decorator usage is assumed.
      Returns the function.

  - #### ``off_all()``
      Removes all functions of all events.

  - #### ``listeners(event)``
      Returns all functions that are registered to an event.
      Wildcards are not applied.

  - #### ``listeners_any()``
      Returns all functions that were registered using ``on_any()``.

  - #### ``listeners_all()``
      Returns all registered functions.

  - #### ``emit(event, *args, **kwargs)``
      Emits an event.
      All functions of events that match *event* are invoked with *args* and *kwargs* in the exact order of their registeration.
      Wildcards might be applied.
      There is no return value.




  - Source hosted at [GitHub](https://github.com/riga/pymitter)
  - Python module hostet at [PyPI](https://pypi.python.org/pypi/pymitter)
  - Report issues, questions, feature requests on [GitHub Issues](https://github.com/riga/pymitter/issues)


pkgId: 9df8a29932f3aaddb0bf3c1dbead0505537e20f9d1997ba73dc8f1557d85c6a5
name: python-pymongo-debuginfo
arch: aarch64
version: 4.3.3
epoch: 0
release: 1
summary: Debug information for package python-pymongo
url: http://github.com/mongodb/mongo-python-driver
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-39d4881f-7e78-4262-b49a-98f938094a66
rpm_sourcerpm: python-pymongo-4.3.3-1.src.rpm
location_href: 00009039-python-pymongo/python-pymongo-debuginfo-4.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pymongo.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: c00e9bcdebc3c4270c0f8eb1663b226e797451b1e2cfb8c80148acda4023f179
name: python-pymongo-debugsource
arch: aarch64
version: 4.3.3
epoch: 0
release: 1
summary: Debug sources for package python-pymongo
url: http://github.com/mongodb/mongo-python-driver
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-39d4881f-7e78-4262-b49a-98f938094a66
rpm_sourcerpm: python-pymongo-4.3.3-1.src.rpm
location_href: 00009039-python-pymongo/python-pymongo-debugsource-4.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pymongo.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: f7f12abc92b795e8d6176838891b6efdb9916d0bfd32d82196ff3f144341f72c
name: python-pymorphy2
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Morphological analyzer (POS tagger + inflection engine) for Russian language.
url: https://github.com/kmike/pymorphy2/
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5b015ac-292d-4e6c-9244-69524487929e
location_href: 00011539-python-pymorphy2/python-pymorphy2-0.9.1-1.src.rpm
checksum_type: sha256
description:
  Morphological analyzer (POS tagger + inflection engine)
  for Russian and Ukrainian languages. License is MIT.
  * docs: https://pymorphy2.readthedocs.io
  * changelog: https://github.com/kmike/pymorphy2/blob/master/CHANGES.rst
  * source code: github_
  * bug tracker: https://github.com/kmike/pymorphy2/issues
  * support: https://groups.google.com/forum/?fromgroups#!forum/pymorphy


pkgId: 9ab1af3f1d4582b4b00c09f14f529a4acb4e3db335346750dc5024ebf340c564
name: python-pymssql
arch: src
version: 2.2.7
epoch: 0
release: 1
summary: DB-API interface to Microsoft SQL Server for Python. (new Cython-based version)
url: https://pypi.org/project/pymssql/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-78fb9b4d-3bd5-4617-ad90-f30a4d964c5d
location_href: 00004743-python-pymssql/python-pymssql-2.2.7-1.src.rpm
checksum_type: sha256
description:
  A simple database interface for `Python`_ that builds on top of `FreeTDS`_ to
  provide a Python DB-API (`PEP-249`_) interface to `Microsoft SQL Server`_.
  Detailed information on pymssql is available on the website:
  `pymssql.readthedocs.io <https://pymssql.readthedocs.io/en/stable/>`_
  New development is happening on GitHub at:
  `github.com/pymssql/pymssql <https://github.com/pymssql/pymssql>`_
  There is a Google Group for discussion at:
  `groups.google.com <https://groups.google.com/forum/?fromgroups#!forum/pymssql>`_


pkgId: 801b5046eb00677b4085e24ef14ea23316de23b619cf3ad10a979b5a245d27be
name: python-pymsteams
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Format messages and post to Microsoft Teams.
url: https://github.com/rveachkc/pymsteams
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-71c55690-aa54-4364-a00a-bc5d98f01767
location_href: 00009667-python-pymsteams/python-pymsteams-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/rveachkc/pymsteams/tree/master.svg?style=shield)](https://circleci.com/gh/rveachkc/pymsteams/tree/master) [![PyPI version](https://badge.fury.io/py/pymsteams.svg)](https://badge.fury.io/py/pymsteams)

  Python Wrapper Library to send requests to Microsoft Teams Webhooks.
  Microsoft refers to these messages as Connector Cards.  A message can be sent with only the main Connector Card, or additional sections can be included into the message.

  This library uses Webhook Connectors for Microsoft Teams.  Please visit the following Microsoft Documentation link for instructions on how to obtain the correct url for your Channel: https://dev.outlook.com/Connectors/GetStarted#creating-messages-through-office-365-connectors-in-microsoft-teams

  Please refer to the Microsoft Documentation for the most up to date screenshots.
  https://dev.outlook.com/connectors/reference



  Install with pip:

  ```bash
  pip install pymsteams
  ```

  Install with async capabilities (python 3.6+):

  ```bash
  pip install pymsteams[async]
  ```



  At time of writing, the latest release supported by Python 2 is [Version 0.1.16](https://github.com/rveachkc/pymsteams/releases/tag/0.1.16)





  This is the simplest implementation of pymsteams.  It will send a message to the teams webhook url with plain text in the message.

  ```python
  import pymsteams


  myTeamsMessage = pymsteams.connectorcard("<Microsoft Webhook URL>")


  myTeamsMessage.text("this is my text")


  myTeamsMessage.send()
  ```



  ```python
  import asyncio
  import pymsteams

  loop = asyncio.get_event_loop()


  myTeamsMessage = pymsteams.async_connectorcard("<Microsoft Webhook URL>")


  myTeamsMessage.text("This is my message")


  loop.run_until_complete(myTeamsMessage.send())
  ```

  Please visit the python asyncio documentation for more info on using asyncio and the event loop: https://docs.python.org/3/library/asyncio-eventloop.html





  ```python
  myTeamsMessage.title("This is my message title")
  ```


  ```python
  myTeamsMessage.addLinkButton("This is the button Text", "https://github.com/rveachkc/pymsteams/")
  ```


  This is useful in the event you need to post the same message to multiple rooms.
  ```python
  myTeamsMessage.newhookurl("<My New URL>")
  ```


  This sets the theme color of the card. The parameter is expected to be a hex color code without the hash or the string red.
  ```python
  myTeamsMessage.color("<Hex Color Code>")
  ```


  This is a simple print command to view your connector card message object before sending.
  ```python
  myTeamsMessage.printme()
  ```


  To create a section and add various formatting elements
  ```python

  myMessageSection = pymsteams.cardsection()


  myMessageSection.title("Section title")


  myMessageSection.activityTitle("my activity title")
  myMessageSection.activitySubtitle("my activity subtitle")
  myMessageSection.activityImage("http://i.imgur.com/c4jt321l.png")
  myMessageSection.activityText("This is my activity Text")


  myMessageSection.addFact("this", "is fine")
  myMessageSection.addFact("this is", "also fine")


  myMessageSection.text("This is my section text")


  myMessageSection.addImage("http://i.imgur.com/c4jt321l.png", ititle="This Is Fine")


  myTeamsMessage.addSection(myMessageSection)
  ```
  You may also add multiple sections to a connector card message as well.
  ```python

  Section1 = pymsteams.cardsection()
  Section1.text("My First Section")


  Section2 = pymsteams.cardsection()
  Section2.text("My Second Section")


  myTeamsMessage.addSection(Section1)
  myTeamsMessage.addSection(Section2)


  myTeamsMessage.send()
  ```

  To create a actions on which the user can interect with in MS Teams
  To find out more information on what actions can be used, please visit https://docs.microsoft.com/en-us/microsoftteams/platform/concepts/connectors/connectors-using#setting-up-a-custom-incoming-webhook

  ```python
  myTeamsMessage = pymsteams.connectorcard("<Microsoft Webhook URL>")

  myTeamsPotentialAction1 = pymsteams.potentialaction(_name = "Add a comment")
  myTeamsPotentialAction1.addInput("TextInput","comment","Add a comment here",False)
  myTeamsPotentialAction1.addAction("HttpPost","Add Comment","https://..."")

  myTeamsPotentialAction2 = pymsteams.potentialaction(_name = "Set due date")
  myTeamsPotentialAction2.addInput("DateInput","dueDate","Enter due date")
  myTeamsPotentialAction2.addAction("HttpPost","save","https://...")

  myTeamsPotentialAction3 = pymsteams.potentialaction(_name = "Change Status")
  myTeamsPotentialAction3.choices.addChoices("In progress","0")
  myTeamsPotentialAction3.choices.addChoices("Active","1")
  myTeamsPotentialAction3.addInput("MultichoiceInput","list","Select a status",False)
  myTeamsPotentialAction3.addAction("HttpPost","Save","https://...")

  myTeamsMessage.addPotentialAction(myTeamsPotentialAction1)
  myTeamsMessage.addPotentialAction(myTeamsPotentialAction2)
  myTeamsMessage.addPotentialAction(myTeamsPotentialAction3)

  myTeamsMessage.summary("Test Message")

  myTeamsMessage.send()
  ```


  ```python
  myTeamsMessage = pymsteams.connectorcard("<Microsoft Webhook URL>")

  myTeamsPotentialAction1 = pymsteams.potentialaction(_name = "Add a comment")

  myTeamsPotentialAction1.addInput("TextInput","comment","Add a comment here",False)

  myTeamsPotentialAction1.addAction("HttpPost","Add Comment","https://...", "{{comment.value}}")
  myTeamsMessage.addPotentialAction(myTeamsPotentialAction1)


  myTeamsMessage.summary("Test Message")

  myTeamsMessage.send()






  ```

  Please use Github issues to report any bugs or request enhancements.



  This module is really just a nice wrapper pointed at the Microsoft API. To help troubleshoot missing messages, the requests response content is saved to the connectorcard class attribute `last_http_response`.

  To get the last http status code:
  ```python
  import pymsteams

  myTeamsMessage = pymsteams.connectorcard("<Microsoft Webhook URL>")
  myTeamsMessage.text("this is my text")
  myTeamsMessage.send()

  last_status_code = myTeamsMessage.last_http_response.status_code
  ```

  More info on the Response Content is available in the requests documentation, [link](https://2.python-requests.org/en/master/user/quickstart/#response-content).



  If the call to the Microsoft Teams webhook service fails, a `TeamsWebhookException` will be thrown.



  In order to test in your environment with pytest, set the environment variable `MS_TEAMS_WEBHOOK` to the Microsoft Teams Webhook url you would like to use.

  Then, from the root of the repo, install the requirements and run pytest.

  ```bash
  pip install -r dev-requirements.txt
  MS_TEAMS_WEBHOOK=MicrosoftWebhookURL
  export MS_TEAMS_WEBHOOK
  pytest --cov=./pymsteams --cov-report=term-missing --cov-branch
  ```

  This will send two MS Teams messages describing how they are formatted.  Manually validate that the message comes through as expected.



  In some situations, a custom CA bundle must be used.  This can be set on class initialization, by setting the verify parameter.

  ```python
  import pymsteams


  msg = pymsteams.connectorcard("<Microsoft Webhook URL>", verify="/path/to/file")


  msg = pymsteams.connectorcard("<Microsoft Webhook URL>", verify=False)
  ```

  Set to either the path of a custom CA bundle or False to disable.

  The requests documentation can be referenced for full details: https://2.python-requests.org/en/master/user/advanced/#ssl-cert-verification


pkgId: 8e623699d234bf421bf9b7b78034eb58c2372dd5741b7bbf6f6e3b9b5844107e
name: python-pymunk
arch: src
version: 6.4.0
epoch: 0
release: 1
summary: Pymunk is a easy-to-use pythonic 2d physics library
url: http://www.pymunk.org
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-551d75d3-c033-4f83-a0c4-aff1d7607a59
location_href: 00011776-python-pymunk/python-pymunk-6.4.0-1.src.rpm
checksum_type: sha256
description:
  Pymunk is a easy-to-use pythonic 2d physics library that can be used whenever
  you need 2d rigid body physics from Python. Perfect when you need 2d physics
  in your game, demo or simulation! It is built on top of the very
  capable 2d physics library `Chipmunk <http://chipmunk-physics.net>`_.
  The first version was released in 2007 and Pymunk is still actively developed
  and maintained today, more than 10 years of active development!
  Pymunk has been used with success in many projects, big and small. For example:
  3 Pyweek game competition winners, more than a dozen published scientific
  papers and even in a self-driving car simulation! See the Showcases section on
  the Pymunk webpage for some examples.
  2007 - 2022, Victor Blomqvist - vb@viblo.se, MIT License
  This release is based on the latest Pymunk release (6.4.0),
  using Chipmunk 7 rev 0593976ef47fcb3957166bd342f6b2bafe4d0e44 .


pkgId: 170a35f13a07a22441164d9baf9f87bdb8b0ee40f8b03acdd65a6ebe0a06a2a2
name: python-pymunk-debuginfo
arch: aarch64
version: 6.4.0
epoch: 0
release: 1
summary: Debug information for package python-pymunk
url: http://www.pymunk.org
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-551d75d3-c033-4f83-a0c4-aff1d7607a59
rpm_sourcerpm: python-pymunk-6.4.0-1.src.rpm
location_href: 00011776-python-pymunk/python-pymunk-debuginfo-6.4.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pymunk.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e4a19ee1ab076df914fa86945a7479ee04a6c335e5727753591b647a69bcf391
name: python-pymunk-debugsource
arch: aarch64
version: 6.4.0
epoch: 0
release: 1
summary: Debug sources for package python-pymunk
url: http://www.pymunk.org
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-551d75d3-c033-4f83-a0c4-aff1d7607a59
rpm_sourcerpm: python-pymunk-6.4.0-1.src.rpm
location_href: 00011776-python-pymunk/python-pymunk-debugsource-6.4.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pymunk.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: ec7fb0841264b98b0233b401ce54dd0d2c79e52a93105c3819db516f82d0dd14
name: python-pynetdicom
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: A Python implementation of the DICOM networking protocol
url: https://github.com/pydicom/pynetdicom
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-020c319c-583f-4c64-9770-907851cf68aa
location_href: 00004745-python-pynetdicom/python-pynetdicom-2.0.2-1.src.rpm
checksum_type: sha256
description:
  A Python implementation of the `DICOM <http://dicom.nema.org>`_
  networking protocol, originally based on (legacy)
  `pynetdicom <https://github.com/patmun/pynetdicom_legacy>`_.


pkgId: 15ce16b04d21d480d0868ef25f9b4640ba5c3b0fdb3fd42f42c9436d2721083e
name: python-pynuvo
arch: src
version: 0.2
epoch: 0
release: 1
summary: Python API for talking to Nuvo multi zone amplifier
url: https://github.com/ejonesnospam/pynuvo
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b6606d77-a010-42a0-b9b9-5d48a00ef383
location_href: 00004748-python-pynuvo/python-pynuvo-0.2-1.src.rpm
checksum_type: sha256
description:
  Python3 interface implementation for Nuvo zone amplifier
   Initially developed/tested with older Concerto model
  *** Should/could also work with any Nuvo amp, via RS-232 serial, such NV-E6D


  This is for use with [Home-Assistant](http://home-assistant.io)


  ```python

  ```


pkgId: 50ae4f00698cd1094365b011484189a1c169bfac9fb92a296d0e5f26c7d55d93
name: python-pynvml
arch: src
version: 11.5.0
epoch: 0
release: 1
summary: Python Bindings for the NVIDIA Management Library
url: http://www.nvidia.com/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b8708c41-6d9f-413f-94ea-c536fc191571
location_href: 00011373-python-pynvml/python-pynvml-11.5.0-1.src.rpm
checksum_type: sha256
description:
  Provides a Python interface to GPU management and monitoring functions.
  This is a wrapper around the NVML library.
  For information about the NVML library, see the NVML developer page
  http://developer.nvidia.com/nvidia-management-library-nvml
  As of version 11.0.0, the NVML-wrappers used in pynvml are identical
  to those published through [nvidia-ml-py](https://pypi.org/project/nvidia-ml-py/).
  Note that this file can be run with 'python -m doctest -v README.txt'
  although the results are system dependent


pkgId: a8fa1c19853abd0a2101ab5a97ad18a183dc0e57317f570345ef9091620254d6
name: python-pyobd
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: PyOBD - Open BYMA Data API
url: https://github.com/franco-lamas/PyOBD
rpm_license: GPL V3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5ebb58bf-d45b-464c-8a06-b86831155a45
location_href: 00004750-python-pyobd/python-pyobd-0.1.7-1.src.rpm
checksum_type: sha256
description:
  PyOBD es una API para conectar cualquier script de Python con datos del mercado con 20 minutos de retraso provistos por Open BYMA Data, además permite la descarga de datos histórico. Fue desarrollada en conjunto por [Nacho Herrera](https://github.com/nacho-herrera), [St1tch](https://twitter.com/St1tch_BL) y [Franco Lamas](https://www.linkedin.com/in/franco-lamas/).



      from PyOBD import *
      PyOBD=openBYMAdata()



  Por el momento solo se encuentra disponible el plazo de 48hs que viene cargado por defecto



      PyOBD.get_bonds()



      PyOBD.get_short_term_bonds()


      PyOBD.get_corporateBonds()



      PyOBD.get_bluechips()



      PyOBD.get_galpones()



      PyOBD.get_cedears()



      PyOBD.indices()



      PyOBD.get_options()




      PyOBD.byma_news()



      PyOBD.isworkingDay()



      PyOBD.marketResume()



  La instalación vía pip aún no está disponible, únicamente desde el repositorio. Se requiere instalar [Git](https://git-scm.com/).

      pip install git+https://github.com/franco-lamas/PyOBD --upgrade --no-cache-dir



  *   Luego de las 2am se reinicia el servidor y cambia la estructura de datos.
  *   Luego de las 17 la sección de noticias se desconecta.




  *   Agregar más plazos
  *   Formatear links de noticias
  *   Dashboard de bonos IAMC
  *   Datos de empresas
  *   Históricos
  *   Balances históricos




  La información es mostrada “tal cual es”, puede ser incorrecta o contener errores, eso es responsabilidad de cada sitio. No somos responsables por el uso indebido de los Scripts.


pkgId: a020029e4fad4cbbc3f38ff4cf1b04af7a40d764c3e7dfdb58d14d951988a0e5
name: python-pyodbc
arch: src
version: 4.0.35
epoch: 0
release: 1
summary: DB API Module for ODBC
url: https://github.com/mkleehammer/pyodbc
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-715c87d1-92bf-4b33-9379-190a9bb9fd32
location_href: 00004752-python-pyodbc/python-pyodbc-4.0.35-1.src.rpm
checksum_type: sha256
description:
  [![Windows Status](https://ci.appveyor.com/api/projects/status/github/mkleehammer/pyodbc?branch=master&svg=true&passingText=Windows%20build)](https://ci.appveyor.com/project/mkleehammer/pyodbc)
  [![Ubuntu build](https://github.com/mkleehammer/pyodbc/actions/workflows/ubuntu_build.yml/badge.svg)](https://github.com/mkleehammer/pyodbc/actions/workflows/ubuntu_build.yml)
  [![PyPI](https://img.shields.io/pypi/v/pyodbc?color=brightgreen)](https://pypi.org/project/pyodbc/)

  pyodbc is an open source Python module that makes accessing ODBC databases simple.  It
  implements the [DB API 2.0](https://www.python.org/dev/peps/pep-0249) specification but is
  packed with even more Pythonic convenience.

  The easiest way to install is to use pip:

      pip install pyodbc

  If you are using Mac, you should be using `Homebrew` for installing pyodbc:

      brew install unixodbc
      pip install pyodbc

  Precompiled binary wheels are provided for most Python versions on Windows and macOS.  On other
  operating systems this will build from source.  Note, pyodbc contains C++ extensions so you will
  need a suitable C++ compiler on your computer to install pyodbc, for all operating systems.  See
  the [docs](https://github.com/mkleehammer/pyodbc/wiki/Install) for details.

  [Documentation](https://github.com/mkleehammer/pyodbc/wiki)

  [Release Notes](https://github.com/mkleehammer/pyodbc/releases)

  IMPORTANT: Python 2.7 support is being ended.  The pyodbc 4.x versions will be the last to
  support Python 2.7.  The pyodbc 5.x versions will only support Python 3.7 and above.


pkgId: e6ba41ca17fa06fffe6cd56c3b60d7edb08b87c6f7ef7f29027f763f70dccfeb
name: python-pyone
arch: src
version: 6.6.1
epoch: 0
release: 1
summary: Python Bindings for OpenNebula XML-RPC API
url: http://opennebula.io
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b221571-2f07-47c0-b879-c43749110c72
location_href: 00004753-python-pyone/python-pyone-6.6.1-1.src.rpm
checksum_type: sha256
description:
  PyOne is an implementation of OpenNebula XML-RPC
  bindings in Python. It works as a proxy over the XML-RPC api and
  utilizes generateDS (https://www.davekuhlman.org/generateDS.html)
  to ecapsulate the xml response to Python objects.


pkgId: 0caa492a1eb8573be698fc91027842560c2b84f603ce4817a45a607609231a3e
name: python-pyopencl
arch: src
version: 2022.3.1
epoch: 0
release: 1
summary: Python wrapper for OpenCL
url: http://mathema.tician.de/software/pyopencl
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-48ade010-c569-48fe-863a-70d53b7c3b62
location_href: 00004754-python-pyopencl/python-pyopencl-2022.3.1-1.src.rpm
checksum_type: sha256
description:
  PyOpenCL lets you access GPUs and other massively parallel compute
  devices from Python. It tries to offer computing goodness in the
  spirit of its sister project `PyCUDA <https://mathema.tician.de/software/pycuda>`__:
  * Object cleanup tied to lifetime of objects. This idiom, often
    called `RAII <https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization>`__
    in C++, makes it much easier to write correct, leak- and
    crash-free code.
  * Completeness. PyOpenCL puts the full power of OpenCL's API at
    your disposal, if you wish.  Every obscure ``get_info()`` query and
    all CL calls are accessible.
  * Automatic Error Checking. All CL errors are automatically
    translated into Python exceptions.
  * Speed. PyOpenCL's base layer is written in C++, so all the niceties
    above are virtually free.
  * Helpful and complete `Documentation <https://documen.tician.de/pyopencl>`__
    as well as a `Wiki <https://wiki.tiker.net/PyOpenCL>`__.
  * Liberal license. PyOpenCL is open-source under the
    `MIT license <https://en.wikipedia.org/wiki/MIT_License>`__
    and free for commercial, academic, and private use.
  * Broad support. PyOpenCL was tested and works with Apple's, AMD's, and Nvidia's
    CL implementations.
  Simple 4-step `install instructions <https://documen.tician.de/pyopencl/misc.html#installation>`__
  using Conda on Linux and macOS (that also install a working OpenCL implementation!)
  can be found in the `documentation <https://documen.tician.de/pyopencl/>`__.
  What you'll need if you do *not* want to use the convenient instructions above and
  instead build from source:
  * gcc/g++ new enough to be compatible with pybind11
    (see their `FAQ <https://pybind11.readthedocs.io/en/stable/faq.html>`__)
  * `numpy <https://numpy.org>`__, and
  * an OpenCL implementation. (See this `howto <https://wiki.tiker.net/OpenCLHowTo>`__
    for how to get one.)


pkgId: c0ea23e876feb4727585f988ee68884df65643210f724b7c9bf1b565fe61072d
name: python-pyopenuv
arch: src
version: 2023.2.0
epoch: 0
release: 1
summary: A simple Python API data from openuv.io
url: https://github.com/bachya/pyopenuv
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-042dcd49-d05d-4c7d-bee7-255588a2f9eb
location_href: 00004757-python-pyopenuv/python-pyopenuv-2023.2.0-1.src.rpm
checksum_type: sha256
description:
  [![CI][ci-badge]][ci]
  [![PyPI][pypi-badge]][pypi]
  [![Version][version-badge]][version]
  [![License][license-badge]][license]
  [![Code Coverage][codecov-badge]][codecov]
  [![Maintainability][maintainability-badge]][maintainability]

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

  `pyopenuv` is a simple Python library for retrieving UV-related information from
  [openuv.io][openuv].

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



  ```bash
  pip install pyopenuv
  ```



  `pyopenuv` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  You can get an API key from [the OpenUV console][openuv-console].



  ```python
  import asyncio

  from pyopenuv import Client
  from pyopenuv.errors import OpenUvError


  async def main():
      client = Client(
          "<OPENUV_API_KEY>", "<LATITUDE>", "<LONGITUDE>", altitude="<ALTITUDE>"
      )

      try:
          
          print(await client.api_status())
          

          
          print(await client.uv_index())
          

          
          print(await client.uv_forecast())
          

          
          print(await client.uv_protection_window())
          

          
          print(await client.api_statistics())
          
      except OpenUvError as err:
          print(f"There was an error: {err}")


  asyncio.run(main())
  ```



  If you would prefer to not call `api_status` manually, you can configure the `Client` object
  to automatically check the status of the OpenUV API before executing any of the API
  methods—simply pass the `check_status_before_request` parameter:

  ```python
  import asyncio

  from pyopenuv import Client
  from pyopenuv.errors import ApiUnavailableError, OpenUvError


  async def main():
      client = Client(
          "<OPENUV_API_KEY>",
          "<LATITUDE>",
          "<LONGITUDE>",
          altitude="<ALTITUDE>",
          check_status_before_request=True,
      )

      try:
          print(await client.uv_index())
      except ApiUnavailableError:
          print("The API is unavailable")
      except OpenUvError as err:
          print(f"There was an error: {err}")


  asyncio.run(main())
  ```



  By default, the library creates a new connection to OpenUV with each coroutine. If you
  are calling a large number of coroutines (or merely want to squeeze out every second of
  runtime savings possible), an [`aiohttp`][aiohttp] `ClientSession` can be used for
  connection pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession
  from pyopenuv import Client
  from pyopenuv.errors import OpenUvError


  async def main():
      async with ClientSession() as session:
          client = Client(
              "<OPENUV_API_KEY>",
              "<LATITUDE>",
              "<LONGITUDE>",
              altitude="<ALTITUDE>",
              session=session,
          )

          try:
              print(await client.uv_index())
          except OpenUvError as err:
              print(f"There was an error: {err}")


  asyncio.run(main())
  ```



  Thanks to all of [our contributors][contributors] so far!

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

  [aiohttp]: https://github.com/aio-libs/aiohttp
  [ci-badge]: https://github.com/bachya/pyopenuv/workflows/CI/badge.svg
  [ci]: https://github.com/bachya/pyopenuv/actions
  [codecov-badge]: https://codecov.io/gh/bachya/pyopenuv/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/pyopenuv
  [contributors]: https://github.com/bachya/pyopenuv/graphs/contributors
  [fork]: https://github.com/bachya/pyopenuv/fork
  [issues]: https://github.com/bachya/pyopenuv/issues
  [license-badge]: https://img.shields.io/pypi/l/pyopenuv.svg
  [license]: https://github.com/bachya/pyopenuv/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/a03c9e96f19a3dc37f98/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/pyopenuv/maintainability
  [new-issue]: https://github.com/bachya/pyopenuv/issues/new
  [new-issue]: https://github.com/bachya/pyopenuv/issues/new
  [openuv]: https://openuv.io/
  [openuv-console]: https://www.openuv.io/console
  [pypi-badge]: https://img.shields.io/pypi/v/pyopenuv.svg
  [pypi]: https://pypi.python.org/pypi/pyopenuv
  [version-badge]: https://img.shields.io/pypi/pyversions/pyopenuv.svg
  [version]: https://pypi.python.org/pypi/pyopenuv


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: 4ec0cf13b3d95eb220469e94899de6f092d8cf207a90d721bb379920c17f95b7
name: python-pypika-tortoise
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Forked from pypika and streamline just for tortoise-orm
url: https://github.com/tortoise/pypika-tortoise
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b8844886-d183-46b8-8b01-3b417d75d51f
location_href: 00013764-python-pypika-tortoise/python-pypika-tortoise-0.1.6-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/pypika-tortoise.svg?style=flat)](https://pypi.python.org/pypi/pypika-tortoise)
  [![image](https://img.shields.io/github/license/tortoise/pypika-tortoise)](https://github.com/tortoise/pypika-tortoise)
  [![image](https://github.com/tortoise/pypika-tortoise/workflows/pypi/badge.svg)](https://github.com/tortoise/pypika-tortoise/actions?query=workflow:pypi)
  [![image](https://github.com/tortoise/pypika-tortoise/workflows/ci/badge.svg)](https://github.com/tortoise/pypika-tortoise/actions?query=workflow:ci)

  Forked from [pypika](https://github.com/kayak/pypika) and streamline just for tortoise-orm.



  The original repo include many databases that tortoise-orm don't need, and which aims to be a perfect sql builder and
  should consider more compatibilities, but tortoise-orm is not, and we need add new features and update it ourselves.



  Delete many codes that tortoise-orm don't need, and add features just tortoise-orm considers to.



  Nothing, because this repo keeps the original struct and code.



  - [pypika](https://github.com/kayak/pypika), a python SQL query builder that exposes the full richness of the SQL
    language using a syntax that reflects the resulting query.



  This project is licensed under the [Apache-2.0](./LICENSE) License.


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: 3d32b33d29015cfad4772adad0596d60342f736e2c8cfc75e54b1da11ea2e265
name: python-pyre-check
arch: src
version: 0.9.18
epoch: 0
release: 1
summary: A performant type checker for Python
url: https://pyre-check.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f159242d-1ab3-423d-943d-bfbaa1b71f20
location_href: 00013697-python-pyre-check/python-pyre-check-0.9.18-1.src.rpm
checksum_type: sha256
description:
  [![lint](https://github.com/facebook/pyre-check/workflows/lint/badge.svg)](https://github.com/facebook/pyre-check/actions/workflows/lint.yml)
  [![tests](https://github.com/facebook/pyre-check/workflows/tests/badge.svg)](https://github.com/facebook/pyre-check/actions/workflows/tests.yml)
  [![pyre](https://github.com/facebook/pyre-check/workflows/pyre/badge.svg)](https://github.com/facebook/pyre-check/actions/workflows/pyre.yml)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Gitter](https://badges.gitter.im/pyre-check/community.svg)](https://gitter.im/pyre-check/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

  <p align="center">
    <img src="https://raw.githubusercontent.com/facebook/pyre-check/main/logo.png">
  </p>

  Pyre is a performant type checker for Python compliant with [PEP 484](https://www.python.org/dev/peps/pep-0484/). Pyre can analyze codebases with millions of lines of code incrementally – providing instantaneous feedback to developers as they write code. You can try it out on examples in [the Pyre Playground](https://pyre-check.org/play).

  Pyre ships with **Pysa**, a security focused static analysis tool we've built on top of Pyre that reasons about data flows in Python applications. Please refer to our [documentation](https://pyre-check.org/docs/pysa-quickstart) to get started with our security analysis.

  Pysa is also available on the [GitHub Marketplace as a Github Action](https://github.com/marketplace/actions/pysa-action)


  To get started, you need [Python 3.6 or later](https://www.python.org/getit/) and [watchman](https://facebook.github.io/watchman/) working on your system. On *MacOS* you can get everything with [homebrew](https://brew.sh/):
  ```bash
  $ brew install python3 watchman
  ```
  On *Ubuntu*, *Mint*, or *Debian*; use `apt-get` and [homebrew](https://brew.sh/):
  ```bash
  $ sudo apt-get install python3 python3-pip python3-venv
  $ brew install watchman
  ```
  We tested Pyre on *Ubuntu 18.04.5 LTS*, *CentOS 7*, as well as *OSX 10.11* and later.


  We start by creating an empty project directory and setting up a virtual environment:

  ```bash
  $ mkdir my_project && cd my_project
  $ python3 -m venv ~/.venvs/venv
  $ source ~/.venvs/venv/bin/activate
  (venv) $ pip install pyre-check
  ```

  Next, we teach Pyre about our new project:
  ```bash
  (venv) $ pyre init
  ```
  This command will set up a configuration for Pyre (`.pyre_configuration`) as well as watchman (`.watchmanconfig`) in your project's directory. Accept the defaults for now – you can change them later if necessary.


  We are now ready to run Pyre:
  ```bash
  (venv) $ echo "i: int = 'string'" > test.py
  (venv) $ pyre
   ƛ Found 1 type error!
  test.py:1:0 Incompatible variable type [9]: i is declared to have type `int` but is used as type `str`.
  ```
  This first invocation will start a daemon listening for filesystem changes – type checking your project incrementally as you make edits to the code. You will notice that subsequent invocations of `pyre` will be faster than the first one.

  For more detailed documentation, see https://pyre-check.org.



  See [CONTRIBUTING.md](CONTRIBUTING.md) for how to help out.



  Pyre is licensed under the MIT license.


pkgId: 6a80eea686b6a77d2fcf8d78924325dbe710dd5d5e9270656656502795763d2d
name: python-pyre-extensions
arch: src
version: 0.0.30
epoch: 0
release: 1
summary: Type system extensions for use with the pyre type checker
url: https://pyre-check.org
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd732a62-eaec-47c3-a1c1-491f9fb3f812
location_href: 00013645-python-pyre-extensions/python-pyre-extensions-0.0.30-1.src.rpm
checksum_type: sha256
description:
  This module defines extensions to the standard “typing” module that are supported by the [Pyre typechecker](https://pypi.org/project/pyre-check/).


  Function to make assumptions about `Optional`s explicit. The function will raise an
  assertion error if passed `None` and return the value otherwise.


  `ParameterSpecification`s are a special kind of type variable that captures callable parameter
  specifications (known as argspecs in the runtime and inspect library) instead of types, allowing
  the typing of decorators which transform the return type of the given callable.
  For example:
  ```
  from typing import TypeVar, Callable, List
  from pyre_extensions import ParameterSpecification
  TParams = ParameterSpecification("TParams")
  TReturn = TypeVar("TReturn")
  def unwrap(f: Callable[TParams, List[TReturn]]) -> Callable[TParams, TReturn]:
      def inner(*args: TParams.args, **kwargs: TParams.kwargs) -> TReturn:
          return f(*args, **kwargs)[0]

      return inner
  @unwrap
  def foo(x: int, y: str, z: bool = False) -> List[int]:
      return [1, 2, 3]
  ```
  decorates foo into a callable that returns int, but still has the same parameters, including their
  names and whether they are required.

  These `ParameterSpecification` variables also have two special properties, `args` and `kwargs`,
  which correspond to the positional and keyword arguments for a specific call to the
  `ParameterSpecification` function.  Because the division of parameters into these two argument
  collections can be different each invocation, these special annotations can only be used in one
  manner: together, in a function definition, as `*args` and `**kwargs` with no other parameters
  listed.


  The `safe_json` module provides a type-safe way to parse JSON. It is meant as a drop-in replacement
  for the builtin `json` module but instead of returning an object of undefined shape (i.e. `Any`)
  allows you to specify the shape of the JSON you're expecting. The parser will validate whether the
  input matches the expected type and raise an exception if it does not.


  For trivial JSON structures you can use builtin types:

  ```python
  >>> from pyre_extensions import safe_json
  >>> from typing import List, Dict
  >>> safe_json.loads("[1, 2, 3]", List[int])
  [1, 2, 3]
  >>> safe_json.loads("[1, 2, 3]", List[str])

  >>> safe_json.loads('{"key": "value"}', Dict[str, str])
  {'key': 'value'}
  >>> safe_json.loads('{"key": "value"}', Dict[str, int])

  ```

  For more complicated, nested structures, typed dictionaries are the way to go:
  ```python
  >>> from typing import TypedDict
  >>> class Movie(TypedDict):
  ...     name: str
  ...     year: int
  ...
  >>> safe_json.loads('{"name": "Blade Runner", "year": 1982 }', Movie)
  {'name': 'Blade Runner', 'year': 1982}
  >>> safe_json.loads('{"name": "Blade Runner", "year": "1982" }', Movie)

  ```

  Validate if data is expected type:
  ```python
  >>> from pyre_extensions import safe_json
  >>> from typing import List, Dict
  >>> data = {"foo": 23}
  >>> safe_json.validate(data, Dict[str, str])

  >>> safe_json.validate(data, Dict[str, int])
  {"foo": 23}
  ```


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: 807db226152c590c4e8130823f95fc4e2aaa053f7fd38cefd739fa06e15ddfb6
name: python-pyswarms
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A Python-based Particle Swarm Optimization (PSO) library.
url: https://github.com/ljvmiranda921/pyswarms
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f06556d-d94a-4da7-bd53-d67b82890e3f
location_href: 00013666-python-pyswarms/python-pyswarms-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/pyswarms.svg)](https://badge.fury.io/py/pyswarms)
  [![Build Status](https://dev.azure.com/ljvmiranda/ljvmiranda/_apis/build/status/ljvmiranda921.pyswarms?branchName=master)](https://dev.azure.com/ljvmiranda/ljvmiranda/_build/latest?definitionId=1&branchName=master)
  [![Documentation Status](https://readthedocs.org/projects/pyswarms/badge/?version=latest)](https://pyswarms.readthedocs.io/en/master/?badge=master)
  [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg )](https://raw.githubusercontent.com/ljvmiranda921/pyswarms/master/LICENSE)
  [![DOI](http://joss.theoj.org/papers/10.21105/joss.00433/status.svg)](https://doi.org/10.21105/joss.00433)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  [![Gitter Chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/pyswarms/Issues)
  PySwarms is an extensible research toolkit for particle swarm optimization
  (PSO) in Python.
  It is intended for swarm intelligence researchers, practitioners, and
  students who prefer a high-level declarative interface for implementing PSO
  in their problems. PySwarms enables basic optimization with PSO and
  interaction with swarm optimizations. Check out more features below!
  * **Free software:** MIT license
  * **Documentation:** https://pyswarms.readthedocs.io.
  * **Python versions:** 3.5 and above

  * High-level module for Particle Swarm Optimization. For a list of all optimizers, check [this link].
  * Built-in objective functions to test optimization algorithms.
  * Plotting environment for cost histories and particle movement.
  * Hyperparameter search tools to optimize swarm behaviour.
  * (For Devs and Researchers): Highly-extensible API for implementing your own techniques.
  [this link]: https://pyswarms.readthedocs.io/en/latest/features.html

  To install PySwarms, run this command in your terminal:
  ```shell
  $ pip install pyswarms
  ```
  This is the preferred method to install PySwarms, as it will always install
  the most recent stable release.
  In case you want to install the bleeding-edge version, clone this repo:
  ```shell
  $ git clone -b development https://github.com/ljvmiranda921/pyswarms.git
  ```
  and then run
  ```shell
  $ cd pyswarms
  $ python setup.py install
  ```

  To run PySwarms in a Vagrant Box, install Vagrant by going to
  https://www.vagrantup.com/downloads.html and downloading the proper packaged from the Hashicorp website.
  Afterward, run the following command in the project directory:
  ```shell
  $ vagrant provision
  $ vagrant up
  $ vagrant ssh
  ```
  Now you're ready to develop your contributions in a premade virtual environment.

  PySwarms provides a high-level implementation of various particle swarm
  optimization algorithms. Thus, it aims to be user-friendly and customizable.
  In addition, supporting modules can be used to help you in your optimization
  problem.

  You can import PySwarms as any other Python module,
  ```python
  import pyswarms as ps
  ```
  Suppose we want to find the minima of `f(x) = x^2` using global best
  PSO, simply import the built-in sphere function,
  `pyswarms.utils.functions.sphere()`, and the necessary optimizer:
  ```python
  import pyswarms as ps
  from pyswarms.utils.functions import single_obj as fx

  options = {'c1': 0.5, 'c2': 0.3, 'w':0.9}

  optimizer = ps.single.GlobalBestPSO(n_particles=10, dimensions=2, options=options)

  best_cost, best_pos = optimizer.optimize(fx.sphere, iters=100)
  ```
  ![Sphere Optimization](https://i.imgur.com/5LtjROf.gif)
  This will run the optimizer for `100` iterations, then returns the best cost
  and best position found by the swarm. In addition, you can also access
  various histories by calling on properties of the class:
  ```python

  optimizer.cost_history

  optimizer.pos_history

  optimizer.velocity_history
  ```
  At the same time, you can also obtain the mean personal best and mean neighbor
  history for local best PSO implementations. Simply call `optimizer.mean_pbest_history`
  and `optimizer.mean_neighbor_history` respectively.

  PySwarms implements a grid search and random search technique to find the
  best parameters for your optimizer. Setting them up is easy. In this example,
  let's try using `pyswarms.utils.search.RandomSearch` to find the optimal
  parameters for `LocalBestPSO` optimizer.
  Here, we input a range, enclosed in tuples, to define the space in which the
  parameters will be found. Thus, `(1,5)` pertains to a range from 1 to 5.
  ```python
  import numpy as np
  import pyswarms as ps
  from pyswarms.utils.search import RandomSearch
  from pyswarms.utils.functions import single_obj as fx

  options = {
      'c1': (1,5),
      'c2': (6,10),
      'w': (2,5),
      'k': (11, 15),
      'p': 1
  }



  g = RandomSearch(ps.single.LocalBestPSO, n_particles=40,
              dimensions=20, options=options, objective_func=fx.sphere,
              iters=10, n_selection_iters=100)
  best_score, best_options = g.search()
  ```
  This then returns the best score found during optimization, and the
  hyperparameter options that enable it.
  ```s
  >>> best_score
  1.41978545901
  >>> best_options['c1']
  1.543556887693
  >>> best_options['c2']
  9.504769054771
  ```

  It is also possible to plot optimizer performance for the sake of formatting.
  The plotters module is built on top of `matplotlib`, making it
  highly-customizable.
  ```python
  import pyswarms as ps
  from pyswarms.utils.functions import single_obj as fx
  from pyswarms.utils.plotters import plot_cost_history, plot_contour, plot_surface
  import matplotlib.pyplot as plt

  options = {'c1':0.5, 'c2':0.3, 'w':0.9}
  optimizer = ps.single.GlobalBestPSO(n_particles=50, dimensions=2, options=options)
  optimizer.optimize(fx.sphere, iters=100)

  plot_cost_history(optimizer.cost_history)
  plt.show()
  ```
  ![CostHistory](https://i.imgur.com/19Iuz4B.png)
  We can also plot the animation...
  ```python
  from pyswarms.utils.plotters.formatters import Mesher, Designer

  m = Mesher(func=fx.sphere,
             limits=[(-1,1), (-1,1)])

  d = Designer(limits=[(-1,1), (-1,1), (-0.1,1)],
               label=['x-axis', 'y-axis', 'z-axis'])
  ```
  In 2D,
  ```python
  plot_contour(pos_history=optimizer.pos_history, mesher=m, designer=d, mark=(0,0))
  ```
  ![Contour](https://i.imgur.com/H3YofJ6.gif)
  Or in 3D!
  ```python
  pos_history_3d = m.compute_history_3d(optimizer.pos_history) # preprocessing
  animation3d = plot_surface(pos_history=pos_history_3d,
                             mesher=m, designer=d,
                             mark=(0,0,0))
  ```
  ![Surface](https://i.imgur.com/kRb61Hx.gif)

  PySwarms is currently maintained by a small yet dedicated team:
  - Lester James V. Miranda ([@ljvmiranda921](https://github.com/ljvmiranda921))
  - Siobhán K. Cronin ([@SioKCronin](https://github.com/SioKCronin))
  - Aaron Moser ([@whzup](https://github.com/whzup))
  - Steven Beardwell ([@stevenbw](https://github.com/stevenbw))
  And we would appreciate it if you can lend a hand with the following:
  * Find bugs and fix them
  * Update documentation in docstrings
  * Implement new optimizers to our collection
  * Make utility functions more robust.
  We would also like to acknowledge [all our
  contributors](http://pyswarms.readthedocs.io/en/latest/authors.html), past and
  present, for making this project successful!
  If you wish to contribute, check out our [contributing guide].
  Moreover, you can also see the list of features that need some help in our
  [Issues] page.
  [contributing guide]: https://pyswarms.readthedocs.io/en/development/contributing.html
  [Issues]: https://github.com/ljvmiranda921/pyswarms/issues
  **Most importantly**, first-time contributors are welcome to join! I try my
  best to help you get started and enable you to make your first Pull Request!
  Let's learn from each other!

  This project was inspired by the [pyswarm] module that performs PSO with
  constrained support. The package was created with [Cookiecutter] and the
  [`audreyr/cookiecutter-pypackage`] project template.
  [pyswarm]: https://github.com/tisimst/pyswarm
  [Cookiecutter]: https://github.com/audreyr/cookiecutter
  [`audreyr/cookiecutter-pypackage`]: https://github.com/audreyr/cookiecutter-pypackage

  Are you using PySwarms in your project or research? Please cite us!
  * Miranda L.J., (2018). PySwarms: a research toolkit for Particle Swarm Optimization in Python. *Journal of Open Source Software*, 3(21), 433, [https://doi.org/10.21105/joss.00433](https://doi.org/10.21105/joss.00433)
  ```bibtex
  @article{pyswarmsJOSS2018,
      author  = {Lester James V. Miranda},
      title   = "{P}y{S}warms, a research-toolkit for {P}article {S}warm {O}ptimization in {P}ython",
      journal = {Journal of Open Source Software},
      year    = {2018},
      volume  = {3},
      issue   = {21},
      doi     = {10.21105/joss.00433},
      url     = {https://doi.org/10.21105/joss.00433}
  }
  ```

  Not on the list? Ping us in the Issue Tracker!
  * Gousios, Georgios. Lecture notes for the TU Delft TI3110TU course Algorithms and Data Structures. Accessed May 22, 2018. http://gousios.org/courses/algo-ds/book/string-distance.html#sop-example-using-pyswarms.
  * Nandy, Abhishek, and Manisha Biswas., "Applying Python to Reinforcement Learning." *Reinforcement Learning*. Apress, Berkeley, CA, 2018. 89-128.
  * Benedetti, Marcello, et al., "A generative modeling approach for benchmarking and training shallow quantum circuits." *arXiv preprint arXiv:1801.07686* (2018).
  * Vrbančič et al., "NiaPy: Python microframework for building nature-inspired algorithms." Journal of Open Source Software, 3(23), 613, https://doi.org/10.21105/joss.00613
  * Häse, Florian, et al. "Phoenics: A Bayesian optimizer for chemistry." *ACS Central Science.* 4.9 (2018): 1134-1145.
  * Szynkiewicz, Pawel. "A Comparative Study of PSO and CMA-ES Algorithms on Black-box Optimization Benchmarks." *Journal of Telecommunications and Information Technology* 4 (2018): 5.
  * Mistry, Miten, et al. "Mixed-Integer Convex Nonlinear Optimization with Gradient-Boosted Trees Embedded." Imperial College London (2018).
  * Vishwakarma, Gaurav. *Machine Learning Model Selection for Predicting Properties of High Refractive Index Polymers* Dissertation. State University of New York at Buffalo, 2018.
  * Uluturk Ismail, et al. "Efficient 3D Placement of Access Points in an Aerial Wireless Network." *2019 16th IEEE Anual Consumer Communications and Networking Conference (CCNC)* IEEE (2019): 1-7.
  * Downey A., Theisen C., et al. "Cam-based passive variable friction device for structural control." *Engineering Structures* Elsevier (2019): 430-439.
  * Thaler S., Paehler L., Adams, N.A. "Sparse identification of truncation errors." *Journal of Computational Physics* Elsevier (2019): vol. 397
  * Lin, Y.H., He, D., Wang, Y. Lee, L.J. "Last-mile Delivery: Optimal Locker locatuion under Multinomial Logit Choice Model" https://arxiv.org/abs/2002.10153
  * Park J., Kim S., Lee, J. "Supplemental Material for Ultimate Light trapping in free-form plasmonic waveguide" KAIST, University of Cambridge, and Cornell University http://www.jlab.or.kr/documents/publications/2019PRApplied_SI.pdf
  * Pasha A., Latha P.H., "Bio-inspired dimensionality reduction for Parkinson's Disease Classification," *Health Information Science and Systems*, Springer (2020).
  * Carmichael Z., Syed, H., et al. "Analysis of Wide and Deep Echo State Networks for Multiscale Spatiotemporal Time-Series Forecasting," *Proceedings of the 7th Annual Neuro-inspired Computational Elements* ACM (2019), nb. 7: 1-10 https://doi.org/10.1145/3320288.3320303
  * Klonowski, J. "Optimizing Message to Virtual Link Assignment in Avionics Full-Duplex Switched Ethernet Networks" Proquest
  * Haidar, A., Jan, ZM. "Evolving One-Dimensional Deep Convolutional Neural Netowrk: A Swarm-based Approach," *IEEE Congress on Evolutionary Computation* (2019) https://doi.org/10.1109/CEC.2019.8790036
  * Shang, Z. "Performance Evaluation of the Control Plane in OpenFlow Networks," Freie Universitat Berlin (2020)
  * Linker, F. "Industrial Benchmark for Fuzzy Particle Swarm Reinforcement Learning," Liezpic University (2020)
  * Vetter, A. Yan, C. et al. "Computational rule-based approach for corner correction of non-Manhattan geometries in mask aligner photolithography," Optics (2019). vol. 27, issue 22: 32523-32535 https://doi.org/10.1364/OE.27.032523
  * Wang, Q., Megherbi, N., Breckon T.P., "A Reference Architecture for Plausible Thread Image Projection (TIP) Within 3D X-ray Computed Tomography Volumes" https://arxiv.org/abs/2001.05459
  * Menke, Tim, Hase, Florian, et al. "Automated discovery of superconducting circuits and its application to 4-local coupler design," arxiv preprint: https://arxiv.org/abs/1912.03322

  Like it? Love it? Leave us a star on [Github] to show your appreciation!
  [Github]: https://github.com/ljvmiranda921/pyswarms

  Thanks goes to these wonderful people ([emoji key](https://github.com/all-contributors/all-contributors#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/whzup"><img src="https://avatars3.githubusercontent.com/u/39431903?v=4" width="100px;" alt=""/><br /><sub><b>Aaron</b></sub></a><br /><a href="#maintenance-whzup" title="Maintenance">🚧</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=whzup" title="Code">💻</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=whzup" title="Documentation">📖</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=whzup" title="Tests">⚠️</a> <a href="#ideas-whzup" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/ljvmiranda921/pyswarms/pulls?q=is%3Apr+reviewed-by%3Awhzup" title="Reviewed Pull Requests">👀</a></td>
      <td align="center"><a href="https://github.com/Carl-K"><img src="https://avatars2.githubusercontent.com/u/13661469?v=4" width="100px;" alt=""/><br /><sub><b>Carl-K</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=Carl-K" title="Code">💻</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=Carl-K" title="Tests">⚠️</a></td>
      <td align="center"><a href="http://www.siobhankcronin.com/"><img src="https://avatars2.githubusercontent.com/u/19956669?v=4" width="100px;" alt=""/><br /><sub><b>Siobhán K Cronin</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=SioKCronin" title="Code">💻</a> <a href="#maintenance-SioKCronin" title="Maintenance">🚧</a> <a href="#ideas-SioKCronin" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="http://andrewjarcho.com"><img src="https://avatars3.githubusercontent.com/u/1452951?v=4" width="100px;" alt=""/><br /><sub><b>Andrew Jarcho</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=jazcap53" title="Tests">⚠️</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=jazcap53" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/mamadyonline"><img src="https://avatars1.githubusercontent.com/u/20543370?v=4" width="100px;" alt=""/><br /><sub><b>Mamady</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=mamadyonline" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/jayspeidell"><img src="https://avatars3.githubusercontent.com/u/26357788?v=4" width="100px;" alt=""/><br /><sub><b>Jay Speidell</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=jayspeidell" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/slek120"><img src="https://avatars2.githubusercontent.com/u/3589574?v=4" width="100px;" alt=""/><br /><sub><b>Eric</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/issues?q=author%3Aslek120" title="Bug reports">🐛</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=slek120" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/CPapadim"><img src="https://avatars1.githubusercontent.com/u/13984473?v=4" width="100px;" alt=""/><br /><sub><b>CPapadim</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/issues?q=author%3ACPapadim" title="Bug reports">🐛</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=CPapadim" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/dfhljf"><img src="https://avatars1.githubusercontent.com/u/7887642?v=4" width="100px;" alt=""/><br /><sub><b>JiangHui</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=dfhljf" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/nik1082"><img src="https://avatars3.githubusercontent.com/u/17260188?v=4" width="100px;" alt=""/><br /><sub><b>Jericho Arcelao</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=nik1082" title="Code">💻</a></td>
      <td align="center"><a href="http://www.jdbohrman.xyz"><img src="https://avatars2.githubusercontent.com/u/27848025?v=4" width="100px;" alt=""/><br /><sub><b>James D. Bohrman</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=jdbohrman" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/bradahoward"><img src="https://avatars2.githubusercontent.com/u/24660861?v=4" width="100px;" alt=""/><br /><sub><b>bradahoward</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=bradahoward" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/ThomasCES"><img src="https://avatars2.githubusercontent.com/u/18325841?v=4" width="100px;" alt=""/><br /><sub><b>ThomasCES</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=ThomasCES" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/danielcorreia96"><img src="https://avatars0.githubusercontent.com/u/17486065?v=4" width="100px;" alt=""/><br /><sub><b>Daniel Correia</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/issues?q=author%3Adanielcorreia96" title="Bug reports">🐛</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=danielcorreia96" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/fluencer"><img src="https://avatars3.githubusercontent.com/u/6614307?v=4" width="100px;" alt=""/><br /><sub><b>fluencer</b></sub></a><br /><a href="#example-fluencer" title="Examples">💡</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=fluencer" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/miguelcocruz"><img src="https://avatars0.githubusercontent.com/u/45034603?v=4" width="100px;" alt=""/><br /><sub><b>miguelcocruz</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=miguelcocruz" title="Documentation">📖</a> <a href="#example-miguelcocruz" title="Examples">💡</a></td>
      <td align="center"><a href="https://github.com/stevenbw"><img src="https://avatars1.githubusercontent.com/u/46458390?v=4" width="100px;" alt=""/><br /><sub><b>Steven Beardwell</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=stevenbw" title="Code">💻</a> <a href="#maintenance-stevenbw" title="Maintenance">🚧</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=stevenbw" title="Documentation">📖</a> <a href="#ideas-stevenbw" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://github.com/ndngo"><img src="https://avatars1.githubusercontent.com/u/16291290?v=4" width="100px;" alt=""/><br /><sub><b>Nathaniel Ngo</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=ndngo" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/Aneal-Sharma"><img src="https://avatars1.githubusercontent.com/u/19873846?v=4" width="100px;" alt=""/><br /><sub><b>Aneal Sharma</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=Aneal-Sharma" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/citomcclure"><img src="https://avatars2.githubusercontent.com/u/38021988?v=4" width="100px;" alt=""/><br /><sub><b>Chris McClure</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=citomcclure" title="Documentation">📖</a> <a href="#example-citomcclure" title="Examples">💡</a></td>
      <td align="center"><a href="http://se4.space/"><img src="https://avatars2.githubusercontent.com/u/42605993?v=4" width="100px;" alt=""/><br /><sub><b>Christopher Angell</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=ctangell" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/Kutim"><img src="https://avatars3.githubusercontent.com/u/8309533?v=4" width="100px;" alt=""/><br /><sub><b>Kutim</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/issues?q=author%3AKutim" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/ichbinjakes"><img src="https://avatars1.githubusercontent.com/u/20906800?v=4" width="100px;" alt=""/><br /><sub><b>Jake Souter</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/issues?q=author%3Aichbinjakes" title="Bug reports">🐛</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=ichbinjakes" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/IanBoyanZhang"><img src="https://avatars3.githubusercontent.com/u/4110995?v=4" width="100px;" alt=""/><br /><sub><b>Ian Zhang</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=IanBoyanZhang" title="Documentation">📖</a> <a href="#example-IanBoyanZhang" title="Examples">💡</a></td>
      <td align="center"><a href="https://www.zachariahcarmichael.com/"><img src="https://avatars2.githubusercontent.com/u/20629897?v=4" width="100px;" alt=""/><br /><sub><b>Zach</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=craymichael" title="Documentation">📖</a></td>
      <td align="center"><a href="https://www.linkedin.com/in/michel-lavoie-71841526/"><img src="https://avatars3.githubusercontent.com/u/3951483?v=4" width="100px;" alt=""/><br /><sub><b>Michel Lavoie</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/issues?q=author%3Amiek770" title="Bug reports">🐛</a></td>
      <td align="center"><a href="http://linkedin.com/in/ewelinakaminska/"><img src="https://avatars1.githubusercontent.com/u/42674710?v=4" width="100px;" alt=""/><br /><sub><b>ewekam</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=ewekam" title="Documentation">📖</a></td>
      <td align="center"><a href="https://www.linkedin.com/in/ivyna-alves"><img src="https://avatars2.githubusercontent.com/u/18709508?v=4" width="100px;" alt=""/><br /><sub><b>Ivyna Santino</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=ivynasantino" title="Documentation">📖</a> <a href="#example-ivynasantino" title="Examples">💡</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/yasirroni"><img src="https://avatars2.githubusercontent.com/u/48709672?v=4" width="100px;" alt=""/><br /><sub><b>Muhammad Yasirroni</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=yasirroni" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/ckastner"><img src="https://avatars0.githubusercontent.com/u/15859947?v=4" width="100px;" alt=""/><br /><sub><b>Christian Kastner</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=ckastner" title="Documentation">📖</a> <a href="#platform-ckastner" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://github.com/nishnash54"><img src="https://avatars1.githubusercontent.com/u/25393122?v=4" width="100px;" alt=""/><br /><sub><b>Nishant Rodrigues</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=nishnash54" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/msat59"><img src="https://avatars2.githubusercontent.com/u/20813541?v=4" width="100px;" alt=""/><br /><sub><b>msat59</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=msat59" title="Code">💻</a> <a href="https://github.com/ljvmiranda921/pyswarms/issues?q=author%3Amsat59" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/diegoroman17"><img src="https://avatars0.githubusercontent.com/u/1294358?v=4" width="100px;" alt=""/><br /><sub><b>Diego</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=diegoroman17" title="Documentation">📖</a></td>
      <td align="center"><a href="http://www.aquanova-mp.com/"><img src="https://avatars2.githubusercontent.com/u/6449766?v=4" width="100px;" alt=""/><br /><sub><b>Shaad Alaka</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=Archer6621" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/blazewicz"><img src="https://avatars1.githubusercontent.com/u/13185945?v=4" width="100px;" alt=""/><br /><sub><b>Krzysztof Błażewicz</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/issues?q=author%3Ablazewicz" title="Bug reports">🐛</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/a310883"><img src="https://avatars2.githubusercontent.com/u/48936633?v=4" width="100px;" alt=""/><br /><sub><b>Jorge Castillo</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=a310883" title="Documentation">📖</a></td>
      <td align="center"><a href="https://danner-web.de/"><img src="https://avatars3.githubusercontent.com/u/11915163?v=4" width="100px;" alt=""/><br /><sub><b>Philipp Danner</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=dannerph" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/nikhil-sethi"><img src="https://avatars2.githubusercontent.com/u/50928699?v=4" width="100px;" alt=""/><br /><sub><b>Nikhil Sethi</b></sub></a><br /><a href="https://github.com/ljvmiranda921/pyswarms/commits?author=nikhil-sethi" title="Code">💻</a> <a href="https://github.com/ljvmiranda921/pyswarms/commits?author=nikhil-sethi" title="Documentation">📖</a></td>
    </tr>
  </table>
  <!-- markdownlint-enable -->
  <!-- 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: 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: bae9f7a8e109bd81cea1a705e4d1759f91de6df49dd3a81033f938101bb3d9a3
name: python-pyte
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Simple VTXXX-compatible terminal emulator.
url: https://github.com/selectel/pyte
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0c6987a3-2cc6-48e0-98f8-095012edf79d
location_href: 00013709-python-pyte/python-pyte-0.8.1-1.src.rpm
checksum_type: sha256
description:
  It's an in memory VTXXX-compatible terminal emulator.
  *XXX* stands for a series of video terminals, developed by
  `DEC <http://en.wikipedia.org/wiki/Digital_Equipment_Corporation>`_ between
  1970 and 1995. The first, and probably the most famous one, was VT100
  terminal, which is now a de-facto standard for all virtual terminal
  emulators. ``pyte`` follows the suit.
  So, why would one need a terminal emulator library?
  * To screen scrape terminal apps, for example ``htop`` or ``aptitude``.
  * To write cross platform terminal emulators; either with a graphical
    (`xterm <http://invisible-island.net/xterm/>`_,
    `rxvt <http://www.rxvt.org/>`_) or a web interface, like
    `AjaxTerm <http://antony.lesuisse.org/software/ajaxterm/>`_.
  * To have fun, hacking on the ancient, poorly documented technologies.
  **Note**: ``pyte`` started as a fork of `vt102 <http://github.com/samfoo/vt102>`_,
  which is an incomplete pure Python implementation of VT100 terminal.


pkgId: 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>`_.


