# packages

pkgId: a5210de5eafc136f8eb30b57e01889aa7a29a4a6a9202e6c4a36b6e50abc57ed
name: python-Pint
arch: src
version: 0.20.1
epoch: 0
release: 1
summary: Physical quantities module
url: https://github.com/hgrecco/pint
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd670273-828f-4e7e-963b-a343d734e881
location_href: 00004552-python-pint/python-Pint-0.20.1-1.src.rpm
checksum_type: sha256
description:
  Pint is a Python package to define, operate and manipulate physical
  quantities: the product of a numerical value and a unit of measurement.
  It allows arithmetic operations between them and conversions from and
  to different units.
  It is distributed with a comprehensive list of physical units, prefixes
  and constants. Due to its modular design, you can extend (or even rewrite!)
  the complete list without changing the source code. It supports a lot of
  numpy mathematical operations **without monkey patching or wrapping numpy**.
  It has a complete test coverage. It runs in Python 3.8+ with no other dependency.
  It is licensed under BSD.
  It is extremely easy and natural to use:
      >>> import pint
      >>> ureg = pint.UnitRegistry()
      >>> 3 * ureg.meter + 4 * ureg.cm
      <Quantity(3.04, 'meter')>
  and you can make good use of numpy if you want:
      >>> import numpy as np
      >>> [3, 4] * ureg.meter + [4, 3] * ureg.cm
      <Quantity([ 3.04  4.03], 'meter')>
      >>> np.sum(_)
      <Quantity(7.07, 'meter')>


pkgId: 44d18a14bcdb880647b72359bd0cd587469cb0a489b136e1f3ca2aeda52d6932
name: python-Pmw
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Python Megawidgets
url: http://pmw.sourceforge.net/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-238f174f-3139-477b-b4e0-9b7a34babec5
location_href: 00004572-python-pmw/python-Pmw-2.1.1-1.src.rpm
checksum_type: sha256
description:
  Pmw is a toolkit for building high-level compound widgets, or megawidgets,
          constructed using other widgets as component parts. It promotes consistent look and feel within
           and between graphical applications, is highly configurable to your needs and is easy to use.


pkgId: 8047c406f19f1a41f135804caf89b9233f4a8fa0089745afccce4901887ddf0c
name: python-ProDy
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: A Python Package for Protein Dynamics Analysis
url: http://www.csb.pitt.edu/ProDy
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d391c8e-e110-44c1-af65-1095913a5d46
location_href: 00002867-python-ProDy/python-ProDy-2.4.0-1.src.rpm
checksum_type: sha256
description:
  ProDy is a free and open-source Python package for protein structure, dynamics,
  and sequence analysis.  It allows for comparative analysis and modeling of
  protein structural dynamics and sequence co-evolution.  Fast and flexible ProDy
  API is for interactive usage as well as application development.  ProDy also
  comes with several analysis applications and a graphical user interface for
  visual analysis.


pkgId: cc49d295ea6a16f71519a3f585b96d682100678f2b185fda966f39671fd3ff66
name: python-PureCloudPlatformClientV2-help
arch: noarch
version: 168.0.0
epoch: 0
release: 1
summary: Development documents and examples for PureCloudPlatformClientV2
description: A Python library to interface with the PureCloud Platform API
url: https://developer.mypurecloud.com/api/rest/client-libraries/python/
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-77168a8e-57b0-447b-aff5-0939bd76ee9b
rpm_sourcerpm: python-PureCloudPlatformClientV2-168.0.0-1.src.rpm
checksum_type: sha256
location_href:
  00012858-python-purecloudplatformclientv2/python-PureCloudPlatformClientV2-help-168.0.0-1.noarch.rpm


pkgId: f06213b75fe989c117bd15d5a5833daa93a74b694e8d35076e50df28ffceb83f
name: python-PyAudio
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: Cross-platform audio I/O with PortAudio
url: https://people.csail.mit.edu/hubert/pyaudio/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c661256-9ef6-45b2-8dfa-ccb96b986db9
location_href: 00004637-python-pyaudio/python-PyAudio-0.2.13-1.src.rpm
checksum_type: sha256
description:
  <img align="right" width="200" style="margin-left: 3px" src="https://people.csail.mit.edu/hubert/pyaudio/images/snake-300.png">



  PyAudio provides Python bindings for PortAudio v19, the cross-platform audio I/O library. With PyAudio, you can easily use Python to play and record audio on a variety of platforms, such as GNU/Linux, Microsoft Windows, and Apple macOS.

  PyAudio is distributed under the MIT License.

  * [Homepage](https://people.csail.mit.edu/hubert/pyaudio/)
  * [API Documentation](https://people.csail.mit.edu/hubert/pyaudio/docs/)
  * [PyPi](https://pypi.python.org/pypi/PyAudio)



  See the INSTALLATION file in the source distribution for details. In summary, install PyAudio using `pip` on most platforms.



  ```sh
  python -m pip install pyaudio
  ```

  This installs the precompiled PyAudio library with PortAudio v19 19.7.0 included. The library is compiled with support for Windows MME API, DirectSound, WASAPI, and WDM-KS. It does not include support for ASIO. If you require support for APIs not included, you will need to compile PortAudio and PyAudio.



  Use [Homebrew](https://brew.sh) to install the prerequisite [portaudio](http://portaudio.com) library, then install PyAudio using `pip`:

  ```sh
  brew install portaudio
  pip install pyaudio
  ```



  Use the package manager to install PyAudio. For example, on Debian-based systems:

  ```sh
  sudo apt install python3-pyaudio
  ```

  Alternatively, if the latest version of PyAudio is not available, install it using `pip`. Be sure to first install development libraries for `portaudio19` and `python3`.



  See the INSTALLATION file.



  * Read the [API Documentation](https://people.csail.mit.edu/hubert/pyaudio/docs/), or generate it from the source using [`sphinx`](https://www.sphinx-doc.org/).

  * Usage examples are in the `examples` directory of the source distribution, or see the [project homepage](https://people.csail.mit.edu/hubert/pyaudio/).



  PyAudio is distributed under the MIT License. See LICENSE.txt.


pkgId: d6f646bc51e0b29b140d0ad81d3213bc512415403671504413ff0e37eaabca97
name: python-PyAutoGUI
arch: src
version: 0.9.53
epoch: 0
release: 1
url: https://github.com/asweigart/pyautogui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-18e1d433-cb7e-4a9c-918d-317b787dc000
location_href: 00009982-python-pyautogui/python-PyAutoGUI-0.9.53-1.src.rpm
checksum_type: sha256
summary:
  PyAutoGUI lets Python control the mouse and keyboard, and other GUI automation tasks. For Windows, macOS, and Linux, on Python 3 and 2.

description:
  PyAutoGUI is a  cross-platform GUI automation Python module for human beings. Used to programmatically control the mouse & keyboard.
  `pip install pyautogui`
  Full documentation available at https://pyautogui.readthedocs.org
  Simplified Chinese documentation available at https://muxuezi.github.io/posts/doc-pyautogui.html
  Source code available at https://github.com/asweigart/pyautogui
  If you need help installing Python, visit https://installpython3.com/


pkgId: 5734f49230899867dde8fed49c9750c081aedd32028ebaba9c8d8d0f4ffb5758
name: python-PyByteBuffer
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: A bytes manipulation library inspired by Java ByteBuffer
url: https://github.com/iGio90/PyByteBuffer
rpm_license: GPL 3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-061db6ba-6005-4a4e-a42a-b472ccc120f9
location_href: 00009614-python-pybytebuffer/python-PyByteBuffer-1.0.5-1.src.rpm
checksum_type: sha256
description:
  A library to manipulate buffers inspired by [Java nio ByteBuffer](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html)

  > [>> DOCUMENTATION](https://igio90.github.io/PyByteBuffer/)



  ```
  pip3 install PyByteBuffer
  ```



  ```python
  from PyByteBuffer import ByteBuffer

  buf = ByteBuffer.allocate(50)

  buf.put(0x10)
  buf.put([0xcc, 0xdd, 0xee])
  buf.put('something')
  buf.put(bytes([00] * 4))


  buf.put(123456, 'little')
  buf.put(1234561434234234, 'big')


  value = buf.get(1)

  value = buf.get(10, 'little')


  buf = ByteBuffer.from_hex('deadbeef')
  buf = ByteBuffer.wrap(bytes())
  ```


  The performance analysis we can do in this library is all around the conversion between int->bytes bytes<-int.

  Tested with a cycle of 1/100/500/1000 conversion using python3 builtin api int.to_bytes/from_bytes, struct pack/unpack and a "primitive" solution
  posted in [stackoverflow](https://stackoverflow.com/a/35634239)


pkgId: 10309eab501b9200fdf9d83a1e10c012250ac6abee56f9dab1ffe2c05df28d40
name: python-PyChromecast
arch: src
version: 13.0.7
epoch: 0
release: 1
summary: Python module to talk to Google Chromecast.
url: https://github.com/balloob/pychromecast
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b9ba351-d393-47db-b60e-6be6b6e0cbd2
location_href: 00011136-python-pychromecast/python-PyChromecast-13.0.7-1.src.rpm
checksum_type: sha256
description:
  Library for Python 3.6+ to communicate with the Google Chromecast. It
  currently supports:
  -  Auto discovering connected Chromecasts on the network
  -  Start the default media receiver and play any online media
  -  Control playback of current playing media
  -  Implement Google Chromecast api v2
  -  Communicate with apps via channels
  -  Easily extendable to add support for unsupported namespaces
  -  Multi-room setups with Audio cast devices
  *Check out* `Home Assistant <https://home-assistant.io>`_ *for a
  ready-made solution using PyChromecast for controlling and automating
  your Chromecast or Cast-enabled device like Google Home.*


pkgId: 7ccd92cd357df6283904fbcff847d36d4fc7e425c569df43f65bbd55da885ff9
name: python-PyDbLite
arch: src
version: 3.0.4
epoch: 0
release: 1
summary: PyDbLite, a fast, pure-Python in-memory database
url: http://www.pydblite.net/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5298ade5-64ea-4061-8996-1718c564ebf1
location_href: 00013161-python-pydblite/python-PyDbLite-3.0.4-1.src.rpm
checksum_type: sha256
description:
  PyDbLite is
  * a fast, pure-Python, untyped, in-memory database engine, using
    Python syntax to manage data, instead of SQL
  * a pythonic interface to SQLite using the same syntax as the
    pure-Python engine for most operations (except database connection
    and table creation because of each database specificities)
  PyDbLite is suitable for a small set of data where a fully fledged DB would be overkill.
  Supported Python versions: 2.6+
  Build status: |build-status|
  Read the documentation: |docs|


pkgId: bb1386ff6594afb13d6eac6d1248889f6bf4b563440b9e4124060c9131439932
name: python-PyDictionary
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A real dictionary module for Python
url: https://github.com/geekpradd/PyDictionary
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-51cce01b-121d-4b04-8edb-ca49d243159f
location_href: 00010037-python-pydictionary/python-PyDictionary-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](http://img.shields.io/travis/geekpradd/PyDictionary/master.svg?style=flat-square)](https://travis-ci.org/geekpradd/PyDictionary)
  [![Latest Version](http://img.shields.io/pypi/v/PyDictionary.svg?style=flat-square)](https://pypi.python.org/pypi/PyDictionary/)
  [![License](https://img.shields.io/pypi/l/PyDictionary.svg?style=flat-square)](https://pypi.python.org/pypi/PyDictionary/)
  [![Downloads](https://img.shields.io/pypi/dm/PyDictionary.svg?style=flat-square)](https://pypi.python.org/pypi/PyDictionary/)

  PyDictionary is a Dictionary Module for Python 2/3 to get meanings, translations, synonyms and Antonyms of words. It uses WordNet for getting meanings, Google for translations, and synonym.com for getting synonyms and antonyms.

  This module uses Python Requests, BeautifulSoup4 and goslate as dependencies



  Installation is very simple through pip (or easy_install)

  For pip

  ```
  pip install PyDictionary
  ```

  For Easy_Install

  ```
  easy_install  PyDictionary
  ```



  PyDictionary can be utilised in 2 ways, either by creating a dictionary instance which can take words as arguments or by creating a dictionary instance with a fixed amount of words.

  For example,

  ```python
  from PyDictionary import PyDictionary
  dictionary=PyDictionary()
  ```

  This is will create a local instance of the PyDictionary class and now it can be used to get meanings, translations etc.

  ```python
  print (dictionary.meaning("indentation"))
  ```

  This will return a dictionary containing the meanings of the word.
  For example the above code will return:

  ```
  {'Noun': ['a concave cut into a surface or edge (as in a coastline', 'the
   formation of small pits in a surface as a consequence of corrosion', 'th
  e space left between the margin and the start of an indented line', 'the
  act of cutting into an edge with toothlike notches or angular incisions']
  }
  ```
  The dictionary keys are the different types of the word. If a word is both a verb and a noun then there will be 2 keys:'Noun' and 'Verb'.
  Each key refers to a list containing the meanings


  For Synonyms,

  ```python
  print (dictionary.synonym("Life"))
  ```

  This will return a list containing the Synonyms of the word.

  For Antonyms,

  ```python
  print (dictionary.antonym("Life"))
  ```
  This will return a list containing the Antonyms of the word.

  For Translations,

  ```python
  print (dictionary.translate("Range",'es'))
  ```

  This will return the Translation of the word "Range" in Spanish. For Language codes consult Google Translate. The return value is string in Python 3 and unicode in Python 2

  Alternatively, you can set a fixed number of words to the PyDictionary Instance. This is useful if you just want to get the meanings of some words quickly without any development need.

  Example:

  ```python
  from PyDictionary import PyDictionary

  dictionary=PyDictionary("hotel","ambush","nonchalant","perceptive")
  'There can be any number of words in the Instance'

  print(dictionary.printMeanings()) '''This print the meanings of all the words'''
  print(dictionary.getMeanings()) '''This will return meanings as dictionaries'''
  print (dictionary.getSynonyms())

  print (dictionary.translateTo("hi")) '''This will translate all words to Hindi'''

  ```

  Similarly Synonyms and Antonyms can also be printed onto the screen.



  Current Version: 2.0.1
  Created By Pradipta Bora 2020.


pkgId: 9a293316cec229f3b45c95076414ccf2d909dfa5d08568ab9e24a762a98e0e5b
name: python-PyDispatcher
arch: src
version: 2.0.7
epoch: 0
release: 1
summary: Multi-producer multi-consumer in-memory signal dispatch system
url: https://github.com/mcfletch/pydispatcher
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49a3055a-d75d-43db-8b87-32f85088fcea
location_href: 00004661-python-pydispatcher/python-PyDispatcher-2.0.7-1.src.rpm
checksum_type: sha256
description:
  PyDispatcher provides the Python programmer with a multiple-producer-multiple-consumer signal-registration and
  routing infrastructure for use in multiple contexts. The mechanism
  of PyDispatcher started life as a highly rated [recipe](http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/87056)
  in the [Python Cookbook](http://aspn.activestate.com/ASPN/Python/Cookbook/). The [project](https://github.com/mcfletch/pydispatcher) aims
  to include various enhancements to the recipe developed during use in
  various applications. It is primarily maintained by [Mike Fletcher](http://www.vrplumber.com). A derivative
  of the project provides the Django web framework's "signal" system.



  PyDispatcher is available on PyPI via standard PIP:
  ```
  pip install PyDispatcher
  ```
  [![Latest PyPI Version](https://img.shields.io/pypi/v/pydispatcher.svg)](https://pypi.python.org/pypi/pydispatcher)
  [![Latest PyPI Version](https://img.shields.io/pypi/dm/pydispatcher.svg)](https://pypi.python.org/pypi/pydispatcher)




  [Documentation](https://mcfletch.github.io/pydispatcher/) is available
  for detailed usage, but the basic idea is:

  ```
  from pydispatch import dispatcher

  metaKey = "moo"
  MyNode = object()
  event = {"sample": "event"}


  def callback(event=None):
      """Handle signal being sent"""
      print("Signal received", event)


  dispatcher.connect(callback, sender=MyNode, signal=metaKey)
  dispatcher.send(metaKey, MyNode, event=event)
  ```


pkgId: f2813f71384abbd02be9b22929078daf73f724642786c748dc98dc64b73a948c
name: python-PyDrive
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Google Drive API made easy.
url: https://github.com/googledrive/PyDrive
rpm_license: LICENSE
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c2cdda8-c434-43ab-bb09-206c7b8d3c8d
location_href: 00002868-python-PyDrive/python-PyDrive-1.3.1-1.src.rpm
checksum_type: sha256
description:
  *PyDrive* is a wrapper library of
  `google-api-python-client <https://code.google.com/p/google-api-python-client/>`_
  that simplifies many common Google Drive API tasks.


pkgId: 5a0fb8885ebf00dbc236b0b2820022cc3ac38119e8ad54a75676543ccf8d7030
name: python-PyDrive2
arch: src
version: 1.15.3
epoch: 0
release: 1
summary: Google Drive API made easy. Maintained fork of PyDrive.
url: https://github.com/iterative/PyDrive2
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e416ba54-e05d-4edf-9a94-3461aefc8f90
location_href: 00012990-python-pydrive2/python-PyDrive2-1.15.3-1.src.rpm
checksum_type: sha256
description:
  *PyDrive2* is a wrapper library of
  `google-api-python-client <https://github.com/google/google-api-python-client>`_
  that simplifies many common Google Drive API V2 tasks. It is an actively
  maintained fork of `https://pypi.python.org/pypi/PyDrive <https://pypi.python.org/pypi/PyDrive>`_.
  By the authors and maintainers of the `Git for Data <https://dvc.org>`_ - DVC
  project.


pkgId: 367a2093a6b152a78315ec248aa7bbf116ae0c2a273511b4fe5da0a0c6bf7c1d
name: python-PyExcelerate
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Accelerated Excel XLSX Writing Library for Python 2/3
url: https://github.com/kz26/PyExcelerate
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-475717b2-6125-412a-9782-7b565fd51a74
location_href: 00010504-python-pyexcelerate/python-PyExcelerate-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Accelerated Excel XLSX writing library for Python
  master: |build-status-master| dev: |build-status-dev| test coverage:
  |coverage-status|
  -  Authors: `Kevin Wang <https://github.com/kevmo314>`__ and `Kevin
     Zhang <https://github.com/kz26>`__
  -  Copyright 2015 Kevin Wang, Kevin Zhang. Portions copyright Google,
     Inc.
  -  License: Simplified BSD License
  -  `Source repository <https://github.com/kz26/PyExcelerate>`__
  -  `PyPI page <https://pypi.python.org/pypi/PyExcelerate>`__


pkgId: 28ff4e9e894efd9649b0e1ea9dfffc559fa1a687b53f2c61a0a5b38da26da7bc
name: python-PyGithub
arch: src
version: 1.58.0
epoch: 0
release: 1
summary: Use the full Github API v3
url: https://github.com/pygithub/pygithub
rpm_license: GNU Library or Lesser General Public License (LGPL)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b024451e-4912-468f-9278-245129c82441
location_href: 00004686-python-pygithub/python-PyGithub-1.58.0-1.src.rpm
checksum_type: sha256
description:
  First create a Github instance::
      from github import Github
      
      g = Github("user", "password")
      
      g = Github("access_token")
  Then play with your Github objects::
      for repo in g.get_user().get_repos():
          print(repo.name)
          repo.edit(has_wiki=False)


pkgId: be785fdac657daabfe9ae1d4a8567b05b097e1de2ddf0f5a145f3c10f7ba825b
name: python-PyGreSQL
arch: src
version: 5.2.4
epoch: 0
release: 1
summary: Python PostgreSQL Interfaces
url: http://www.pygresql.org
rpm_license: PostgreSQL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3accc3dd-3a69-4f83-b94e-a2e672469c74
location_href: 00004696-python-pygresql/python-PyGreSQL-5.2.4-1.src.rpm
checksum_type: sha256
description:
  PyGreSQL is an open-source Python module that interfaces to a
  PostgreSQL database. It embeds the PostgreSQL query library to allow
  easy use of the powerful PostgreSQL features from a Python script.


pkgId: 4e51483a32cad0d9031dae36337561c9335940ef58086e134d81d7e380e68ece
name: python-PyICU
arch: src
version: 2.10.2
epoch: 0
release: 1
summary: Python extension wrapping the ICU C++ API
url: https://gitlab.pyicu.org/main/pyicu
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-59ca1ad2-5af4-4d0d-91dd-cb3361f4b836
location_href: 00004706-python-pyicu/python-PyICU-2.10.2-1.src.rpm
checksum_type: sha256
description:
  Welcome to PyICU, a Python extension wrapping the ICU C++ libraries.

  ICU stands for "International Components for Unicode".
  These are the i18n libraries of the Unicode Consortium.
  They implement much of the Unicode Standard,
  many of its companion Unicode Technical Standards,
  and much of Unicode CLDR.

  The PyICU source code is hosted at https://gitlab.pyicu.org/main/pyicu.

  The ICU homepage is https://icu.unicode.org/

  See also the CLDR homepage at http://cldr.unicode.org/



  PyICU is a python extension implemented in C++ that wraps the C/C++ ICU library.
  It is known to also work as a [PyPy](https://www.pypy.org/) extension.
  Unless ``pkg-config`` and the ICU libraries and headers are already installed,
  building PyICU from the sources on [PyPI](https://pypi.org/project/PyICU/)
  involves more than just a ``pip`` call. Many operating systems distribute
  pre-built binary packages of ICU and PyICU, see below.

    - Mac OS X
      - Ensure ICU is installed and can be found by `pkg-config` (as `icu-config` was [deprecated](https://unicode-org.github.io/icu/userguide/icu/howtouseicu.html#c-makefiles) as of ICU 63.1), either by following [ICU build instructions](https://unicode-org.github.io/icu/userguide/icu4c/build.html), or by using Homebrew:
        ```sh
        
        brew install pkg-config icu4c

        
        export PATH="/usr/local/opt/icu4c/bin:/usr/local/opt/icu4c/sbin:$PATH"
        export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/opt/icu4c/lib/pkgconfig"
        ```
      - Install PyICU **with the same C++ compiler as your Python distribution**
        ([more info](https://gitlab.pyicu.org/main/pyicu/merge_requests/140#issuecomment-782283491)):
        ```sh
        
        export CC="$(which gcc)" CXX="$(which g++)"
        
        unset CC CXX

        
        pip install --no-binary=:pyicu: pyicu
        ```

      - ICU and PyICU binaries are both available via [Macports](https://www.macports.org/) as well. The same limitations about mixing binaries may apply.
        ```sh
        
        /opt/local/bin/port search pyicu
        sudo /opt/local/bin/port install ...
        ```

    - Debian
      ```sh
      apt-get update

      
      apt-get install python3-icu
      
      apt-get install pkg-config libicu-dev
      pip install --no-binary=:pyicu: pyicu
      ```

    - Ubuntu: similar to Debian, there is a pyicu
      [package](https://packages.ubuntu.com/source/xenial/python/pyicu)
      available via ``apt``.

    - Alpine Linux: there is a pyicu
      [package](https://pkgs.alpinelinux.org/package/edge/community/x86/py3-icu)
      available via ``apk``.

    - NetBSD: there is a pyicu [package](https://pkgsrc.se/textproc/py-ICU)
      available via ``pkg_add``.

    - OpenBSD: there is a pyicu [package](https://openports.se/textproc/py-ICU)
      available via ``pkg_add``.

    - Other operating systems: see below.



  *Please, refer to [next section](#building-pyicu-python-3-and-icu-from-sources) for building Python, ICU and PyICU from sources.
  The current section is about building only PyICU from sources, with all dependencies such as Python and ICU already present.*

  Before building PyICU the ICU libraries must be built and installed. Refer
  to each system's [instructions](https://unicode-org.github.io/icu/userguide/icu4c/build.html) for more information.

  PyICU is built from sources with ``setuptools`` or with ``build`` and ``pip``:

     - verify that ``pkg-config`` is available (the ``icu-config`` program is
       [deprecated](https://unicode-org.github.io/icu/userguide/icu/howtouseicu.html#c-makefiles)
       as of ICU 63.1)
       ```sh
       pkg-config --cflags --libs icu-i18n
       ```
       If this command returns an error or doesn't return the paths expected
       then ensure that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES``
       dictionaries in ``setup.py`` contain correct values for your platform.
       Starting with ICU 60, ``-std=c++11`` must appear in your CFLAGS or be the
       default for your C++ compiler.

     - **either** build and install PyICU with ``setuptools``
       ```sh
       python setup.py build
       sudo python setup.py install
       ```

     - **or** build PyICU with ``build`` and install it with ``pip``
       ```sh
       python -m build
       sudo python -m pip install dist/PyICU-<version>-<platform>.whl
       ```

     - **either** test PyICU with ``setuptools``
       ```sh
       python setup.py test
       ```

     - **or** test PyICU with ``pytest``
       ```sh
       python -m pytest
       ```




  The instructions at [note_855](https://gitlab.pyicu.org/main/pyicu/-/issues/153#note_855) contain the complete steps for building everything from sources into
  a self-contained directory, without modifying any system directories. They were
  made and tested on an M1 Mac but they can be modified and reused for any unix
  environment. In particular, they outline how to build PyICU from sources
  without icu-config or pkg-config being present.




    - Mac OS X
      Make sure that ``DYLD_LIBRARY_PATH`` contains paths to the directory(ies)
      containing the ICU libs.

    - Linux & Solaris
      Make sure that ``LD_LIBRARY_PATH`` contains paths to the directory(ies)
      containing the ICU libs or that you added the corresponding ``-rpath``
      argument to ``LFLAGS``.

    - Windows
      Make sure that ``PATH`` contains paths to the directory(ies)
      containing the ICU DLLs.




  See the [CHANGES](https://gitlab.pyicu.org/main/pyicu/blob/main/CHANGES) file
  for an up to date log of changes and additions.




  There is no API documentation for PyICU. The API for ICU is documented at
  https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/ and the
  following patterns can be used to translate from the C++ APIs to the
  corresponding Python APIs.



  The ICU string type, [UnicodeString](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/classicu_1_1UnicodeString.html), is a type pointing at a mutable array of [UChar](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/umachine_8h.html#a6bb9fad572d65b305324ef288165e2ac) Unicode 16-bit wide characters and is described [here](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/classicu_1_1UnicodeString.html#details). The Python 3 [str](https://docs.python.org/3/library/stdtypes.html#str) type is described [here](https://docs.python.org/3/library/stdtypes.html#index-26) and [here](https://docs.python.org/3/howto/unicode.html). The Python 2 [unicode](https://docs.python.org/2.7/reference/datamodel.html#index-23) type is described [here](https://docs.python.org/2.7/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange).

  Because of their differences, ICU's and Python's string objects are not merged
  into the same type when crossing the C++ boundary but converted.

  ICU APIs taking ``UnicodeString`` arguments have been overloaded to also
  accept arguments that are Python 3 ``str`` or Python 2 ``unicode`` objects.
  Python 2 ``str`` objects are auto-decoded into ICU strings using the ``utf-8``
  encoding.

  To convert a Python 3 ``bytes`` or a Python 2 ``str`` object encoded in an
  encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the
  ``UnicodeString(str, encodingName)`` constructor.

  ICU's C++ APIs accept and return ``UnicodeString`` arguments in several
  ways: by value, by pointer or by reference.
  When an ICU C++ API is documented to accept a ``UnicodeString`` reference
  parameter, it is safe to assume that there are several corresponding
  PyICU python APIs making it accessible in simpler ways:

  For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'``
  API, documented
  [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1Locale.html#a61def321a9cfd9904b59e3f1897f835e),
  can be invoked from Python in several ways:

  1. The ICU way

          >>> from icu import UnicodeString, Locale
          >>> locale = Locale('pt_BR')
          >>> string = UnicodeString()
          >>> name = locale.getDisplayName(string)
          >>> name
          <UnicodeString: 'Portuguese (Brazil)'>
          >>> name is string
          True                  <-- string arg was returned, modified in place

  2. The Python way

          >>> from icu import Locale
          >>> locale = Locale('pt_BR')
          >>> name = locale.getDisplayName()
          >>> name
          'Portuguese (Brazil)'

      A ``UnicodeString`` object was allocated and converted to a Python
      ``str`` object.

  A UnicodeString can be converted to a Python unicode string with Python 3's
  ``str()`` or Python 2's ``unicode()`` constructor. The usual ``len()``,
  comparison, `[]`` and ``[:]`` operators are all available, with the additional
  twists that slicing is not read-only and that ``+=`` is also available since a
  UnicodeString is mutable. For example:

      >>> name = locale.getDisplayName()
      'Portuguese (Brazil)'
      >>> name = UnicodeString(name)
      >>> name
      <UnicodeString: 'Portuguese (Brazil)'>
      >>> str(name)
      'Portuguese (Brazil)'
      >>> len(name)
      19
      >>> str(name)
      'Portuguese (Brazil)'
      >>> name[3]
      't'
      >>> name[12:18]
      <UnicodeString: 'Brazil'>
      >>> name[12:18] = 'the country of Brasil'
      >>> name
      <UnicodeString: 'Portuguese (the country of Brasil)'>
      >>> name += ' oh joy'
      >>> name
      <UnicodeString: 'Portuguese (the country of Brasil) oh joy'>



  The C++ ICU library does not use C++ exceptions to report errors. ICU
  C++ APIs return errors via a ``UErrorCode`` reference argument. All such
  APIs are wrapped by Python APIs that omit this argument and throw an
  ``ICUError`` Python exception instead. The same is true for ICU APIs
  taking both a ``ParseError`` and a ``UErrorCode``, they are both to be
  omitted.

  For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, FieldPosition &, UErrorCode &)'`` API, documented [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1DateFormat.html#aae63209f1202550c91e2beed5691b062) is invoked from Python with:

      >>> from icu import DateFormat, Formattable
      >>> df = DateFormat.createInstance()
      >>> df
      <SimpleDateFormat: M/d/yy h:mm a>
      >>> f = Formattable(940284258.0, Formattable.kIsDate)
      >>> df.format(f)
      '10/18/99 3:04 PM'

  Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1DateFormat.html#a5940ccf5676d3fa043d8255c55b7ddd1) can be used too:

      >>> from icu import DateFormat
      >>> df = DateFormat.createInstance()
      >>> df
      <SimpleDateFormat: M/d/yy h:mm a>
      >>> df.format(940284258.0)
      '10/18/99 3:04 PM'



  ICU uses a double floating point type called ``UDate`` that represents the
  number of milliseconds elapsed since 1970-jan-01 UTC for dates.

  In Python, the value returned by the ``time`` module's ``time()``
  function is the number of seconds since 1970-jan-01 UTC. Because of this
  difference, floating point values are multiplied by 1000 when passed to
  APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``.

  Python's ``datetime`` objects, with or without timezone information, can
  also be used with APIs taking ``UDate`` arguments. The ``datetime``
  objects get converted to ``UDate`` when crossing into the C++ layer.



  Many ICU API take array arguments. A list of elements of the array
  element types is to be passed from Python.



  An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which
  returns ``str`` objects, ``unext()`` which returns ``str`` objects in Python 3
  or ``unicode`` objects in Python 2 and ``snext()`` which returns
  ``UnicodeString`` objects. Any of these methods can be used as an iterator,
  using the Python built-in ``iter`` function.

  For example, let ``e`` be a ``StringEnumeration`` instance:

  ```python
  e = TimeZone.createEnumeration()
  [s for s in e] # a list of 'str' objects
  [s for s in iter(e.unext, '')] # a list of 'str' or 'unicode' objects
  [s for s in iter(e.snext, '')] # a list of 'UnicodeString' objects
  ```



  The ICU ``TimeZone`` type may be wrapped with an ``ICUtzinfo`` type for
  usage with Python's ``datetime`` type. For example:

  ```python
  from datetime import datetime
  tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain'))
  datetime.now(tz)
  ```

  or, even simpler:

  ```python
  tz = ICUtzinfo.getInstance('Pacific/Fiji')
  datetime.now(tz)
  ```

  To get the default time zone use:

  ```python
  defaultTZ = ICUtzinfo.getDefault()
  ```

  To get the time zone's id, use the ``tzid`` attribute or coerce the time
  zone to a string:

  ```python
  ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji'
  str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji'
  ```



  The [unit tests](https://gitlab.pyicu.org/main/pyicu/-/tree/main/test) have
  more examples of actual PyICU usage.

  There are also a few
  [samples](https://gitlab.pyicu.org/main/pyicu/-/tree/main/samples) ported from
  ICU C/C++.


pkgId: 15b6a01950fcc49ce2b860174b33c7af5a34e5d3febbb845798d7a74b61240bb
name: python-PyInquirer
arch: src
version: 1.0.3
epoch: 0
release: 1
url: https://github.com/CITGuru/PyInquirer/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d6cdc5a6-fd9f-4a36-be70-3a0d20c285f4
location_href: 00012626-python-pyinquirer/python-PyInquirer-1.0.3-1.src.rpm
checksum_type: sha256
summary:
  A Python module for collection of common interactive command line user interfaces, based on Inquirer.js

description:
  A collection of common interactive command line user interfaces. It is
  originally called `whaaaaaat <https://github.com/finklabs/whaaaaat>`__
  created by **finklabs**, but due to bad naming and in need of fixes, I
  decided to rename and apply some necessary fixes on it. The reason is
  because I needed it for a tool that can be install through PyPI. I need
  to rewrite it for my own need. But don't worry any new fix on the main
  Repo, will be added to it if needed. Lastly, I am currently working on
  the author's TODO.


pkgId: 50d9bb7e510f27066976a40551e6317be2f7e9e607652e60f9ffda5efbadc3d6
name: python-PyLEMS
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: A Python library for working with the Low Entropy Model Specification language (LEMS)
url: https://github.com/LEMS/pylems
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ab009cbb-4b3a-42d0-924e-4f1235fb10ec
location_href: 00002869-python-PyLEMS/python-PyLEMS-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/LEMS/pylems/actions/workflows/ci.yml/badge.svg)](https://github.com/LEMS/pylems/actions/workflows/ci.yml) [![Documentation Status](https://readthedocs.org/projects/pylems/badge/?version=latest)](https://pylems.readthedocs.io/en/latest/?badge=latest)


  A LEMS (http://lems.github.io/LEMS) simulator written in Python which can be used to run NeuroML2 (http://neuroml.org/neuroml2.php) models.

  For more about PyLEMS see:

  Michael Vella, Robert C. Cannon, Sharon Crook, Andrew P. Davison, Gautham Ganapathy, Hugh P. C. Robinson, R. Angus Silver and Padraig Gleeson,
  **libNeuroML and PyLEMS: using Python to combine procedural and declarative modeling approaches in computational neuroscience**
  [Frontiers in Neuroinformatics 2014](http://journal.frontiersin.org/Journal/10.3389/fninf.2014.00038/abstract), doi: 10.3389/fninf.2014.00038

  _**PLEASE CITE THE PAPER ABOVE IF YOU USE PYLEMS!**_

  For more details on LEMS see:

  Robert C. Cannon, Padraig Gleeson, Sharon Crook, Gautham Ganapathy, Boris Marin, Eugenio Piasini and R. Angus Silver,
  **LEMS: A language for expressing complex biological models in concise and hierarchical form and its use in underpinning NeuroML 2**,
  [Frontiers in Neuroinformatics 2014](http://journal.frontiersin.org/Journal/10.3389/fninf.2014.00079/abstract), doi: 10.3389/fninf.2014.00079




  A stable version of PyLEMS is [available on PyPI](https://pypi.python.org/pypi/PyLEMS) using [pip](https://pip.pypa.io/en/latest/installing.html):

      pip install pylems

  To install as root:

      sudo pip install pylems

  Alternatively, you can obtain the latest version with

      git clone https://github.com/LEMS/pylems.git
      cd pylems
      git checkout development   # optional
      sudo python setup.py install



      pylems [options] LEMS_file

  **Options**

  - -I/-include path - Adds a directory to the model file include search path





  **NeuroML examples (from https://github.com/NeuroML/NeuroML2/tree/development/NeuroML2CoreTypes)**

  - Example 0 --  Working
  - Example 1 --  Working
  - Example 2 --  Working
  - Example 3 --  Working
  - Example 4 --  Not working (Unsupported in PyLEMS: KSChannel)
  - Example 5 --  Working
  - Example 6 --  Working
  - Example 7 --  Working
  - Example 8 --  Working
  - Example 9 --  Working
  - Example 10 -- Working
  - Example 11 -- Working
  - Example 12 -- Not working (Unsupported in PyLEMS: Property)
  - Example 13 -- Working
  - Example 14 -- Not working (Unsupported in PyLEMS: Property)
  - Example 15 -- Working
  - Example 16 -- Working (apart from spikeArray)
  - Example 17 -- Working
  - Example 18 -- Working


  **LEMS examples (in directory examples)**

  - example1.xml --  Working
  - example2.xml --  Working
  - example3.xml --  Working
  - example4.xml --  Not working (Unsupported in PyLEMS: KSChannel)
  - example5.xml --  Not working (Unsupported in PyLEMS: KSChannel)
  - example6.xml --  Working
  -- TODO: Rest of examples require an update to the `<Simulation>` element,
     i.e. use `<Simulation...>` not `<SimulationSet...>`, to work in PyLEMS


  **LEMS elements that do not work**

  - KSChannel
  - Property
  - XPath based parameters - PathParameter
  - Assertions

  **Tasks TODO**

  - Implement flattening
  - Decouple events from runnables
  - Improve dimension-checking on expressions.




  pylems is integrated with the the [Travis Continuous Integration service](http://travis-ci.com/).

  [![Build Status](https://travis-ci.com/LEMS/pylems.png?branch=master)](https://travis-ci.com/LEMS/pylems)

  This code is distributed under the terms of the GNU Lesser General Public License.


pkgId: 154627d1907c177d70ea58cc12f272f2a76d450eeaf7f8d4b156301165cc48f2
name: python-PyLTI1p3
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: LTI 1.3 Advantage Tool implementation in Python
url: https://github.com/dmitry-viskov/pylti1.3
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-48fd76b6-03f3-4576-885c-9d742b1ac7f9
location_href: 00013485-python-pylti1p3/python-PyLTI1p3-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This project is a Python implementation of the similar `PHP tool`_.
  This library contains adapters for use with the Django and Flask web frameworks. However, there are no difficulties with adapting it to other frameworks; you just need to re-implement the ``OIDCLogin`` and ``MessageLaunch`` classes as it is already done in existing adapters.


pkgId: 361eb757d10df76759475b6bd65c71bca878cc227e84c2eee02f54bf624b4167
name: python-PyLaTeX
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: A Python library for creating LaTeX files and snippets
url: https://github.com/JelteF/PyLaTeX
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12a7f5d0-187d-4ab9-ba9a-a9d8a8132afb
location_href: 00004720-python-pylatex/python-PyLaTeX-1.4.1-1.src.rpm
checksum_type: sha256
description:
  PyLaTeX is a Python library for creating and compiling LaTeX files or
  snippets. The goal of this library is being an easy, but extensible
  interface between Python and LaTeX.


pkgId: 3ad15cdd58fdac5641a55690e7ae01e7e8c431ea5c776743499b610dd1fa323d
name: python-PyLink
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Universal communication interface using File-Like API
url: https://github.com/SalemHarrache/PyLink
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-518f16a4-f801-42e3-8882-0960007811fb
location_href: 00002870-python-PyLink/python-PyLink-0.3.3-1.src.rpm
checksum_type: sha256
description:
  Pylink offers a universal communication interface using File-Like API.
  For now, only the **TCP**, **UDP**, **Serial** and **GSM** interfaces are
  supported.
  The aim of this project is to allow any type of communication.
  It is best suited for projects that have various ways of communicating
  including IP remote or local serial communication.


pkgId: 7d2c07cdfbef8e0655cafb4915293427db87360d697901be71fb63d8fcf807ae
name: python-PyMeeus
arch: src
version: 0.5.12
epoch: 0
release: 1
summary: Python implementation of Jean Meeus astronomical routines
url: https://github.com/architest/pymeeus
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-57af5955-513f-4ab7-9fc2-c396fc5150b7
location_href: 00004735-python-pymeeus/python-PyMeeus-0.5.12-1.src.rpm
checksum_type: sha256
description:
     **Library of astronomical algorithms in Python**.
  PyMeeus is a Python implementation of the astronomical algorithms
  described in the classical book 'Astronomical Algorithms, 2nd Edition,
  Willmann-Bell Inc. (1998)' by Jean Meeus.
  There are great astronomical libraries out there. For instance, if
  you're looking for high precision and speed you should take a look at
  `libnova <http://libnova.sourceforge.net/>`__. For a set of python
  modules aimed at professional astronomers, you should look at
  `Astropy <http://www.astropy.org/>`__. On the other hand, the advantages
  of PyMeeus are its simplicity, ease of use, ease of reading, ease of
  installation (it has the minimum amount of dependencies) and abundant
  documentation.


pkgId: 5bedc893ecb34d6ad25e4d9010a827dc2d39a09eaa05d187901a7280fee71a3c
name: python-PyMsgBox
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: A simple, cross-platform, pure Python module for JavaScript-like message boxes.
url: https://github.com/asweigart/pymsgbox
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4869a577-d279-4b49-92e1-458993a97918
location_href: 00010085-python-pymsgbox/python-PyMsgBox-1.0.9-1.src.rpm
checksum_type: sha256
description:
   A simple, cross-platform, pure Python module for JavaScript-like message boxes.
  To import, run:
      >>> from pymsgbox import *`
   There are four functions in PyMsgBox, which follow JavaScript's message box naming conventions:
      >>> alert(text='', title='', button='OK')`
      Displays a simple message box with text and a single OK button. Returns the text of the button clicked on.
      >>> confirm(text='', title='', buttons=['OK', 'Cancel'])`
      Displays a message box with OK and Cancel buttons. Number and text of buttons can be customized. Returns the text of the button clicked on.
      >>> prompt(text='', title='' , defaultValue='')`
      Displays a message box with text input, and OK & Cancel buttons. Returns the text entered, or None if Cancel was clicked.
      >>> password(text='', title='', defaultValue='', mask='*')`
      Displays a message box with text input, and OK & Cancel buttons. Typed characters appear as *. Returns the text entered, or None if Cancel was clicked.
  On Linux Python 2, you need to first install Tkinter by running: sudo apt-get install python-tk
  Modified BSD License
  Derived from Stephen Raymond Ferg's EasyGui http://easygui.sourceforge.net/


pkgId: fe2faae7c032708258f1b4cb9b57d2577bdbb5ef258850c6a1fc9252de3de930
name: python-PyNLPl
arch: src
version: 1.2.9
epoch: 0
release: 1
url: https://github.com/proycon/pynlpl
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bba582a5-c3bf-4e5b-bbf7-a3bf22692103
location_href: 00004747-python-pynlpl/python-PyNLPl-1.2.9-1.src.rpm
checksum_type: sha256
summary:
  PyNLPl, pronounced as 'pineapple', is a Python library for Natural Language Processing. It contains various modules useful for common, and less common, NLP tasks. PyNLPl contains modules for basic tasks, clients for interfacting with server, and modules for parsing several file formats common in NLP, most notably FoLiA.

description:
  PyNLPl, pronounced as 'pineapple', is a Python library for Natural Language
  Processing. It contains various modules useful for common, and less common, NLP
  tasks. PyNLPl can be used for basic tasks such as the extraction of n-grams and
  frequency lists, and to build simple language model. There are also more
  complex data types and algorithms. Moreover, there are parsers for file formats
  common in NLP (e.g. FoLiA/Giza/Moses/ARPA/Timbl/CQL). There are also clients to
  interface with various NLP specific servers. PyNLPl most notably features a
  very extensive library for working with FoLiA XML (Format for Linguistic
  Annotatation).
  The library is a divided into several packages and modules. It works on Python
  2.7, as well as Python 3.
  The following modules are available:
  - ``pynlpl.datatypes`` - Extra datatypes (priority queues, patterns, tries)
  - ``pynlpl.evaluation`` - Evaluation & experiment classes (parameter search, wrapped
    progressive sampling, class evaluation (precision/recall/f-score/auc), sampler, confusion matrix, multithreaded experiment pool)
  - ``pynlpl.formats.cgn`` - Module for parsing CGN (Corpus Gesproken Nederlands) part-of-speech tags
  - ``pynlpl.formats.folia`` - Extensive library for reading and manipulating the
    documents in `FoLiA <http://proycon.github.io/folia>`_ format (Format for Linguistic Annotation).
  - ``pynlpl.formats.fql`` - Extensive library for the FoLiA Query Language (FQL),
    built on top of ``pynlpl.formats.folia``. FQL is currently documented `here
    <https://github.com/proycon/foliadocserve>`__.
  - ``pynlpl.formats.cql`` - Parser for the Corpus Query Language (CQL), as also used by
    Corpus Workbench and Sketch Engine. Contains a convertor to FQL.
  - ``pynlpl.formats.giza`` - Module for reading GIZA++ word alignment data
  - ``pynlpl.formats.moses`` - Module for reading Moses phrase-translation tables.
  - ``pynlpl.formats.sonar`` - Largely obsolete module for pre-releases of the
    SoNaR corpus, use ``pynlpl.formats.folia`` instead.
  - ``pynlpl.formats.timbl`` - Module for reading Timbl output (consider using
    `python-timbl <https://github.com/proycon/python-timbl>`_ instead though)
  - ``pynlpl.lm.lm`` - Module for simple language model and reader for ARPA
    language model data as well (used by SRILM).
  - ``pynlpl.search`` - Various search algorithms (Breadth-first, depth-first,
    beam-search, hill climbing, A star, various variants of each)
  - ``pynlpl.statistics`` - Frequency lists, Levenshtein, common statistics and
    information theory functions
  - ``pynlpl.textprocessors`` - Simple tokeniser, n-gram extraction


pkgId: 06062aa6e406d0506e1fc04285969e89e9689ec72d62430c5ff8e944b1c68c0f
name: python-PyNaCl-debuginfo
arch: aarch64
version: 1.5.0
epoch: 0
release: 1
summary: Debug information for package python-PyNaCl
url: https://github.com/pyca/pynacl/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-8d0fdfa3-11ff-4d74-b9fd-a0e8cf818fe8
rpm_sourcerpm: python-PyNaCl-1.5.0-1.src.rpm
location_href: 00008983-python-pynacl/python-PyNaCl-debuginfo-1.5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-PyNaCl.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: ec71e3a9c655483b6457894f5e736ba7bf0496a3a34d2b4319f29639e24f0472
name: python-PyNaCl-debugsource
arch: aarch64
version: 1.5.0
epoch: 0
release: 1
summary: Debug sources for package python-PyNaCl
url: https://github.com/pyca/pynacl/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-8d0fdfa3-11ff-4d74-b9fd-a0e8cf818fe8
rpm_sourcerpm: python-PyNaCl-1.5.0-1.src.rpm
location_href: 00008983-python-pynacl/python-PyNaCl-debugsource-1.5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-PyNaCl.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 628a7208330f2c42b3d8586048a785ab059b7226938b113c24798e29f75bbf69
name: python-PyOpenGL
arch: src
version: 3.1.6
epoch: 0
release: 1
summary: Standard OpenGL bindings for Python
url: http://pyopengl.sourceforge.net
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0b992017-5846-4efe-b481-bfef87a100bf
location_href: 00004755-python-pyopengl/python-PyOpenGL-3.1.6-1.src.rpm
checksum_type: sha256
description:
  PyOpenGL is normally distributed via PyPI using standard pip::
      $ pip install PyOpenGL PyOpenGL_accelerate
  You can install this repository by branching/cloning and running
  setup.py::
      $ cd pyopengl
      $ python setup.py develop
      $ cd accelerate
      $ python setup.py develop
  Note that to compile PyOpenGL_accelerate you will need to have
  a functioning Python extension-compiling environment.


pkgId: 3c846fd156f00ad6585ca2d5dfa973b8413b19a3ecc0e46e1f2a593563d8e546
name: python-PyPDF4
arch: src
version: 1.27.0
epoch: 0
release: 1
summary: PDF toolkit
url: http://claird.github.com/PyPDF4
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d0538bb-01b5-4659-b98e-f15090878b1b
location_href: 00011093-python-pypdf4/python-PyPDF4-1.27.0-1.src.rpm
checksum_type: sha256
description:
  A Pure-Python library built as a PDF toolkit.  It is capable of:

  - extracting document information (title, author, ...)
  - splitting documents page by page
  - merging documents page by page
  - cropping pages
  - merging multiple pages into a single page
  - encrypting and decrypting PDF files
  - and more!

  By being Pure-Python, it should run on any Python platform without any
  dependencies on external libraries.  It can also work entirely on StringIO
  objects rather than file streams, allowing for PDF manipulation in memory.
  It is therefore a useful tool for websites that manage or manipulate PDFs.


pkgId: f342f9a6a216bde7ef4884f0989e94f294a453acf440f319bef4e0b3c37d09a4
name: python-PyQtChart
arch: src
version: 5.15.6
epoch: 0
release: 1
summary: Python bindings for the Qt Charts library
url: https://www.riverbankcomputing.com/software/pyqtchart/
rpm_license: GPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fbf0d17f-9b79-4423-8f74-81d9daad6777
location_href: 00004773-python-pyqtchart/python-PyQtChart-5.15.6-1.src.rpm
checksum_type: sha256
description:
  PyQtChart is a set of Python bindings for The Qt Company's Qt Charts library.
  The bindings sit on top of PyQt5 and are implemented as a single module.


pkgId: 421a66c8e1b3cc60f0f820f00fecdfba70583047c837b0b5599c580cfe325f32
name: python-PyRSS2Gen
arch: src
version: 1.1
epoch: 0
release: 1
summary: Generate RSS2 using a Python data structure
url: http://dalkescientific.com/Python/PyRSS2Gen.html
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-be0ec961-2d92-4663-9447-97dcf26842f6
location_href: 00002876-python-PyRSS2Gen/python-PyRSS2Gen-1.1-1.src.rpm
checksum_type: sha256
description:
  I've finally decided to catch up with 1999 and play around a bit with
  RSS.  I looked around, and while there are many ways to read RSS there
  are remarkably few which write them.  I could use a DOM or other
  construct, but I want the code to feel like Python.  There are more
  Pythonic APIs I might use, like the effbot's ElementTree, but I also
  wanted integers, dates, and lists to be real integers, dates, and
  lists.  (And I want bug-eyed monsters from Alpha Centauri to be *real*
  bug-eyed monsters from Alpha Centauri - is that too much I ask you?)
  The RSS generators I found were built around print statements.
  Workable, but they almost invariably left out proper HTML escaping the
  sort which leads to Mark Pilgrim's to write feed_parser, to make sense
  of documents which are neither XML nor HTML.  Annoying, but sadly all
  too common.
  So I messed around a bit with the spec from
   http://blogs.law.harvard.edu/tech/rss
  The result looks like this:
  import datetime
  import PyRSS2Gen
  rss = PyRSS2Gen.RSS2(
      title = "Andrew's PyRSS2Gen feed",
      link = "http://www.dalkescientific.com/Python/PyRSS2Gen.html",
      description = "The latest news about PyRSS2Gen, a "
                    "Python library for generating RSS2 feeds",
      lastBuildDate = datetime.datetime.now(),
      items = [
         PyRSS2Gen.RSSItem(
           title = "PyRSS2Gen-0.0 released",
           link = "http://www.dalkescientific.com/news/030906-PyRSS2Gen.html",
           description = "Dalke Scientific today announced PyRSS2Gen-0.0, "
                         "a library for generating RSS feeds for Python.  ",
           guid = PyRSS2Gen.Guid("http://www.dalkescientific.com/news/"
                            "030906-PyRSS2Gen.html"),
           pubDate = datetime.datetime(2003, 9, 6, 21, 31)),
         PyRSS2Gen.RSSItem(
           title = "Thoughts on RSS feeds for bioinformatics",
           link = "http://www.dalkescientific.com/writings/diary/"
                  "archive/2003/09/06/RSS.html",
           description = "One of the reasons I wrote PyRSS2Gen was to "
                         "experiment with RSS for data collection in "
                         "bioinformatics.  Last year I came across...",
           guid = PyRSS2Gen.Guid("http://www.dalkescientific.com/writings/"
                                 "diary/archive/2003/09/06/RSS.html"),
           pubDate = datetime.datetime(2003, 9, 6, 21, 49)),
      ])
  rss.write_xml(open("pyrss2gen.xml", "w"))
  The output does not contain newlines, so if you want to read it,
  you'll need to use your favorite XML tools to reformat it.
  RSS is not a fixed format.  People are free to add various metadata,
  like Dublin Core elements.
  The RSS objects are converted to XML using the 'publish' method, which
  takes a SAX2 ContentHandler.  If you want different output, implement
  your own 'publish'.  The "simple" data types which takes a string,
  int, or date, can be replaced with a publishable object, so you can
  add metadata to, say, the "description" field.  To support new
  elements for RSS and RSSItem, derive from them and use the
  'publish_extensions" hook.  To add your own attributes (needed for
  namespace declarations), redefine 'element_attrs' or 'rss_attrs' in
  your subclass.
  To use a different encoding, create your own ContentHandler instead of
  using the helper methods 'to_xml' and 'write_xml.'  You'll need to
  make sure the 'characters' method in the handler does the appropriate
  translation.
  The "categories" list is somewhat special.  It needs to be a list and
  doesn't have a publish method.  That's because the RSS spec doesn't
  have an explicit concept for the set of categories -- an RSS2 channel
  can have 0 or more 'category' elements, but doesn't have a "list of
  categories" -- my "categories" attribute is an API fiction.
  BUGS:
  Several people have used this package since its first release in
  September of 2003 and reported a couple of bugs.  All those are fixed.
  There are no known bugs.
  The name PyRSS2Gen is a mouthful.  It didn't think it was useful to
  come up with a cute name.  You might consider having
     import PyRSS2Gen as RSS2
  in any code which uses this module.  I'm not changing the name because
  anyone who reads "RSS2" will likely think it's a parser and not a
  generator.  Plus, the current name is very easy to find via a web
  search.
  LICENSE:
  This is copyright (c) by Andrew Dalke Scientific, AB (previously
  'Dalke Scientific Software, LLC') and released under the BSD
  license. See the file LICENSE in the distribution, or
    http://www.opensource.org/licenses/bsd-license.php
  for details.
  CHANGES for 1.1: Released August 25, 2012
    - Ported to Python 3.x. Thanks to Graham Bell for the initial patch.
  CHANGES for 1.0: Released November 6, 2005
    - Many people (Richard Chamberlain, Daniel Hsu, Leonart Richardson
    and Daniel Holth) pointed out that Guid sets "isPermaLink" (with a
    "L" not "l").  Fixed, and changed it so the isPermaLink RSS attribute
    is always either "true" or "false" instead of assuming empty means false.
    - Added patches from Erik de Jonge and MATSUNO Tokuhiro to set the
    output encoding.
    - Implemented a suggestion by Daniel Hoth to convert the enclosure
    length to a string.
  CHANGES for 0.1.1: Released in September 2003
    - retroactively renamed "0.0" to "0.1"
    - fixed bug in Image height.  Patch thanks to Edward Dale.


pkgId: 61f72f38ee0e7c9ce888a03561de80057a33b3d5b65c78704bd3ac078e961fcc
name: python-PyScaffold
arch: src
version: 4.4
epoch: 0
release: 1
summary: Template tool for putting up the scaffold of a Python project
url: https://github.com/pyscaffold/pyscaffold/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-509e027a-042e-484e-852f-c637de27cffb
location_href: 00004790-python-pyscaffold/python-PyScaffold-4.4-1.src.rpm
checksum_type: sha256
description:
  Just pick your favourite installation method::
      
      
      pip install pyscaffold
      
      conda install -c conda-forge pyscaffold
      
      pipx install pyscaffold
  If you want to install all PyScaffold's *extensions* you can even::
      pip install pyscaffold[all]
  (More details of each method are available in the `installation docs`_)
  After the installation, a new ``putup`` command will be available and you can just type::
      putup my_project
  This will create a new folder called ``my_project`` containing a perfect *project
  template* with everything you need for some serious coding.
  After ``cd``-ing into your new project and creating (or activating) an `isolated
  development environment`_ (with virtualenv_, conda_ or your preferred tool),
  you can do the usual `editable install`_::
      pip install -e .
  … all set and ready to go!
  We also recommend using tox_, so you can take advantage of the automation tasks
  we have setup for you, like::
     tox -e build  # to build your package distribution
     tox -e publish  # to test your project uploads correctly in test.pypi.org
     tox -e publish -- --repository pypi  # to release your package to PyPI
     tox -av  # to list all the tasks available
  The following figure demonstrates the usage of ``putup`` with the new experimental
  interactive mode for setting up a simple project.
  It uses the `--cirrus` flag to add CI support (via `Cirrus CI`_), and
  tox_ to run automated project tasks like building a package file for
  distribution (or publishing).
  Type ``putup -h`` to learn about more configuration options. PyScaffold assumes
  that you have Git_ installed and set up on your PC,
  meaning at least your name and email are configured.
  The project template provides you with following features:


pkgId: a2aeeace2e289029c3b8d86e36d245bcebea9ad19f6004a55d121305eac33e39
name: python-PySimpleGUI
arch: src
version: 4.60.4
epoch: 0
release: 1
url: https://github.com/PySimpleGUI/PySimpleGUI
rpm_license: GNU Lesser General Public License v3 or later (LGPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-675746d9-c4fe-4c7c-9150-cbae3d44e2c2
location_href: 00011788-python-pysimplegui/python-PySimpleGUI-4.60.4-1.src.rpm
checksum_type: sha256
summary:
  Python GUIs for Humans. Launched in 2018. It's 2022 & PySimpleGUI is an ACTIVE & supported project. Super-simple to create custom GUI's. 325+ Demo programs & Cookbook for rapid start. Extensive documentation. Main docs at www.PySimpleGUI.org. Fun & your success are the focus. Examples using Machine Learning (GUI, OpenCV Integration), Rainmeter Style Desktop Widgets, Matplotlib + Pyplot, PIL support, add GUI to command line scripts, PDF & Image Viewers. Great for beginners & advanced GUI programmers.

description:
  |  Issues | Commit Activity | Stars | Docs |
  | -- | -- | -- | -- |
  | ![GitHub issues](https://img.shields.io/github/issues-raw/PySimpleGUI/PySimpleGUI?color=blue)  | ![commit activity](https://img.shields.io/github/commit-activity/m/PySimpleGUI/PySimpleGUI.svg?color=blue) | ![stars](https://img.shields.io/github/stars/PySimpleGUI/PySimpleGUI.svg?label=stars&maxAge=2592000) | ![Documentation Status](https://readthedocs.org/projects/pysimplegui/badge/?version=latest) |
  |  ![GitHub closed issues](https://img.shields.io/github/issues-closed-raw/PySimpleGUI/PySimpleGUI?color=blue) | ![last commit](https://img.shields.io/github/last-commit/PySimpleGUI/PySimpleGUI.svg?color=blue)  |  |
  <p align="center">
    <img src="https://github-readme-stats.vercel.app/api/?username=PySimpleGUI&bg_color=3e7bac&title_color=ffdd55&icon_color=ffdd55&text_color=ffdd55&show_icons=true&count_private=true">
  </p>
  <hr>

  PySimpleGUI is a Python package that enables Python programmers of all levels to create GUIs.  You specify your GUI window using a "layout" which contains widgets (they're called "Elements" in PySimpleGUI).  Your layout is used to create a window using one of the 4 supported frameworks to display and interact with your window.  Supported frameworks include tkinter, Qt, WxPython, or Remi. The term "wrapper" is sometimes used for these kinds of packages.
  Your PySimpleGUI code is simpler and shorter than writing directly using the underlying framework because PySimpleGUI implements much of the "boilerplate code" for you.  Additionally, interfaces are simplified to require as little code as possible to get the desired result.  Depending on the program and framework used, a PySimpleGUI program may require 1/2 to 1/10th amount of code to create an identical window using one of the frameworks directly.
  While the goal is to encapsulate/hide the specific objects and code used by the GUI framework you are running on top of, if needed you can access the frameworks' dependent widgets and windows directly. If a setting or feature is not yet exposed or accessible using the PySimpleGUI APIs, you are not walled off from the framework. You can expand capabilities without directly modifying the PySimpleGUI package itself.

  Python has brought a large number of people into the programming community. The number of programs and the range of areas it touches is mindboggling.  But more often than not, these technologies are out of reach of all but a handful of people.  The majority of Python programs are "command line" based. This isn't a problem for programmer-types as we're all used to interacting with computers through a text interface.  While programmers don't have a problem with command-line interfaces, most "normal people" do.  This creates a digital divide, a "GUI Gap".
  Adding a GUI to a program opens that program up to a wider audience. It becomes more approachable. GUIs can also make interacting with some programs easier, even for those that are comfortable with a command-line interface.  And finally, some problems require a GUI.
  <p align="center">
    <img src="https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/images/for_readme/GUI%20Gap%202020.png" width="600px">
  </p>

  In the Demo Programs or one of the PySimpleGUI Account's Repos these packages were used at least one time. Some of your are the goodies on the right of the GUI gap.
   If you use Open Source software in your project, be sure and supply information about the packages you used.
  - chatterbot
  - cv2
  - fitz
  - forecastio
  - gtts
  - matplotlib
  - mido
  - mpl_toolkits
  - notifypy
  - numpy
  - pandas
  - PIL
  - praw
  - psgtray
  - psutil
  - pyfiglet
  - pygame
  - pylab
  - pymunk
  - requests
  - vlc
  - win32api
  - win32con
  - win32gui
  - win32process

  The licensing terms in the LLC3 Licensing, it states:
  >   4. Combined Works.
  > You may convey a Combined Work under terms of your choice that,
  > taken together, effectively do not restrict modification of the
  > portions of the Library contained in the Combined Work and reverse
  > engineering for debugging such modifications, if you also do each of
  > the following:
  >
  >    a) Give prominent notice with each copy of the Combined Work that
  >    the Library is used in it and that the Library and its use are
  >    covered by this License.
  >
  >    b) Accompany the Combined Work with a copy of the GNU GPL and this license
  >    document.
  Since the above packages each have a similar license clause, I'm listing them here, in what I would consider a "prominent notice" location, that I'm using the fine works of these groups or individuals.  They are used in the Demo Programs most likely or one of the Repos that are under this account as this list is all inclusive.
  You all have my respect and admiration.  You're enabling bigger things. What a special kind of thing to make. Who knows what you've enabled. I believe more people are getting over to your creations and getting to experience them.
  tkinter team - PySimpleGUI would be nowhere without your lengthy work & continuous dedication. ONE GUI API for 3 different OS's? Really? With no code changes to move between? That's a huge accomplishment. You're #1 to me.  Thank you for your hard work.

  It's been said by some that "the bar is pretty high" when it comes to learning GUI programming in Python.
  >	 What happens when the bar is placed on the ground and can be stepped over?
  This is one of the questions that the PySimpleGUI project has tried to answer.  Here's a humorous look at what's been a not funny situation.
  <p align="center">
    <img src="https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/images/for_readme/GettingOverThe%20GUILearningBar.jpg" width="600px">
  </p>
  The results have been fascinating to witness and it's been touching to read the accounts of the journeys of users.
  Nothing prepared me for the emails that started to arrive soon after the first release of PySimpleGUI. They are heartwarming and heartbreaking tales of life-long dreams of creating a program that required a GUI. Some made a few attempts, giving up each time. Others never started once they started to research what was required.
  After recounting the varied and long road to finding PySimpleGUI, the stories became similar. They each found success and expressed joy and gratitude. The joy expressed in these messages was unlike anything I had encountered in the entirety of career in the computing field.
  It's been these emails and the messages of gratitude seen here in the GitHub Issues that made dedicating my life to his project a non-decision.
  <hr>

  If you click the "Subscribe" button in [the Announcements GitHub Issue](https://github.com/PySimpleGUI/PySimpleGUI/issues/142), then you'll be notified when project news is published.  This Issue is **the official location** to get the latest PySimpleGUI information.  Information is posted frequently including release contents, tips & tricks, documentation updates, etc. There have been over 1,000 posts since the project started.
  <hr>

  Hi there!  I'm Mike.  You'll find me right here, on the PySimpleGUI GitHub, solving problems and continuously pushing PySimpleGUI forward.  I've dedicated my days, nights, and weekends to the project and PySimpleGUI users.  Our successes are ultimately shared.  I'm successful when you're successful.
  While I'm a relative newcomer to Python, I've been writing software since the 70s.  The majority of my career was spent creating products in Silicon Valley. I bring to PySimpleGUI the same professionalism and dedication as I did to the corporate products I developed. You are my customers now.

  Two of the most important goals of the PySimpleGUI project:
  * Having fun
  * Your success
  **Fun** as a goal on a serious project sounds odd, but it's a serious goal. I find writing these GUI programs to be a lot of fun. One reason is how little time it takes to write a complete solution. If we're not enjoying the process then someone's going to give up.
  There is a significant amount of documentation, a cookbook, 100's of demo programs to get you immediately running, a detailed call reference, YouTube videos, online Trinket demos, and more... all working to create... a fun experience.
  **Your Success** is a shared goal.  PySimpleGUI was built for developers. You're my peeps. It's been an unexpected reward to see the results of the combined effort of users and PySimpleGUI. Use the documentation & other materials to help build your application.  If you run into trouble, help is available by opening on [Issue on the PySimpleGUI GitHub](http://Issues.PySimpleGUI.org).  Take a look at the section on Support below.
  <hr>

  PySimpleGUI now has an official Udemy course!  Check the header of this readme and the PySimpleGUI documentation for a coupon code.  The course can be found at [www.udemy.com/PySimpleGUI](https://www.udemy.com/PySimpleGUI).  **This course** is currently the only income source for the PySimpleGUI project other than sponsorships and donations.
  [www.PySimpleGUI.org](http://www.PySimpleGUI.org)
  is easy to remember and is where the documentation is located. You'll find tabs across the top that represent several different documents. The documentation is located on "Read The Docs" so that there is a table of contents for each document and they are easy to search.
  There are 100s of pages of written documentation and 100s of example programs that will help you be effective very quickly.  Rather than requiring days or weeks of investment to learn a single GUI package, you may be able to complete your project in a single afternoon when using PySimpleGUI.

  This type of program is called a "one-shot" window because the window is displayed one time, the values collected, and then it is closed.  It doesn't remain open for a long time like you would in a Word Processor.

  There are 5 sections to a PySimpleGUI program
  ```python
  import PySimpleGUI as sg                        # Part 1 - The import

  layout = [  [sg.Text("What's your name?")],     # Part 2 - The Layout
              [sg.Input()],
              [sg.Button('Ok')] ]

  window = sg.Window('Window Title', layout)      # Part 3 - Window Defintion

  event, values = window.read()                   # Part 4 - Event loop or Window.read call

  print('Hello', values[0], "! Thanks for trying PySimpleGUI")

  window.close()                                  # Part 5 - Close the Window
  ```
  The code produces this window
  <p align="center">
    <img src="https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/images/for_readme/ex1-tkinter.jpg">
  </p>
  <hr>

  In this example, our window will remain on the screen until the user closes the window or clicks the Quit button.  The main difference between the one-shot window you saw earlier and an interactive window is the addition of an "Event Loop". The Event Loop reads events and inputs from your window.  The heart of your application lives in the event loop.
  ```python
  import PySimpleGUI as sg

  layout = [[sg.Text("What's your name?")],
            [sg.Input(key='-INPUT-')],
            [sg.Text(size=(40,1), key='-OUTPUT-')],
            [sg.Button('Ok'), sg.Button('Quit')]]

  window = sg.Window('Window Title', layout)

  while True:
      event, values = window.read()
      
      if event == sg.WINDOW_CLOSED or event == 'Quit':
          break
      
      window['-OUTPUT-'].update('Hello ' + values['-INPUT-'] + "! Thanks for trying PySimpleGUI")

  window.close()
  ```
  This is the window that Example 2 produces.
  <p align="center">
    <img src="https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/images/for_readme/Example2-1.jpg">
  </p>
  And here's what it looks like after you enter a value into the Input field and click the Ok button.
  <p align="center">
    <img src="https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/images/for_readme/Example2-2.jpg">
  </p>
  Let's take a quick look at some of the differences between this example and the one-shot window.
  First, you'll notice differences in the layout.  Two changes in particular are important.  One is the addition of the `key` parameter to the `Input` element and one of the `Text` elements.  A `key` is like a name for an element.  Or, in Python terms, it's like a dictionary key.  The `Input` element's key will be used as a dictionary key later in the code.
  Another difference is the addition of this `Text` element:
  ```python
            [sg.Text(size=(40,1), key='-OUTPUT-')],
  ```
  There are 2 parameters, the `key` we already covered.  The `size` parameter defines the size of the element in characters.  In this case, we're indicating that this `Text` element is 40 characters wide, by 1 character high.  Notice that there is no text string specified which means it'll be blank.  You can easily see this blank row in the window that's created.
  We also added a button,  "Quit".
  The Event Loop has our familiar `window.read()` call.
  Following the read is this if statement:
  ```python
      if event == sg.WINDOW_CLOSED or event == 'Quit':
          break
  ```
  This code is checking to see if the user closed the window by clicking the "X" or if they clicked the "Quit" button.  If either of these happens, then the code will break out of the event loop.
  If the window wasn't closed nor the Quit button clicked, then execution continues.  The only thing that could have happened is the user clicked the "Ok" button.  The last statement in the Event Loop is this one:
  ```python
      window['-OUTPUT-'].update('Hello ' + values['-INPUT-'] + "! Thanks for trying PySimpleGUI")
  ```
  This statement updates the `Text` element that has the key `-OUTPUT-` with a string.  `window['-OUTPUT-']` finds the element with the key `-OUTPUT-`.  That key belongs to our blank `Text` element.  Once that element is returned from the lookup, then its `update` method is called.  Nearly all elements have an `update` method.  This method is used to change the value of the element or to change some configuration of the element.
  If we wanted the text to be yellow, then that can be accomplished by adding a `text_color` parameter to the `update` method so that it reads:
  ```python
      window['-OUTPUT-'].update('Hello ' + values['-INPUT-'] + "! Thanks for trying PySimpleGUI",
                                text_color='yellow')
  ```
  After adding the `text_color` parameter, this is our new resulting window:
  <p align="center">
    <img src="https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/images/for_readme/Example2-3.jpg">
  </p>
  The parameters available for each element are documented in both the [call reference documentation](http://calls.PySimpleGUI.org) as well as the docstrings.  PySimpleGUI has extensive documentation to help you understand all of the options available to you. If you lookup the `update` method for the `Text` element, you'll find this definition for the call:
  <p align="center">
    <img src="https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/images/for_readme/TextUpdate.jpg">
  </p>
  As you can see several things can be changed for a `Text` element.  The call reference documentation is a valuable resource that will make programming in PySimpleGUI, uhm, simple.
  <hr>

  The over 300 Demo Programs will give you a jump-start and provide many design patterns for you to learn how to use PySimpleGUI and how to integrate PySimpleGUI with other packages.  By far the best way to experience these demos is using the Demo Browser.  This tool enables you to search, edit and run the Demo Programs.
  To get them installed quickly along with the Demo Browser, use `pip` to install `psgdemos`:
  `python -m pip install psgdemos`
  or if you're in Linux, Mac, etc, that uses `python3` instead of `python` to launch Python:
  `python3 -m pip install psgdemos`
  Once installed, launch the demo browser by typing `psgdemos` from the command line"
  `psgdemos`


pkgId: 22db16650cd54becf560897977e3b4cb584cb2debdb18866f5671606ab192d9a
name: python-PySimpleSOAP
arch: src
version: 1.16.2
epoch: 0
release: 1
summary: Python simple and lightweight SOAP Library (master branch)
url: https://github.com/pysimplesoap/pysimplesoap
rpm_license: LGPL 3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-79f963c6-b45b-4f5d-9b54-b6d523764679
location_href: 00004804-python-pysimplesoap/python-PySimpleSOAP-1.16.2-1.src.rpm
checksum_type: sha256
description:
  Python simple and lightweight SOAP library for client and server
  webservices interfaces, aimed to be as small and easy as possible,
  supporting most common functionality. Initially it was inspired by `PHP
  Soap Extension <http://php.net/manual/en/book.soap.php>`__ (mimicking
  its functionality, simplicity and ease of use), with many advanced
  features added.
  **Supports Python 3** (same codebase, no need to run 2to3)


pkgId: b0985ddea81d2ac8e7131bc4f5393416ce4b5a4f4da4fd671ccf55856ea99824
name: python-PySnooper
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A poor man's debugger for Python.
url: https://github.com/cool-RR/PySnooper
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-efa00ada-1aa3-48da-b903-112188f74b9c
location_href: 00004809-python-pysnooper/python-PySnooper-1.1.1-1.src.rpm
checksum_type: sha256
description:
  **PySnooper** is a poor man's debugger. If you've used Bash, it's like `set -x` for Python, except it's fancier.

  Your story: You're trying to figure out why your Python code isn't doing what you think it should be doing. You'd love to use a full-fledged debugger with breakpoints and watches, but you can't be bothered to set one up right now.

  You want to know which lines are running and which aren't, and what the values of the local variables are.

  Most people would use `print` lines, in strategic locations, some of them showing the values of variables.

  **PySnooper** lets you do the same, except instead of carefully crafting the right `print` lines, you just add one decorator line to the function you're interested in. You'll get a play-by-play log of your function, including which lines ran and   when, and exactly when local variables were changed.

  What makes **PySnooper** stand out from all other code intelligence tools? You can use it in your shitty, sprawling enterprise codebase without having to do any setup. Just slap the decorator on, as shown below, and redirect the output to a dedicated log file by specifying its path as the first argument.



  We're writing a function that converts a number to binary, by returning a list of bits. Let's snoop on it by adding the `@pysnooper.snoop()` decorator:

  ```python
  import pysnooper

  @pysnooper.snoop()
  def number_to_bits(number):
      if number:
          bits = []
          while number:
              number, remainder = divmod(number, 2)
              bits.insert(0, remainder)
          return bits
      else:
          return [0]

  number_to_bits(6)
  ```
  The output to stderr is:

  ![](https://i.imgur.com/TrF3VVj.jpg)

  Or if you don't want to trace an entire function, you can wrap the relevant part in a `with` block:

  ```python
  import pysnooper
  import random

  def foo():
      lst = []
      for i in range(10):
          lst.append(random.randrange(1, 1000))

      with pysnooper.snoop():
          lower = min(lst)
          upper = max(lst)
          mid = (lower + upper) / 2
          print(lower, mid, upper)

  foo()
  ```

  which outputs something like:

  ```
  New var:....... i = 9
  New var:....... lst = [681, 267, 74, 832, 284, 678, ...]
  09:37:35.881721 line        10         lower = min(lst)
  New var:....... lower = 74
  09:37:35.882137 line        11         upper = max(lst)
  New var:....... upper = 832
  09:37:35.882304 line        12         mid = (lower + upper) / 2
  74 453.0 832
  New var:....... mid = 453.0
  09:37:35.882486 line        13         print(lower, mid, upper)
  Elapsed time: 00:00:00.000344
  ```



  If stderr is not easily accessible for you, you can redirect the output to a file:

  ```python
  @pysnooper.snoop('/my/log/file.log')
  ```

  You can also pass a stream or a callable instead, and they'll be used.

  See values of some expressions that aren't local variables:

  ```python
  @pysnooper.snoop(watch=('foo.bar', 'self.x["whatever"]'))
  ```

  Show snoop lines for functions that your function calls:

  ```python
  @pysnooper.snoop(depth=2)
  ```

  **See [Advanced Usage](https://github.com/cool-RR/PySnooper/blob/master/ADVANCED_USAGE.md) for more options.** <------




  The best way to install **PySnooper** is with Pip:

  ```console
  $ pip install pysnooper
  ```



  Conda with conda-forge channel:

  ```console
  $ conda install -c conda-forge pysnooper
  ```

  Arch Linux:

  ```console
  $ yay -S python-pysnooper
  ```

  Fedora Linux:

  ```console
  $ dnf install python3-pysnooper
  ```



  Copyright (c) 2019 Ram Rachum and collaborators, released under the MIT license.




  [Hacker News thread](https://news.ycombinator.com/item?id=19717786)
  and [/r/Python Reddit thread](https://www.reddit.com/r/Python/comments/bg0ida/pysnooper_never_use_print_for_debugging_again/) (22 April 2019)


pkgId: 958b01eb736be21453538df2b841022d79cc1c4e6d07f86bacc2b6261bc48221
name: python-PySocks
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: A Python SOCKS client module. See https://github.com/Anorov/PySocks for more information.
url: https://github.com/Anorov/PySocks
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d0d40006-a9f4-4793-b244-3b131ddf7a06
location_href: 00009328-python-pysocks/python-PySocks-1.7.1-1.src.rpm
checksum_type: sha256
description:
  PySocks lets you send traffic through SOCKS and HTTP proxy servers. It is a modern fork of [SocksiPy](http://socksipy.sourceforge.net/) with bug fixes and extra features.


pkgId: d392efb6f8a37f8b92a6a156b1bfad6e2475d9ab39fe0da1dfdc94f195d0bdf3
name: python-PyTrie
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A pure Python implementation of the trie data structure.
url: https://github.com/gsakkis/pytrie/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d99516e1-ee93-4953-bac3-a3bbd5ebd974
location_href: 00012806-python-pytrie/python-PyTrie-0.4.0-1.src.rpm
checksum_type: sha256
description:
  `pytrie` is a a pure Python 3 implementation of the trie data structure.

  A _trie_ is an ordered tree data structure that is used to store a mapping
  where the keys are sequences, usually strings over an alphabet. In addition to
  implementing the mapping interface, tries allow finding the items for a given
  prefix, and vice versa, finding the items whose keys are prefixes of a given key.

  To install run:

      pip install pytrie

  Documentation is available at [Read the Docs](https://pytrie.readthedocs.io/).





  * Drop Python 2 support



  * Fixed iteritems/itervalues for SortedDicts in Python 2.7.



  * Fixed bug for tries with zero-length keys.
  * Added `__bool__` (`__nonzero__`) and `__cmp__` methods to `Trie`.
  * Added `sortedcontainers` dependency.
  * Linting.
  * Converted from Mercurial to Git.



  * Initial Python 3 support (thanks Dmitrijs Milajevs)



  * Initial release


pkgId: 5acffe03507bc92f31694458562aad985b5653d20c7e36dbbb65cf8183ba3ab3
name: python-PyTurboJPEG
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: A Python wrapper of libjpeg-turbo for decoding and encoding JPEG image.
url: https://github.com/lilohuang/PyTurboJPEG
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-214f862c-0546-4456-abb2-2e62246bc96d
location_href: 00011238-python-pyturbojpeg/python-PyTurboJPEG-1.7.0-1.src.rpm
checksum_type: sha256
description:
  A Python wrapper of libjpeg-turbo for decoding and encoding JPEG image.


  - [libjpeg-turbo](https://github.com/libjpeg-turbo/libjpeg-turbo/releases)
  - [numpy](https://github.com/numpy/numpy)



  ```python
  import cv2
  from turbojpeg import TurboJPEG, TJPF_GRAY, TJSAMP_GRAY, TJFLAG_PROGRESSIVE, TJFLAG_FASTUPSAMPLE, TJFLAG_FASTDCT







  jpeg = TurboJPEG()


  in_file = open('input.jpg', 'rb')
  bgr_array = jpeg.decode(in_file.read())
  in_file.close()
  cv2.imshow('bgr_array', bgr_array)
  cv2.waitKey(0)


  in_file = open('input.jpg', 'rb')
  bgr_array = jpeg.decode(in_file.read(), flags=TJFLAG_FASTUPSAMPLE|TJFLAG_FASTDCT)
  in_file.close()
  cv2.imshow('bgr_array', bgr_array)
  cv2.waitKey(0)


  in_file = open('input.jpg', 'rb')
  bgr_array_half = jpeg.decode(in_file.read(), scaling_factor=(1, 2))
  in_file.close()
  cv2.imshow('bgr_array_half', bgr_array_half)
  cv2.waitKey(0)


  scaling_factors = jpeg.scaling_factors


  in_file = open('input.jpg', 'rb')
  width, height, jpeg_subsample, jpeg_colorspace = jpeg.decode_header(in_file.read())
  in_file.close()


  in_file = open('input.jpg', 'rb')
  buffer_array, plane_sizes = jpeg.decode_to_yuv(in_file.read())
  in_file.close()


  in_file = open('input.jpg', 'rb')
  planes = jpeg.decode_to_yuv_planes(in_file.read())
  in_file.close()


  out_file = open('output.jpg', 'wb')
  out_file.write(jpeg.encode(bgr_array))
  out_file.close()


  out_file = open('output_gray.jpg', 'wb')
  out_file.write(jpeg.encode(bgr_array, jpeg_subsample=TJSAMP_GRAY))
  out_file.close()


  out_file = open('output_quality_50.jpg', 'wb')
  out_file.write(jpeg.encode(bgr_array, quality=50))
  out_file.close()


  out_file = open('output_quality_100_progressive.jpg', 'wb')
  out_file.write(jpeg.encode(bgr_array, quality=100, flags=TJFLAG_PROGRESSIVE))
  out_file.close()


  in_file = open('input.jpg', 'rb')
  gray_array = jpeg.decode(in_file.read(), pixel_format=TJPF_GRAY)
  in_file.close()
  cv2.imshow('gray_array', gray_array)
  cv2.waitKey(0)


  in_file = open('input.jpg', 'rb')
  out_file = open('scaled_output.jpg', 'wb')
  out_file.write(jpeg.scale_with_quality(in_file.read(), scaling_factor=(1, 4), quality=70))
  out_file.close()
  in_file.close()


  out_file = open('lossless_cropped_output.jpg', 'wb')
  out_file.write(jpeg.crop(open('input.jpg', 'rb').read(), 8, 8, 320, 240))
  out_file.close()
  ```

  ```python





  import cv2
  import numpy as np
  import exifread
  from turbojpeg import TurboJPEG

  def transposeImage(image, orientation):
      """See Orientation in https://www.exif.org/Exif2-2.PDF for details."""
      if orientation == None: return image
      val = orientation.values[0]
      if val == 1: return image
      elif val == 2: return np.fliplr(image)
      elif val == 3: return np.rot90(image, 2)
      elif val == 4: return np.flipud(image)
      elif val == 5: return np.rot90(np.flipud(image), -1)
      elif val == 6: return np.rot90(image, -1)
      elif val == 7: return np.rot90(np.flipud(image))
      elif val == 8: return np.rot90(image)


  turbo_jpeg = TurboJPEG()

  in_file = open('foobar.jpg', 'rb')

  orientation = exifread.process_file(in_file).get('Image Orientation', None)

  in_file.seek(0)

  image = turbo_jpeg.decode(in_file.read())

  transposed_image = transposeImage(image, orientation)

  in_file.close()

  cv2.imshow('transposed_image', transposed_image)
  cv2.waitKey(0)
  ```




  - brew install jpeg-turbo
  - pip install -U git+https://github.com/lilohuang/PyTurboJPEG.git


  - Download [libjpeg-turbo official installer](https://sourceforge.net/projects/libjpeg-turbo/files)
  - pip install -U git+https://github.com/lilohuang/PyTurboJPEG.git


  - RHEL/CentOS/Fedora
    - Download [libjpeg-turbo.repo](https://libjpeg-turbo.org/pmwiki/uploads/Downloads/libjpeg-turbo.repo) to /etc/yum.repos.d/
    - sudo yum install libjpeg-turbo-official
    - pip install -U git+https://github.com/lilohuang/PyTurboJPEG.git

  - Ubuntu
    - sudo apt-get update
    - sudo apt-get install libturbojpeg
    - pip install -U git+https://github.com/lilohuang/PyTurboJPEG.git




  - macOS Sierra 10.12.6
  - Intel(R) Core(TM) i5-3210M CPU @ 2.50GHz
  - opencv-python 3.4.0.12 (pre-built)
  - turbo-jpeg 1.5.3 (pre-built)

  | Function              | Wall-clock time |
  | ----------------------|-----------------|
  | cv2.imdecode()        |   0.528 sec     |
  | TurboJPEG.decode()    |   0.191 sec     |
  | cv2.imencode()        |   0.875 sec     |
  | TurboJPEG.encode()    |   0.176 sec     |


  - Windows 7 Ultimate 64-bit
  - Intel(R) Xeon(R) E3-1276 v3 CPU @ 3.60 GHz
  - opencv-python 3.4.0.12 (pre-built)
  - turbo-jpeg 1.5.3 (pre-built)

  | Function              | Wall-clock time |
  | ----------------------|-----------------|
  | cv2.imdecode()        |   0.358 sec     |
  | TurboJPEG.decode()    |   0.135 sec     |
  | cv2.imencode()        |   0.581 sec     |
  | TurboJPEG.encode()    |   0.140 sec     |


pkgId: aade87e0dba43429fc560d169b6d9037f17e0739999c4f29650c6db2c8806e61
name: python-PyVISA
arch: src
version: 1.13.0
epoch: 0
release: 1
summary: Python VISA bindings for GPIB, RS232, TCPIP and USB instruments
url: https://pypi.org/project/PyVISA/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2496a061-2cd2-49ae-b686-920fc8177edf
location_href: 00012466-python-pyvisa/python-PyVISA-1.13.0-1.src.rpm
checksum_type: sha256
description:
  A Python package for support of the "Virtual Instrument Software
  Architecture" (VISA), in order to control measurement devices and
  test equipment via GPIB, RS232, Ethernet or USB.

rpm_license:
  The MIT License  Copyright (c) 2005-2022 PyVISA Authors and contributors. See AUTHORS  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 496ae2bb8dc91f8767bf760fba8480bec3cf9316adacc935df4490732e797f5b
name: python-PyVISA-py
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: Pure Python implementation of a VISA library.
url: https://pypi.org/project/PyVISA-py/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4080de6a-2224-42e4-9492-55a28c083327
location_href: 00014186-python-pyvisa-py/python-PyVISA-py-0.6.3-1.src.rpm
checksum_type: sha256
description:
  A PyVISA backend that implements a large part of the "Virtual Instrument Software
  Architecture" (VISA_) in pure Python (with the help of some nice cross platform
  libraries python packages!).

rpm_license:
  The MIT License  Copyright (c) 2014 PyVISA-py Authors and contributors. See AUTHORS  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: ef8ca66f5593217fa1efb609d885bfa915be0795d8c5e143a30ba9471ef4910e
name: python-PyWebDAV
arch: src
version: 0.9.8
epoch: 0
release: 1
summary: WebDAV library including a standalone server for python
url: http://code.google.com/p/pywebdav/
rpm_license: GPL v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e33856d3-f714-4ed2-8a4c-fd3803801b6c
location_href: 00004888-python-pywebdav/python-PyWebDAV-0.9.8-1.src.rpm
checksum_type: sha256
description:
  After installation of this package you will have a new script in you
  $PYTHON/bin directory called *davserver*. This serves as the main entry point
  to the server.


pkgId: 9f462c24bdc6f6cffaf9e7febad9f586b72ceda1a673b823fe4c8893a630fb7d
name: python-PyXB
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: Python XML Schema Bindings
url: http://pyxb.sourceforge.net
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cab3ece5-9f30-45a4-99a8-fdc8549c4ca5
location_href: 00013426-python-pyxb/python-PyXB-1.2.6-1.src.rpm
checksum_type: sha256
description:
  PyXB is a pure `Python <http://www.python.org>`_ package that generates
  Python code for classes that correspond to data structures defined by
  `XMLSchema <http://www.w3.org/XML/Schema>`_.  In concept it is similar to
  `JAXB <http://en.wikipedia.org/wiki/JAXB>`_ for Java and `CodeSynthesis XSD
  <http://www.codesynthesis.com/products/xsd/>`_ for C++.

  The major goals of PyXB are:

  * Provide a generated Python interface that is "Pythonic", meaning similar
    to one that would have been hand-written:

    + Attributes and elements are Python properties, with name conflicts
      resolved in favor of elements
    + Elements with maxOccurs larger than 1 are stored as Python lists
    + Bindings for type extensions inherit from the binding for the base type
    + Enumeration constraints are exposed as class (constant) variables

  * Support bi-directional conversion (document to Python and back)

  * Allow easy customization of the generated bindings to provide
    functionality along with content

  * Support all XMLSchema features that are in common use, including:

    + complex content models (nested all/choice/sequence)
    + cross-namespace dependencies
    + include and import directives
    + constraints on simple types


pkgId: 5905b86dea828ddd3aaf168b69aeba1b3b0e77982543752b9019c191b06fb22a
name: python-PyYAML
arch: src
version: 6.0
epoch: 0
release: 1
summary: YAML parser and emitter for Python
url: https://pyyaml.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c3354706-2fb3-4d72-af92-15ee110970eb
location_href: 00008883-python-pyyaml/python-PyYAML-6.0-1.src.rpm
checksum_type: sha256
description:
  YAML is a data serialization format designed for human readability
  and interaction with scripting languages.  PyYAML is a YAML parser
  and emitter for Python.

  PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
  support, capable extension API, and sensible error messages.  PyYAML
  supports standard YAML tags and provides Python-specific tags that
  allow to represent an arbitrary Python object.

  PyYAML is applicable for a broad range of tasks from complex
  configuration files to object serialization and persistence.


pkgId: 2bfb114f893088c8ff33404eccd7b7037fd618eeade4340414544241582f49c6
name: python-PyYAML-debuginfo
arch: aarch64
version: 6.0
epoch: 0
release: 1
summary: Debug information for package python-PyYAML
url: https://pyyaml.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-c3354706-2fb3-4d72-af92-15ee110970eb
rpm_sourcerpm: python-PyYAML-6.0-1.src.rpm
location_href: 00008883-python-pyyaml/python-PyYAML-debuginfo-6.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-PyYAML.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 874bde5237e16a5bf959485c0eaeee903ce5ead2d95c46d8797394a5c2d7f7ce
name: python-PyYAML-debugsource
arch: aarch64
version: 6.0
epoch: 0
release: 1
summary: Debug sources for package python-PyYAML
url: https://pyyaml.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-c3354706-2fb3-4d72-af92-15ee110970eb
rpm_sourcerpm: python-PyYAML-6.0-1.src.rpm
location_href: 00008883-python-pyyaml/python-PyYAML-debugsource-6.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-PyYAML.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 70db69d9f916f74657554befd7c8fa5a0f98a2247cf7df08ff8fc09e3e9ba83a
name: python-Pympler
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A development tool to measure, monitor and analyze the memory behavior of Python objects.
url: https://github.com/pympler/pympler
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94c5c8e0-7d63-4776-a89b-ed45dbfba80e
location_href: 00002878-python-Pympler/python-Pympler-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Pympler is a development tool to measure, monitor and analyze the memory
  behavior of Python objects in a running Python application.
  By pympling a Python application, detailed insight in the size and the lifetime
  of Python objects can be obtained.  Undesirable or unexpected runtime behavior
  like memory bloat and other "pymples" can easily be identified.
  Pympler integrates three previously separate projects into a single,
  comprehensive profiling tool. Asizeof provides basic size information for one
  or several Python objects, muppy is used for on-line monitoring of a Python
  application and the class tracker provides off-line analysis of the lifetime of
  selected Python objects. A web profiling frontend exposes process statistics,
  garbage visualisation and class tracker statistics.
  Pympler is written entirely in Python, with no dependencies to external
  libraries. It has been tested with Python 3.6, 3.7, 3.8, 3.9, 3.10 on Linux,
  Windows and MacOS X.


pkgId: 56a5e575efce2e12b43bdb08e30b87fbd0698b46cdbbcb7c2782b33deb6f63fc
name: python-Pyped
arch: src
version: 1.4
epoch: 0
release: 1
url: http://github.com/ksamuel/Pyped
rpm_license: GPL2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d60db92-8186-4830-83c9-9f62fb9af9b5
location_href: 00002879-python-Pyped/python-Pyped-1.4-1.src.rpm
checksum_type: sha256
summary:
  Replace sed/grep/cut/awk by letting you execute Python one-liners in your ordinary shell, like perl does.

description:
  *WARNING: since the last version the command line name "py" has been
  renamed to "pyp" to avoid conflict with the new tool in the Python
  stdlib named "py". It means pyped is now incompatible with the
  "Python Power at the Prompt" project sharing the same name and goals.*
  Pyped is a command-line tool that let you process another command
  output with a Python one-liner like Perl or AWK.
  Ever wish you could do this::
      $ ps aux | pyp "line = x.split()" "print(line[1], line[-1])" | grep worker
      18921 [kworker/1:2]
      22489 [kworker/3:0]
      24065 [kworker/3:3]
      24869 [kworker/u:3]
      25463 [kworker/u:1]
      25511 [kworker/2:2]
      25720 [kworker/0:2]
      26343 [kworker/0:1]
      26491 [kworker/2:0]
      26569 [kworker/1:0]
      26592 [kworker/u:0]
      26861 worker
  Or this::
      $ ls -1 | pyp -i "for x in Counter(path(x.split()[-1]).ext for x in l).items(): print(x)"
      (u'.sh', 2)
      ('', 3)
      (u'.sh~', 3)
      (u'.py', 4)
      (u'.desktop', 1)
  Pyped make that possible by giving you the `py` commande.


pkgId: 1c0018354edfd342775fc58fd8f399e2ff903397b63c315224bdb042ced7b9b2
name: python-Pyro
arch: src
version: 3.16
epoch: 0
release: 1
summary: distributed object middleware for Python (IPC/RPC), version 3.x
url: https://pypi.org/project/Pyro/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b9cb0978-a2cc-49a3-831a-d544ed686470
location_href: 00004786-python-pyro/python-Pyro-3.16-1.src.rpm
checksum_type: sha256
description:
  Pyro stands for PYthon Remote Objects. It is an advanced and powerful Distributed Object Technology system written entirely in Python, that is designed to be very easy to use.

  This is version 3.x of Pyro, which is no longer being maintained.
  For the current version with new features, look at `Pyro4 <http://pypi.python.org/pypi/Pyro4>`_ instead.


pkgId: 1c7b6f24cec2a92eeaeccdc46e29eae522e3606a7a6adf1861c397eb6f2c0753
name: python-Pyro4
arch: src
version: 4.82
epoch: 0
release: 1
summary: distributed object middleware for Python (RPC)
url: http://pyro4.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ec6eb2c9-8e8c-42ab-8f79-faf99288bf02
location_href: 00011193-python-pyro4/python-Pyro4-4.82-1.src.rpm
checksum_type: sha256
description:
  Pyro means PYthon Remote Objects.
  It is a library that enables you to build applications in which
  objects can talk to eachother over the network, with minimal programming effort.
  You can just use normal Python method calls, with almost every possible parameter
  and return value type, and Pyro takes care of locating the right object on the right
  computer to execute the method. It is designed to be very easy to use, and to
  generally stay out of your way. But it also provides a set of powerful features that
  enables you to build distributed applications rapidly and effortlessly.
  Pyro is a pure Python library and runs on many different platforms and Python versions.

  The source code repository is on Github: https://github.com/irmen/Pyro4

  The documentation can be found here: http://pyro4.readthedocs.io


pkgId: e85c5944706f1a9a8d657706f95802f11b11ebcde7ac885e41e3d0a1253f0224
name: python-Pyrogram
arch: src
version: 2.0.103
epoch: 0
release: 1
summary: Elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots
url: https://github.com/pyrogram
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-586e558f-f30d-45e5-a1f7-5e1b77a914ef
location_href: 00010305-python-pyrogram/python-Pyrogram-2.0.103-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/pyrogram/pyrogram">
          <img src="https://docs.pyrogram.org/_static/pyrogram.png" alt="Pyrogram" width="128">
      </a>
      <br>
      <b>Telegram MTProto API Framework for Python</b>
      <br>
      <a href="https://pyrogram.org">
          Homepage
      </a>
      •
      <a href="https://docs.pyrogram.org">
          Documentation
      </a>
      •
      <a href="https://docs.pyrogram.org/releases">
          Releases
      </a>
      •
      <a href="https://t.me/pyrogram">
          News
      </a>
  </p>



  > Elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots

  ``` python
  from pyrogram import Client, filters

  app = Client("my_account")


  @app.on_message(filters.private)
  async def hello(client, message):
      await message.reply("Hello from Pyrogram!")


  app.run()
  ```

  **Pyrogram** is a modern, elegant and asynchronous [MTProto API](https://docs.pyrogram.org/topics/mtproto-vs-botapi)
  framework. It enables you to easily interact with the main Telegram API through a user account (custom client) or a bot
  identity (bot API alternative) using Python.



  If you'd like to support Pyrogram, you can consider:

  - [Become a GitHub sponsor](https://github.com/sponsors/delivrance).
  - [Become a LiberaPay patron](https://liberapay.com/delivrance).
  - [Become an OpenCollective backer](https://opencollective.com/pyrogram).



  - **Ready**: Install Pyrogram with pip and start building your applications right away.
  - **Easy**: Makes the Telegram API simple and intuitive, while still allowing advanced usages.
  - **Elegant**: Low-level details are abstracted and re-presented in a more convenient way.
  - **Fast**: Boosted up by [TgCrypto](https://github.com/pyrogram/tgcrypto), a high-performance cryptography library written in C.
  - **Type-hinted**: Types and methods are all type-hinted, enabling excellent editor support.
  - **Async**: Fully asynchronous (also usable synchronously if wanted, for convenience).
  - **Powerful**: Full access to Telegram's API to execute any official client action and more.



  ``` bash
  pip3 install pyrogram
  ```



  - Check out the docs at https://docs.pyrogram.org to learn more about Pyrogram, get started right
  away and discover more in-depth material for building your client applications.
  - Join the official channel at https://t.me/pyrogram and stay tuned for news, updates and announcements.


pkgId: 5c13493626a3c1c409386405b4ef84660fae0048e59358b290923d63f50daa97
name: python-QDarkStyle
arch: src
version: 3.1
epoch: 0
release: 1
summary: The most complete dark/light style sheet for C++/Python and Qt applications
url: https://github.com/ColinDuquesnoy/QDarkStyleSheet
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-151a6984-3c40-4be2-afe9-d8626cc3331a
location_href: 00004897-python-qdarkstyle/python-QDarkStyle-3.1-1.src.rpm
checksum_type: sha256
description:
  The most complete dark/light style sheet for Qt applications (Qt4, Qt5,
  PySide, PySide2, PyQt4, PyQt5, QtPy, PyQtGraph, Qt.Py) for Python 2/3 and C++.

  Python 2, as well as Qt4 (PyQt4 and PySide), will not be supported anymore.
  They still there as it is, but no back-compatibility, fixes, nor features
  will be implemented.

  We still preparing the portability to Qt6 since we need changes in
  `QtPy <https://github.com/spyder-ide/qtpy>`__ dependency project.

  Check the `documentation <https://qdarkstylesheet.readthedocs.io/en/stable>`__
  to see how to set the desirable theme palette.

  This module provides a function to load the stylesheets transparently
  with the right resources file.

  First, start importing our module

  .. code-block:: python

      import qdarkstyle

  Then you can get stylesheet provided by QDarkStyle for various Qt wrappers
  as shown below

  .. code-block:: python

      
      dark_stylesheet = qdarkstyle.load_stylesheet_pyside()
      
      dark_stylesheet = qdarkstyle.load_stylesheet_pyside2()
      
      dark_stylesheet = qdarkstyle.load_stylesheet_pyqt()
      
      dark_stylesheet = qdarkstyle.load_stylesheet_pyqt5()

  Alternatively, from environment variables provided by QtPy, PyQtGraph, Qt.Py

  .. code-block:: python

      
      dark_stylesheet = qdarkstyle.load_stylesheet()
      
      dark_stylesheet = qdarkstyle.load_stylesheet(qt_api=os.environ('PYQTGRAPH_QT_LIB'))
      
      dark_stylesheet = qdarkstyle.load_stylesheet(qt_api=Qt.__binding__)

  Finally, set your QApplication with it

  .. code-block:: python

      app.setStyleSheet(dark_stylesheet)

  Enjoy!


pkgId: 8cf5172a5fe9084929fea7f49301e1662bd57e5349527bb8f8216bd72bc25ceb
name: python-QtAwesome
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: FontAwesome icons in PyQt and PySide applications
url: https://github.com/spyder-ide/qtawesome
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddeaad41-1759-4667-950e-5a29acc172cc
location_href: 00002880-python-QtAwesome/python-QtAwesome-1.2.2-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/pypi/l/qtawesome.svg)](./LICENSE)
  [![pypi version](https://img.shields.io/pypi/v/qtawesome.svg)](https://pypi.org/project/qtawesome/)
  [![conda version](https://img.shields.io/conda/vn/conda-forge/qtawesome.svg)](https://www.anaconda.com/download/)
  [![download count](https://img.shields.io/conda/d/conda-forge/qtawesome.svg)](https://www.anaconda.com/download/)
  [![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
  [![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public)<br>
  [![PyPI status](https://img.shields.io/pypi/status/qtawesome.svg)](https://github.com/spyder-ide/qtawesome)
  [![Github Windows build status](https://github.com/spyder-ide/qtawesome/workflows/Windows%20tests/badge.svg)](https://github.com/spyder-ide/qtawesome/actions)
  [![Github Linux build status](https://github.com/spyder-ide/qtawesome/workflows/Linux%20tests/badge.svg)](https://github.com/spyder-ide/qtawesome/actions)
  [![Github MacOS build status](https://github.com/spyder-ide/qtawesome/workflows/Macos%20tests/badge.svg)](https://github.com/spyder-ide/qtawesome/actions)
  [![Documentation Status](https://readthedocs.org/projects/qtawesome/badge/?version=latest)](https://qtawesome.readthedocs.io/en/latest/?badge=latest)

  *Copyright © 2015–2022 Spyder Project Contributors*




  QtAwesome enables iconic fonts such as Font Awesome and Elusive Icons
  in PyQt and PySide applications.

  It started as a Python port of the [QtAwesome](
  https://github.com/Gamecreature/qtawesome)
  C++ library by Rick Blommers.




  Using `conda`:

  ```
  conda install qtawesome
  ```

  or using `pip` (only if you don't have conda installed):

  ```
  pip install qtawesome
  ```






  QtAwesome identifies icons by their **prefix** and their **icon name**, separated by a *period* (`.`) character.

  The following prefixes are currently available to use:

  - [**FontAwesome**](https://fontawesome.com):

    - FA 5.15.4 features 1,608 free icons in different styles:

      - `fa5` prefix has [151 icons in the "**regular**" style.](https://fontawesome.com/v5/search?o=r&m=free&s=regular)
      - `fa5s` prefix has [1001 icons in the "**solid**" style.](https://fontawesome.com/v5/search?o=r&m=free&s=solid)
      - `fa5b` prefix has [456 icons of various **brands**.](https://fontawesome.com/v5/search?o=r&m=free&f=brands)

    - `fa` is the legacy [FA 4.7 version with its 675 icons](https://fontawesome.com/v4.7.0/icons/) but **all** of them (*and more!*) are part of FA 5.x so you should probably use the newer version above.

  - `ei` prefix holds [**Elusive Icons** 2.0 with its 304 icons](http://elusiveicons.com/icons/).

  - [**Material Design Icons**](https://cdn.materialdesignicons.com)

    - `mdi6` prefix holds [**Material Design Icons** 6.3.95 with its 6395 icons.](https://cdn.materialdesignicons.com/6.3.95/)

    - `mdi` prefix holds [**Material Design Icons** 5.9.55 with its 5955 icons.](https://cdn.materialdesignicons.com/5.9.55/)

  - `ph` prefix holds [**Phosphor** 1.3.0 with its 4470 icons (894 icons * 5 weights: Thin, Light, Regular, Bold and Fill).](https://github.com/phosphor-icons/phosphor-icons)

  - `ri` prefix holds [**Remix Icon** 2.5.0 with its 2271 icons.](https://github.com/Remix-Design/RemixIcon)

  - `msc` prefix holds Microsoft's [**Codicons** 0.0.32 with its 421 icons.](https://github.com/microsoft/vscode-codicons)



  ```python
  import qtawesome as qta
  ```

  - Use Font Awesome, Elusive Icons, Material Design Icons, Phosphor, Remix Icon or Microsoft's Codicons.

  ```python

  fa5_icon = qta.icon('fa5.flag')
  fa5_button = QtWidgets.QPushButton(fa5_icon, 'Font Awesome! (regular)')
  fa5s_icon = qta.icon('fa5s.flag')
  fa5s_button = QtWidgets.QPushButton(fa5s_icon, 'Font Awesome! (solid)')
  fa5b_icon = qta.icon('fa5b.github')
  fa5b_button = QtWidgets.QPushButton(fa5b_icon, 'Font Awesome! (brands)')


  asl_icon = qta.icon('ei.asl')
  elusive_button = QtWidgets.QPushButton(asl_icon, 'Elusive Icons!')


  apn_icon = qta.icon('mdi6.access-point-network')
  mdi6_button = QtWidgets.QPushButton(apn_icon, 'Material Design Icons!')


  mic_icon = qta.icon('ph.microphone-fill')
  ph_button = QtWidgets.QPushButton(mic_icon, 'Phosphor!')


  truck_icon = qta.icon('ri.truck-fill')
  ri_button = QtWidgets.QPushButton(truck_icon, 'Remix Icon!')


  squirrel_icon = qta.icon('msc.squirrel')
  msc_button = QtWidgets.QPushButton(squirrel_icon, 'Codicons!')

  ```

  - Apply some styling

  ```python

  styling_icon = qta.icon('fa5s.music',
                          active='fa5s.balance-scale',
                          color='blue',
                          color_active='orange')
  music_button = QtWidgets.QPushButton(styling_icon, 'Styling')
  ```

  - Set alpha in colors

  ```python


  icon_with_alpha = qta.icon('mdi.heart',
                             color=('red', 120))
  heart_button = QtWidgets.QPushButton(icon_with_alpha, 'Setting alpha')
  ```

  - Stack multiple icons

  ```python

  camera_ban = qta.icon('fa5s.camera', 'fa5s.ban',
                        options=[{'scale_factor': 0.5,
                                  'active': 'fa5s.balance-scale'},
                                 {'color': 'red'}])
  stack_button = QtWidgets.QPushButton(camera_ban, 'Stack')
  stack_button.setIconSize(QtCore.QSize(32, 32))
  ```

  - Define the way to draw icons (`text`- default for icons without animation, `path` - default for icons with animations, `glyphrun` and `image`)

  ```python

  drawn_image_icon = qta.icon('ri.truck-fill',
                              options=[{'draw': 'image'}])
  drawn_image_button = QtWidgets.QPushButton(drawn_image_icon,
                                             'Icon drawn as an image')
  ```

  - Animations

  ```python

  spin_button = QtWidgets.QPushButton(' Spinning icon')
  spin_icon = qta.icon('fa5s.spinner', color='red',
                       animation=qta.Spin(spin_button))
  spin_button.setIcon(spin_icon)
  ```

  - Display Icon as a widget

  ```python

  spin_widget = qta.IconWidget()
  spin_icon = qta.icon('mdi.loading', color='red',
                       animation=qta.Spin(spin_widget))
  spin_widget.setIcon(spin_icon)


  simple_widget = qta.IconWidget('mdi.web', color='blue')
  ```

  - Screenshot

  ![QtAwesome screenshot](qtawesome-screenshot.gif)


  To check these options you can launch the `example.py` script and pass to it the options as arguments. For example, to test how the icons could look using the `glyphrun` draw option, you can run something like:

  ```
  python example.py draw=glyphrun
  ```



  - QtAwesome comes bundled with _Font Awesome_, _Elusive Icons_, _Material Design_
    _Icons_, _Phosphor_, _Remix Icon_ and Microsoft's _Codicons_
    but it can also be used with other iconic fonts. The `load_font`
    function allows to load other fonts dynamically.
  - QtAwesome relies on the [QtPy](https://github.com/spyder-ide/qtpy.git)
    project as a compatibility layer on the top ot PyQt or PySide.



  QtAwesome ships with a browser that displays all the available icons.  You can
  use this to search for an icon that suits your requirements and then copy the
  name that should be used to create that icon!

  Once installed, run `qta-browser` from a shell to start the browser.

  ![QtAwesomeIconbrowser](qtawesome-browser.png)




  MIT License. Copyright 2015 - The Spyder development team.
  See the [LICENSE](LICENSE) file for details.

  The [Font Awesome](https://github.com/FortAwesome/Font-Awesome/blob/master/LICENSE.txt) and [Elusive Icons](http://elusiveicons.com/license/) fonts are licensed under the [SIL Open Font License](http://scripts.sil.org/OFL).

  The Phosphor font is licensed under the [MIT License](https://github.com/phosphor-icons/phosphor-icons/blob/master/LICENSE).

  The [Material Design Icons](https://github.com/Templarian/MaterialDesign/blob/master/LICENSE) font is licensed under the [Apache License Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).

  The Remix Icon font is licensed under the [Apache License Version 2.0](https://github.com/Remix-Design/remixicon/blob/master/License).

  Microsoft's Codicons are licensed under a [Creative Commons Attribution 4.0 International Public License](https://github.com/microsoft/vscode-codicons/blob/master/LICENSE).



  Spyder and its subprojects are funded thanks to the generous support of

  [![Quansight](https://user-images.githubusercontent.com/16781833/142477716-53152d43-99a0-470c-a70b-c04bbfa97dd4.png)](https://www.quansight.com/)[![Numfocus](https://i2.wp.com/numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png?fit=320%2C148&ssl=1)](https://numfocus.org/)

  and the donations we have received from our users around the world through [Open Collective](https://opencollective.com/spyder/):

  [![Sponsors](https://opencollective.com/spyder/sponsors.svg)](https://opencollective.com/spyder#support)


pkgId: 644a63d27350ca8d607111e4ebb6405abd75b142086184eed46e1fbcfba7420a
name: python-QtPy
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6).
url: https://github.com/spyder-ide/qtpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae7763a2-7e3c-4b5b-bec2-ab0fe6cffe47
location_href: 00002881-python-QtPy/python-QtPy-2.3.0-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/pypi/l/qtpy.svg)](./LICENSE)
  [![pypi version](https://img.shields.io/pypi/v/qtpy.svg)](https://pypi.org/project/QtPy/)
  [![conda version](https://img.shields.io/conda/vn/conda-forge/qtpy.svg)](https://www.anaconda.com/download/)
  [![download count](https://img.shields.io/conda/dn/conda-forge/qtpy.svg)](https://www.anaconda.com/download/)
  [![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
  [![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public)<br>
  [![PyPI status](https://img.shields.io/pypi/status/qtpy.svg)](https://github.com/spyder-ide/qtpy)
  [![Github build status](https://github.com/spyder-ide/qtpy/workflows/Tests/badge.svg)](https://github.com/spyder-ide/qtpy/actions)
  [![Coverage Status](https://coveralls.io/repos/github/spyder-ide/qtpy/badge.svg?branch=master)](https://coveralls.io/github/spyder-ide/qtpy?branch=master)

  *Copyright © 2009–2022 The Spyder Development Team*




  **QtPy** is a small abstraction layer that lets you
  write applications using a single API call to either PyQt or PySide.

  It provides support for PyQt5, PyQt6, PySide6, PySide2 using the Qt5 layout
  (where the QtGui module has been split into QtGui and QtWidgets).

  Basically, you can write your code as if you were using PyQt or PySide directly,
  but import Qt modules from `qtpy` instead of `PyQt5`, `PySide2`, `PyQt6` or `PySide6`.

  Accordingly, when porting code between different Qt bindings (PyQt vs PySide) or Qt versions (Qt5 vs Qt6), QtPy makes this much more painless, and allows you to easily and incrementally transition between them. QtPy handles incompatibilities and differences between bindings or Qt versions for you while keeping your project running, so you can focus more on your own code and less on keeping track of supporting every Qt version and binding. Furthermore, when you do want to upgrade or support new bindings, it allows you to update your project module by module rather than all at once.  You can check out examples of this approach in projects using QtPy, like [git-cola](https://github.com/git-cola/git-cola/issues/232).



  This project is based on the [pyqode.qt](https://github.com/pyQode/pyqode.qt)
  project and the [spyderlib.qt](https://github.com/spyder-ide/spyder/tree/2.3/spyderlib/qt)
  module from the [Spyder](https://github.com/spyder-ide/spyder) project, and
  also includes contributions adapted from
  [qt-helpers](https://github.com/glue-viz/qt-helpers), developed as part of the
  [glue](http://glueviz.org) project.

  Unlike `pyqode.qt` this is not a namespace package, so it is not tied
  to a particular project or namespace.




  This project is released under the MIT license.




  You need PyQt5, PySide2, PyQt6 or PySide6 installed in your system to make use
  of QtPy. If several of these packages are found, PyQt5 is used by
  default unless you set the `QT_API` environment variable.

  `QT_API` can take the following values:

  * `pyqt5` (to use PyQt5).
  * `pyside2` (to use PySide2).
  * `pyqt6` (to use PyQt6).
  * `pyside6` (to use PySide6).




  * `QtCore.pyqtSignal`, `QtCore.pyqtSlot` and `QtCore.pyqtProperty` (available on PyQt5/6) are instead exposed as `QtCore.Signal`, `QtCore.Slot` and `QtCore.Property`, respectively, following the Qt5 module layout.

  * The Qt version being used can be checked with `QtCore.__version__` (instead of `QtCore.QT_VERSION_STR`) as well as from `qtpy.QT_VERSION`.

  * For PyQt6 enums, unscoped enum access was added by promoting the enums of the `QtCore`, `QtGui`, `QtTest` and `QtWidgets` modules.

  * Compatibility is added between the `QtGui` and `QtOpenGL` modules for the `QOpenGL*` classes.

  * To check the current binding version, you can use `qtpy.PYSIDE_VERSION` for PySide2/6 and `qtpy.PYQT_VERSION` for PyQt5/6. If the respective binding is not being used, the value of its attribute will be `None`.

  * To check the current selected binding, you can use `qtpy.API_NAME`

  * There are boolean values to check if Qt5/6, PyQt5/6 or PySide2/6 are being used: `qtpy.QT5`, `qtpy.QT6`, `qtpy.PYQT5`, `qtpy.PYQT6`, `qtpy.PYSIDE2` and `qtpy.PYSIDE6`. `True` if currently being used, `False` otherwise.



  In the `qtpy.compat` module, you can find wrappers for `QFileDialog` static methods and SIP/Shiboken functions, such as:

  * `QFileDialog.getExistingDirectory` wrapped with `qtpy.compat.getexistingdirectory`

  * `QFileDialog.getOpenFileName` wrapped with `qtpy.compat.getopenfilename`

  * `QFileDialog.getOpenFileNames` wrapped with `qtpy.compat.getopenfilenames`

  * `QFileDialog.getSaveFileName` wrapped with `qtpy.compat.getsavefilename`

  * `sip.isdeleted` and `shiboken.isValid` wrapped with `qtpy.compat.isalive`




  ```bash
  pip install qtpy
  ```

  or

  ```bash
  conda install qtpy
  ```




  A Command Line Interface (CLI) is offered to help with usage of QtPy.
  Presently, its only feature is to generate command line arguments for Mypy
  that will enable it to process the QtPy source files with the same API
  as QtPy itself would have selected.

  If you run

  ```bash
  qtpy mypy-args
  ```

  QtPy will output a string of Mypy CLI args that will reflect the currently
  selected Qt API.
  For example, in an environment where PyQt5 is installed and selected
  (or the default fallback, if no binding can be found in the environment),
  this would output the following:

  ```text
  --always-true=PYQT5 --always-false=PYSIDE2 --always-false=PYQT6 --always-false=PYSIDE6
  ```

  Using Bash or a similar shell, this can be injected into
  the Mypy command line invocation as follows:

  ```bash
  mypy --package mypackage $(qtpy mypy-args)
  ```

  For Pyright support and other usage notes, see [this comment](https://github.com/spyder-ide/qtpy/issues/352#issuecomment-1170684412).




  Everyone is welcome to contribute!




  QtPy is funded thanks to the generous support of


  [![Quansight](https://user-images.githubusercontent.com/16781833/142477716-53152d43-99a0-470c-a70b-c04bbfa97dd4.png)](https://www.quansight.com/)[![Numfocus](https://i2.wp.com/numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png?fit=320%2C148&ssl=1)](https://numfocus.org/)

  and the donations we have received from our users around the world through [Open Collective](https://opencollective.com/spyder/):

  [![Sponsors](https://opencollective.com/spyder/sponsors.svg)](https://opencollective.com/spyder#support)


pkgId: 6f712e8687b270243c79908bc6bbc493d93b74ca98848e92927b139f84921a8d
name: python-RESTinstance
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Robot Framework library for RESTful JSON APIs
url: https://github.com/asyrjasalo/RESTinstance
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ed31dd3f-8b1f-4677-8a15-46e73e3b7654
location_href: 00013220-python-restinstance/python-RESTinstance-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [Robot Framework](http://robotframework.org) library for RESTful JSON APIs

  [Keyword Documentation](https://asyrjasalo.github.io/RESTinstance)



  1.  **RESTinstance relies on Robot Framework's language-agnostic, clean
      and minimal syntax, for API tests.** It is neither tied to any
      particular programming language nor development framework. Using
      RESTinstance requires little, if any, programming knowledge. It
      builts on long-term technologies with well established communities,
      such as HTTP, JSON (Schema), Swagger/OpenAPI and Robot Framework.
  2.  **It validates JSON using JSON Schema, guiding you to write API
      tests to base on properties** rather than on specific values (e.g.
      "email must be valid" vs "email is foo@bar.com"). This approach
      reduces test maintenance when the values responded by the API are
      prone to change. Although values are not required, you can still
      test them whenever they make sense (e.g. GET response body from one
      endpoint, then POST some of its values to another endpoint and
      verify the results).
  3.  **It generates JSON Schema for requests and responses automatically,
      and the schema gets more accurate by your tests.** Output the schema
      to a file and reuse it as expectations to test the other methods, as
      most of them respond similarly with only minor differences. Or
      extend the schema further to a full Swagger spec (version 2.0,
      OpenAPI 3.0 also planned), which RESTinstance can test requests and
      responses against. All this leads to reusability, getting great test
      coverage with minimum number of keystrokes and very clean tests.





  On 3.6, 3.7 you can install and upgrade
  [from PyPi](https://pypi.org/project/RESTinstance):

      python3 -m venv venv
      source venv/bin/activate
      pip install --upgrade RESTinstance

  On 2.7 series the package works as well, but using 2.7 is
  [not preferred 2020 onwards](https://pythonclock.org/):

      pip install --user --upgrade virtualenv
      virtualenv venv
      source venv/bin/activate
      pip install --upgrade RESTinstance

  These also install [Robot Framework](https://pypi.org/project/robotframework)
  if you do not have it already.





  There is a
  [step-by-step tutorial](https://github.com/asyrjasalo/RESTinstance/blob/master/examples)
  in the making, best accompanied with
  [the keyword documentation](https://asyrjasalo.github.io/RESTinstance).



  1.  Create two new empty directories, `atest` and `results`.
  2.  Create a new file `atest/YOURNAME.robot` with the content:

  ``` robotframework
  *** Settings ***
  Library         REST    https://jsonplaceholder.typicode.com
  Documentation   Test data can be read from variables and files.
  ...             Both JSON and Python type systems are supported for inputs.
  ...             Every request creates a so-called instance. Can be `Output`.
  ...             Most keywords are effective only for the last instance.
  ...             Initial schemas are autogenerated for request and response.
  ...             You can make them more detailed by using assertion keywords.
  ...             The assertion keywords correspond to the JSON types.
  ...             They take in either path to the property or a JSONPath query.
  ...             Using (enum) values in tests optional. Only type is required.
  ...             All the JSON Schema validation keywords are also supported.
  ...             Thus, there is no need to write any own validation logic.
  ...             Not a long path from schemas to full Swagger/OpenAPI specs.
  ...             The persistence of the created instances is the test suite.
  ...             Use keyword `Rest instances` to output the created instances.


  *** Variables ***
  ${json}         { "id": 11, "name": "Gil Alexander" }
  &{dict}         name=Julie Langford


  *** Test Cases ***
  GET an existing user, notice how the schema gets more accurate
      GET         /users/1                  # this creates a new instance
      Output schema   response body
      Object      response body             # values are fully optional
      Integer     response body id          1
      String      response body name        Leanne Graham
      [Teardown]  Output schema             # note the updated response schema

  GET existing users, use JSONPath for very short but powerful queries
      GET         /users?_limit=5           # further assertions are to this
      Array       response body
      Integer     $[0].id                   1           # first id is 1
      String      $[0]..lat                 -37.3159    # any matching child
      Integer     $..id                     maximum=5   # multiple matches
      [Teardown]  Output  $[*].email        # outputs all emails as an array

  POST with valid params to create a new user, can be output to a file
      POST        /users                    ${json}
      Integer     response status           201
      [Teardown]  Output  response body     ${OUTPUTDIR}/new_user.demo.json

  PUT with valid params to update the existing user, values matter here
      PUT         /users/2                  { "isCoding": true }
      Boolean     response body isCoding    true
      PUT         /users/2                  { "sleep": null }
      Null        response body sleep
      PUT         /users/2                  { "pockets": "", "money": 0.02 }
      String      response body pockets     ${EMPTY}
      Number      response body money       0.02
      Missing     response body moving      # fails if property moving exists

  PATCH with valid params, reusing response properties as a new payload
      &{res}=     GET   /users/3
      String      $.name                    Clementine Bauch
      PATCH       /users/4                  { "name": "${res.body['name']}" }
      String      $.name                    Clementine Bauch
      PATCH       /users/5                  ${dict}
      String      $.name                    ${dict.name}

  DELETE the existing successfully, save the history of all requests
      DELETE      /users/6                  # status can be any of the below
      Integer     response status           200    202     204
      Rest instances  ${OUTPUTDIR}/all.demo.json  # all the instances so far
  ```

  3.  Make JSON API testing great again:
  ```
  robot --outputdir results atest/
  ```




  Bug reports and feature requests are tracked in
  [GitHub](https://github.com/asyrjasalo/RESTinstance/issues).
  We do respect pull request(er)s.



  The logic is detaching the enving from system level (dependencies) as following:
  1. We use [pyenv](https://github.com/pyenv/pyenv) to manage n Pythons user-wide.
  2. With Pyenv installed Pythons, we never mess with the system's default Python.
  3. We ended up to [Nox](https://nox.thea.codes/en/stable/) after evaluating
  Bash scripts, `make`, `invoke` and `tox` to achieve automated virtualenving.

  To understand the first two of the practices, these are worth reading:
  - [Real Python's intro to pyenv](https://realpython.com/intro-to-pyenv)
  - [Real Python's virtualenvs primer](https://realpython.com/python-virtual-environments-a-primer/)
  - [virtualenv compatibility with the stdlib venv module](https://virtualenv.pypa.io/en/latest/reference/#compatibility-with-the-stdlib-venv-module)

  Third, unlike Tox, Nox uses Python file (`noxfile.py`) for configuration, yet:
  - Supports multiple Python versions, each session is ran on some `pythonX.X`.
  - A session is a single virtualenv which is stored in `.venv/<session_name>`.
  - Every `nox` recreates session, thus virtualenv, unless `reuse_venv=True`.



  The pyenv setup works on OS X and on the common Linux distros out of the box:

      curl https://pyenv.run | bash
      export PATH="$HOME/.pyenv/bin:$PATH"
      eval "$(pyenv init -)"

  The first script installs it user-wide, thus it never requires `sudo` rights.

  If you are on Windows, using pyenv might or might not be an option. Regardless,
  you want to check [pyenv-win](https://github.com/pyenv-win/pyenv-win) instead.

  We test, develop, build and publish on Python 3.6.9, and use venvs as preferred:

      git clone git@github.com:asyrjasalo/RESTinstance.git
      cd RESTinstance
      pyenv install --skip-existing 3.6.9 && pyenv rehash
      python3 -m venv .venv/dev
      source .venv/dev/bin/activate
      pip install -e .



  Nox automates handling `.venv/<task>`s for workflows, that on Windows as well:

      pip install --upgrade nox

  The actual tasks are defined in `noxfile.py`, as well as our settings like:
  - The default Python interpreter to run all the development tasks is `python3.6`
  - We explicitly use [venv module](https://docs.python.org/3/library/venv.html)
  now for virtualenving, as we develop on Python >= 3.3 anyway
  - Whether a new virtualenv is always recreated when the respective task is run
  (which is default for most of our tasks)

  Session is a task, running in the `.venv/<task>`. To list all possible sessions:

      nox -l

  Sessions defined in `RESTinstance/noxfile.py`:

      * test -> Run development tests for the package.
      - testenv -> Run development server for acceptance tests.
      * atest -> Run acceptance tests for the project.
      - docs -> Regenerate documentation for the project.
      - black -> Reformat/unify/"blacken" Python source code in-place.
      - prospector -> Run various static analysis tools for the package.
      - build -> Build sdist and wheel dists.
      - release_testpypi -> Publish dist/* to TestPyPI.
      - install_testpypi -> Install the latest (pre-)release from TestPyPI.
      - release -> Tag, build and publish a new release to PyPI.
      - install -> Install the latest release from PyPI.
      - clean -> Remove all .venv's, build files and caches in the directory.

  Sessions marked with `*` are selected, sessions marked with `-` are skipped.

  That is, to run both `test`s and `atest`s:

      nox

  Session `nox -s atest` assumes you have started `testapi/` on
  [mountebank](https://www.mbtest.org):

      nox -s testenv

  Running the above assumes you have `node` (>= 6) installed in your system.

  After started, you can debug requests and responses by tests in web browser at
  [localhost:2525](http://localhost:2525/imposters).

  Both `nox -s test` and `nox -s atest` allow passing arguments to `pytest`
  and `robot`, respectively:

      nox -s test -- test/<test_modulename>.py
      nox -s atest -- atest/<atest_suitedir>/<atest_suitefile>.robot

  You know, having a virtualenv even for generating `docs/` - why not a bad idea:

      nox -s docs



  Remove all sessions (`.venv/`s) as well as temporary files in your working copy:

      nox -s clean

  Our PyPI distributions are known to work well on Python 3.7 and 2.7 series too:

      nox -s clean build

  We use [zest.releaser](https://github.com/zestsoftware/zest.releaser) for
  versioning, tagging and building (universal) `bdist_wheel`s.

  It uses [twine](https://pypi.org/project/twine/) underneath to upload to PyPIs
  securely over HTTPS, which can't be done with `python setup.py` commands.



  This workflow is preferred for distributing a new (pre-)release to TestPyPI:

      nox -s test atest docs clean build release_testpypi install_testpypi

  If that installed well, all will be fine to let the final release to PyPI:

      nox -s release

  To install the latest release from PyPI, and in a dedicated venv of course:

      nox -s install



  For intermediate `nox` arguments usage, you'll advance by enabling
  [shell completion](https://nox.thea.codes/en/stable/usage.html#shell-completion):

      eval "$(register-python-argcomplete nox)"

  On `zsh`, ensure you have bash compatibility enabled in `.zshrc` or similar:

      autoload -U bashcompinit
      bashcompinit

  These completions likely do not work on vanilla PowerShell, but can be used on
  [Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10).



  Catching errors already write-time, regardless of the editor, is advantaged by
  [Palantir's Python Language Server](https://github.com/palantir/python-language-server):

      python3 -m venv .venv/dev
      source .venv/dev/bin/activate
      pip install --upgrade python-language-server[all]

  Installing the all bundle, and the LSP plugin for your editor, enables to run
  useful linters real-time, like:

  - Either `autopep8` or `black` (preferred) for automated code formatting
  - `isort` for sorting code import statements
  - McCabe for code complexity checking
  - `mypy` for static type checking on Python 3
  - `pycodestyle` for coding style checking
  - `pyflakes` for detecting various coding errors

  Remember to (auto-)start the language server on background via your editor.



  We want our static analysis checks ran before code even ends up in a commit.

  Thus both `nox` and `nox -s test` commands bootstrap
  [pre-commit](https://pre-commit.com/) hooks in your git working copy.

  The actual hooks are configured in `.pre-commit-commit.yaml`.



  - export `mb` recorded responses to CI (pre-commit hook: `nox -s save_testenv`)
  - change `nox -s testenv` to load the saved testenv -> rid of `--allowInjection`
  - add CI (GitHub Actions? GitLab?)
  - add Python types to pass `prospector --with-tool mypy`
  - enable pre-commit hook for prospector





  RESTinstance is under
  [Apache License 2.0](https://github.com/asyrjasalo/RESTinstance/blob/master/LICENSE)
  and was originally written by [Anssi Syrjäsalo](https://github.com/asyrjasalo).

  It was first presented at the first [RoboCon](https://robocon.io), 2018.

  Contributors:

  - [jjwong](https://github.com/jjwong) for helping with keyword
  documentation and examples (also check
  [RESTinstance_starter_project](https://github.com/jjwong/RESTinstance_starter_project))
  - [Przemysław "sqilz" Hendel](https://github.com/sqilz) for using and
  testing RESTinstance in early phase (also check
  [RESTinstance-wrapper](https://github.com/sqilz/RESTinstance-wrapper))
  - [Vinh "vinhntb" Nguyen](https://github.com/vinhntb),
  [#52](https://github.com/asyrjasalo/RESTinstance/pull/52).
  - [Stavros "stdedos" Ntentos](https://github.com/stdedos),
  [#75](https://github.com/asyrjasalo/RESTinstance/pull/75).
  - [Nicholas "bollwyvl" Bollweg](https://github.com/bollwyvl),
  [#84](https://github.com/asyrjasalo/RESTinstance/pull/84).
  - [Trey Turner](https://github.com/treyturner), [#86](https://github.com/asyrjasalo/RESTinstance/pull/86)

  We use following Python excellence under the hood:

  - [Flex](https://github.com/pipermerriam/flex), by Piper Merriam, for
  Swagger 2.0 validation
  - [GenSON](https://github.com/wolverdude/GenSON), by Jon "wolverdude"
  Wolverton, for JSON Schema generator
  - [jsonpath-ng](https://github.com/h2non/jsonpath-ng), by Tomas
  Aparicio and Kenneth Knowles, for handling JSONPath queries
  - [jsonschema](https://github.com/Julian/jsonschema), by Julian
  Berman, for JSON Schema validator
  - [pygments](http://pygments.org), by Georg Brandl et al., for JSON
  syntax coloring, in terminal <span class="title-ref">Output</span>
  - [requests](https://github.com/requests/requests), by Kenneth Reitz
  et al., for making HTTP requests

  See
  [requirements.txt](https://github.com/asyrjasalo/RESTinstance/blob/master/requirements.txt)
  for all the direct run time dependencies.

  REST your mind, OSS got your back.


pkgId: e9a372f00c4d80bff0e531a90b223bbfa812eadbe5d17a501419a6c5c58b57bd
name: python-ROPGadget
arch: src
version: 7.2
epoch: 0
release: 1
summary: This tool lets you search your gadgets on your binaries to facilitate your ROP exploitation.
url: https://github.com/JonathanSalwan/ROPgadget
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-484890e9-9099-451f-8df3-18d86a5c9726
location_href: 00002882-python-ROPGadget/python-ROPGadget-7.2-1.src.rpm
checksum_type: sha256
description:
  ROPgadget supports ELF, PE and Mach-O format on x86, x64, ARM, ARM64, PowerPC, SPARC and MIPS architectures.
  http://www.shell-storm.org/project/ROPgadget/


pkgId: 6be9d9bbcf5e2c4aeb61cfb931faee7152e69ef7ca595dd9cacc213160971015
name: python-ROPGadget
arch: src
version: 7.3
epoch: 0
release: 1
summary: This tool lets you search your gadgets on your binaries to facilitate your ROP exploitation.
url: https://github.com/JonathanSalwan/ROPgadget
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f4e158a-e6a2-4b76-8641-6c05c35c6a0e
location_href: 00006262-python-ROPGadget/python-ROPGadget-7.3-1.src.rpm
checksum_type: sha256
description:
  ROPgadget supports ELF, PE, Mach-O, and Raw formats on x86, x64, ARM, ARM64, PowerPC, SPARC, MIPS, RISC-V 64, and RISC-V Compressed architectures.
  https://github.com/JonathanSalwan/ROPgadget


pkgId: 5cb527702afc865e4d4be62b4ec6a41e2e61ea374ac0c88e26c37a08672195ab
name: python-Represent
arch: src
version: 1.6.0.post0
epoch: 0
release: 1
summary: Create __repr__ automatically or declaratively.
url: https://github.com/RazerM/represent
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd83754d-3dda-45cc-b3ef-07674f48dd1c
location_href: 00004955-python-represent/python-Represent-1.6.0.post0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version][ppi]][ppl] [![Documentation][di]][dl] [![CI Status][gai]][gal] [![Coverage][cvi]][cvl] [![Python Version][pvi]][pvl] [![MIT License][mli]][mll]

    [ppi]: https://img.shields.io/pypi/v/represent.svg?style=flat-square
    [ppl]: https://pypi.python.org/pypi/represent/
    [pvi]: https://img.shields.io/badge/python-2.7%2C%203-brightgreen.svg?style=flat-square
    [pvl]: https://www.python.org/downloads/
    [mli]: https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square
    [mll]: https://raw.githubusercontent.com/RazerM/represent/master/LICENSE
    [di]: https://img.shields.io/badge/docs-latest-brightgreen.svg?style=flat-square
    [dl]: https://represent.readthedocs.io/en/latest/
    [gai]: https://github.com/RazerM/represent/workflows/CI/badge.svg?branch=master
    [gal]: https://github.com/RazerM/represent/actions?workflow=CI
    [cvi]: https://img.shields.io/codecov/c/github/RazerM/represent/master.svg?style=flat-square
    [cvl]: https://codecov.io/github/RazerM/represent?branch=master



  ```bash
  $ pip install represent
  ```



  ```python
  from represent import autorepr


  @autorepr
  class Rectangle:
      def __init__(self, name, color, width, height):
          self.name = name
          self.color = color
          self.width = width
          self.height = height

  rect = Rectangle('Timothy', 'red', 15, 4.5)
  print(rect)
  ```

  ```
  Rectangle(name='Timothy', color='red', width=15, height=4.5)
  ```



  ```python
  from represent import ReprHelperMixin


  class ContrivedExample(ReprHelperMixin, object):
      def __init__(self, description, radians, shape, color, miles):
          self.description = description
          self.degrees = radians * 180 / 3.141592654
          self.shape = shape
          self._color = color
          self.km = 1.60934 * miles

      def _repr_helper_(self, r):
          r.positional_from_attr('description')
          r.positional_with_value(self.degrees * 3.141592654 / 180)
          r.keyword_from_attr('shape')
          r.keyword_from_attr('color', '_color')
          r.keyword_with_value('miles', self.km / 1.60934)

  ce = ContrivedExample('does something', 0.345, 'square', 'red', 22)

  print(ce)
  from IPython.lib.pretty import pprint
  pprint(ce)
  ```

  ```
  ContrivedExample('does something', 0.345, shape='square', color='red', miles=22.0)
  ContrivedExample('does something',
                   0.345,
                   shape='square',
                   color='red',
                   miles=22.0)
  ```


pkgId: d67cdc684fe945e90a5fb0701bf48e082cc87b33067488200ab910fa809b2d41
name: python-RestrictedPython
arch: src
version: 6.0
epoch: 0
release: 1
url: https://github.com/zopefoundation/RestrictedPython
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-53741bb2-2292-4ef4-a649-568f9be6d537
location_href: 00011400-python-restrictedpython/python-RestrictedPython-6.0-1.src.rpm
checksum_type: sha256
summary:
  RestrictedPython is a defined subset of the Python language which allows to provide a program input into a trusted environment.


pkgId: efa4d56fb5047e3b6c7ccbea99d2c70c8ab524456b3f7cf2cb0081de801c0e47
name: python-Rtree
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: R-Tree spatial index for Python GIS
url: https://github.com/Toblerity/rtree
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-30abce8a-24fd-465c-b049-803d04f2f70d
location_href: 00005019-python-rtree/python-Rtree-1.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Build](https://github.com/Toblerity/rtree/workflows/Build/badge.svg)
  [![PyPI version](https://badge.fury.io/py/Rtree.svg)](https://badge.fury.io/py/Rtree)


  Rtree is a [ctypes](http://docs.python.org/library/ctypes.html) Python wrapper of [libspatialindex](https://libspatialindex.org/) that provides a
  number of advanced spatial indexing features for the spatially curious Python
  user.  These features include:

  * Nearest neighbor search
  * Intersection search
  * Multi-dimensional indexes
  * Clustered indexes (store Python pickles directly with index entries)
  * Bulk loading
  * Deletion
  * Disk serialization
  * Custom storage implementation (to implement spatial indexing in ZODB, for example)


  Wheels are available for most major platforms, and `rtree` with bundled `libspatialindex` can be installed via pip:

  ```
  pip install rtree
  ```





  * Fix up type hints #243 (thanks @oderby)
  * Python 3.11 wheels #250 (thanks @ewouth)




  * Python 3.7+ is now required (#212) (thanks @adamjstewart!)
  * Type hints (#215 and others) (thanks @adamjstewart!)
  * Python 3.10 wheels, including osx-arm64 #224
  * Clean up libspatialindex C API mismatches #222 (thanks @musicinmybrain!)
  * Many doc updates, fixes, and type hints (thanks @adamjstewart!) #212 #221 #217 #215
  * __len__ method for index #194
  * Prevent get_coordinate_pointers from mutating inputs #205 (thanks @sjones94549!)
  * linux-aarch64 wheels #183 (thanks @odidev!)
  * black (#218) and flake8 (#145) linting

  https://github.com/Toblerity/rtree/releases/1.0.0


pkgId: e98959a7b91c69917184ff31e7576f5540a127156544e5c954a890457ebd0393
name: python-SPARQLWrapper
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: SPARQL Endpoint interface to Python
url: http://rdflib.github.io/sparqlwrapper
rpm_license: W3C SOFTWARE NOTICE AND LICENSE
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e07d1e33-5ea9-4f4c-b974-6881a9de397c
location_href: 00012159-python-sparqlwrapper/python-SPARQLWrapper-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This is a wrapper around a SPARQL service. It helps in creating the query URI and, possibly, convert the result into a more manageable format.


pkgId: 83ea3a97c328f200f0bbfaa29f5e1ac3b5533f8e65d9c0ec4a71d86a2f1b7af4
name: python-SQLObject
arch: src
version: 3.10.1
epoch: 0
release: 1
summary: Object-Relational Manager, aka database wrapper
url: http://sqlobject.org/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3eee059-ad15-4eeb-b69e-664304a9a3b5
location_href: 00005197-python-sqlobject/python-SQLObject-3.10.1-1.src.rpm
checksum_type: sha256
description:
  SQLObject is a popular *Object Relational Manager* for providing an
  object interface to your database, with tables as classes, rows as
  instances, and columns as attributes.

  SQLObject includes a Python-object-based query language that makes SQL
  more abstract, and provides substantial database independence for
  applications.

  Supports MySQL, PostgreSQL, SQLite, Firebird, Sybase, MSSQL and MaxDB (SAPDB).
  Python 2.7 or 3.4+ is required.

  For development see the projects at
  `SourceForge <https://sourceforge.net/projects/sqlobject/>`_
  and `GitHub <https://github.com/sqlobject>`_.

  .. image:: https://github.com/sqlobject/sqlobject/actions/workflows/run-tests.yaml/badge.svg?branch=github-actions
     :target: https://github.com/sqlobject/sqlobject/actions/workflows/run-tests.yaml


pkgId: b23b504d391e18fb22a5167e7efc49c507f9b0dc661e5326158e6c819a2860a6
name: python-STEPS
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: STochastic Engine for Pathway Simulation
url: http://steps.sourceforge.net
rpm_license: GNU General Public License Version 3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ce612d6e-ed42-4a91-8422-60a74add1969
location_href: 00005220-python-steps/python-STEPS-2.2.0-1.src.rpm
checksum_type: sha256
description:
      We provide precompiled binary packages for various operating
  systems. The user is recommended to use these packages when possible.
      For systems which a precomplied binary is unavailable, the user may
  install STEPS following the steps in the Basic Installation section.


pkgId: d0582470619a946825127cb149ffcfcc94a181d8a48f6012db9fb03dd0903ad7
name: python-Salesforce-FuelSDK
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Salesforce Marketing Cloud Fuel SDK for Python
url: https://github.com/salesforce-marketingcloud/FuelSDK-Python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-30f847d3-21aa-4afa-8b66-8c15458290df
location_href: 00011940-python-salesforce-fuelsdk/python-Salesforce-FuelSDK-1.3.0-1.src.rpm
checksum_type: sha256
description:
  * Added Refresh Token support for OAuth2 authentication
  * Added Web/Public App support for OAuth2 authentication
     More details on Access Tokens for Web/Public Apps can be found [here](https://developer.salesforce.com/docs/atlas.en-us.mc-app-development.meta/mc-app-development/access-token-app.htm)
     Sample config:
     ```
    [Web Services]
    appsignature: none
    clientid: <CLIENT_ID>
    clientsecret: <CLIENT_SECRET>
    defaultwsdl: https://webservice.exacttarget.com/etframework.wsdl
    authenticationurl: <AUTH TENANT SPECIFIC ENDPOINT>
    baseapiurl: <REST TENANT SPECIFIC ENDPOINT>
    soapendpoint: <SOAP TENANT SPECIFIC ENDPOINT>
    wsdl_file_local_loc: <WSDL_PATH>/ExactTargetWSDL.xml
    [Auth Service]
    useOAuth2Authentication: True
    accountId: <TARGET_ACCOUNT_ID>
    scope: <PERMISSION_LIST>
    applicationType: <APPLICATION_TYPE>
    redirectURI: <REDIRECT_URI_FOR_PUBLIC/WEB_APP>
    authorizationCode: <AUTHORIZATION_CODE_FOR_PUBLIC/WEB_APP>
    ```
    Example passing config as a parameter to ET_Client constructor:
    ```
    stubObj = ET_Client.ET_Client(
      False, False,
      {
          'clientid': '<CLIENT_ID>',
          'clientsecret': '<CLIENT_SECRET>',
          'defaultwsdl': 'https://webservice.exacttarget.com/etframework.wsdl',
          'authenticationurl': '<AUTH TENANT SPECIFIC ENDPOINT>',
          'baseapiurl': '<REST TENANT SPECIFIC ENDPOINT>',
          'soapendpoint': '<SOAP TENANT SPECIFIC ENDPOINT>',
          'wsdl_file_local_loc': r'<WSDL_PATH>/ExactTargetWSDL.xml',
          'useOAuth2Authentication': 'True',
          'accountId': '<TARGET_ACCOUNT_ID>',
          'scope': '<PERMISSION_LIST>'
          'applicationType': '<APPLICATION_TYPE>'
          'redirectURI': '<REDIRECT_URI_FOR_PUBLIC/WEB_APP>'
          'authorizationCode': '<AUTHORIZATION_CODE_FOR_PUBLIC/WEB_APP>'
      })
    ```
  * applicationType can have one of the following values: `server`, `public`, `web`. The default value of applicationType is `server`.


pkgId: a7fd31334c34621ebbd68d542fe0ad3af0b06323b628d91b3aabd04c23e66fc3
name: python-Sanic-Cors
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: A Sanic extension adding a decorator for CORS support. Based on flask-cors by Cory Dolphin.
url: https://github.com/ashleysommer/sanic-cors
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9fd4a0a6-08f3-41d1-a7cc-42a15a646230
location_href: 00011118-python-sanic-cors/python-Sanic-Cors-2.2.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Latest Version| |Supported Python versions|
  |License|
  A Sanic extension for handling Cross Origin Resource Sharing (CORS),
  making cross-origin AJAX possible. Based on
  `flask-cors <https://github.com/corydolphin/flask-cors>`__ by Cory Dolphin.
  This package has a simple philosophy, when you want to enable CORS, you
  wish to enable it for all use cases on a domain. This means no mucking
  around with different allowed headers, methods, etc. By default,
  submission of cookies across domains is disabled due to the security
  implications, please see the documentation for how to enable
  credential'ed requests, and please make sure you add some sort of
  `CSRF <http://en.wikipedia.org/wiki/Cross-site_request_forgery>`__
  protection before doing so!
  **Sept 2022 Notice:**
  If you are having unexpected results in Sanic v22.9+, upgrade to Sanic-CORS v2.2.0
  **December 2021 Notice:**
  If you need compatibility with Sanic v21.12+, upgrade to Sanic-CORS v2.0
  **Sept 2021 Notice:**
  Please upgrade to Sanic-CORS v1.0.1 if you need compatibility with Sanic v21.9,<21.12


pkgId: 6b881805ead39fc644a697cf2e0c9174f0e649a657919a6d50cd9e16f9bfa78e
name: python-Sanic-Plugins-Framework
arch: src
version: 0.9.5
epoch: 0
release: 1
summary: Doing all of the boilerplate to create a Sanic Plugin, so you don't have to.
url: https://github.com/ashleysommer/sanicpluginsframework
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1724bd94-fbf4-4cd8-b3b0-6191aa7584a0
location_href: 00011619-python-sanic-plugins-framework/python-Sanic-Plugins-Framework-0.9.5-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Latest Version| |Supported Python versions| |License|
  Welcome to the Sanic Plugins Framework.
  The Sanic Plugins Framework (SPF) is a lightweight python library aimed at making it as simple as possible to build
  plugins for the Sanic Async HTTP Server.
  The SPF provides a `SanicPlugin` python base object that your plugin can build upon. It is set up with all of the basic
  functionality that the majority of Sanic Plugins will need.
  A SPF Sanic Plugin is implemented in a similar way to Sanic Blueprints. You can use convenience decorators to set up all
  of the routes, middleware, exception handlers, and listeners your plugin uses in the same way you would a blueprint,
  and any Application developer can import your plugin and register it into their application.
  The Sanic Plugins Framework is more than just a Blueprints-like system for Plugins. It provides an enhanced middleware
  system, and manages Context objects.
  **Notice:** Please update to SPF v0.9.0 if you need compatibility with Sanic v19.12+. See `here <https://github.com/huge-success/sanic/issues/1749#issuecomment-571881532>`_ for more details.


pkgId: 54527f9ecd055320986fc1bbddbee49f57e554df90a9ebe61e12be11cb798b83
name: python-SecretStorage
arch: src
version: 3.3.3
epoch: 0
release: 1
summary: Python bindings to FreeDesktop.org Secret Service API
url: https://github.com/mitya57/secretstorage
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eff2d4d0-bab2-43df-84e2-fcca69f22ab3
location_href: 00005050-python-secretstorage/python-SecretStorage-3.3.3-1.src.rpm
checksum_type: sha256
description:
  This module provides a way for securely storing passwords and other secrets.
  It uses D-Bus `Secret Service`_ API that is supported by GNOME Keyring,
  KWallet (since version 5.97) and KeePassXC.
  The main classes provided are ``secretstorage.Item``, representing a secret
  item (that has a *label*, a *secret* and some *attributes*) and
  ``secretstorage.Collection``, a place items are stored in.
  SecretStorage supports most of the functions provided by Secret Service,
  including creating and deleting items and collections, editing items,
  locking and unlocking collections (asynchronous unlocking is also supported).
  The documentation can be found on `secretstorage.readthedocs.io`_.


pkgId: 474eb61d99a7d40cb455c79bcc872cefcafe9e7514a6b402896679661c4abb02
name: python-ShopifyAPI
arch: src
version: 12.2.0
epoch: 0
release: 1
summary: Shopify API for Python
url: https://github.com/Shopify/shopify_python_api
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-37969089-1588-4839-9b9f-5beca10fa180
location_href: 00010992-python-shopifyapi/python-ShopifyAPI-12.2.0-1.src.rpm
checksum_type: sha256
description:
  The ShopifyAPI library allows python developers to programmatically
  access the admin section of stores using an ActiveResource like
  interface similar the ruby Shopify API gem. The library makes HTTP
  requests to Shopify in order to list, create, update, or delete
  resources (e.g. Order, Product, Collection).


pkgId: cb1aa21c58c359f57ac4de9d22532087ab1a09601ccf72a767d2641f8349dc26
name: python-South
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: South: Migrations for Django
url: http://south.aeracode.org/
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-be9646a7-6611-4f08-94da-970a89b507d5
location_href: 00012486-python-south/python-South-1.0.2-1.src.rpm
checksum_type: sha256
description:
  South is an intelligent database migrations library for the Django web framework. It is database-independent and DVCS-friendly, as well as a whole host of other features.


pkgId: ef0ba877f11d429f09571ecbbfb6b6f4376a8aa57186a0dce254887606d96b14
name: python-SudachiDict-full
arch: src
version: 20230110
epoch: 0
release: 1
summary: Sudachi Dictionary for SudachiPy - Full Edition
url: https://github.com/WorksApplications/SudachiDict
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12bb2b40-53a9-4d0c-a6ae-1940c227ac3e
location_href: 00010973-python-sudachidict-full/python-SudachiDict-full-20230110-1.src.rpm
checksum_type: sha256
description:
  - [WorksApplications/SudachiDict](https://github.com/WorksApplications/SudachiDict)
  - [WorksApplications/SudachiPy](https://github.com/WorksApplications/SudachiPy)

  Managing the dictionary resources as Python packages.

  - [SudachiDict-small · PyPI](https://pypi.org/project/SudachiDict-small/)
  - [SudachiDict-core · PyPI](https://pypi.org/project/SudachiDict-core/)
  - [SudachiDict-full · PyPI](https://pypi.org/project/SudachiDict-full/)

  The dictionary files are not included in the packages; It will be downloaded upon installation (the procedure in `setup.py`).

  The version (e.g., `20200330`) and the edition (`small`, `core`, or `full`) is specified in `INFO.json`.



  In SudachiPy v0.5.2 and later, you can specify a dictionary directly from a command line or program.

  **WARNING: `sudachipy link` is no longer available in SudachiPy v0.5.2 and later.**

  Please see the following links for more details on the dictionary option.

  - english
    - [https://github.com/WorksApplications/SudachiPy#dictionary-edition](https://github.com/WorksApplications/SudachiPy#dictionary-edition)
  - japanese
    - [https://github.com/WorksApplications/SudachiPy/blob/develop/docs/tutorial.md#辞書の種類](https://github.com/WorksApplications/SudachiPy/blob/develop/docs/tutorial.md#%E8%BE%9E%E6%9B%B8%E3%81%AE%E7%A8%AE%E9%A1%9E)



  ```bash
  pip install sudachidict_core
  ```

  ```bash
  pip install sudachidict_small
  ```

  ```bash
  pip install sudachidict_full
  ```



  In case you are using SudachiPy before v0.5.2, please visit the old SudachiPy documentation.

  - english
    - [https://github.com/WorksApplications/SudachiPy/tree/v0.5.1#dictionary-edition](https://github.com/WorksApplications/SudachiPy/tree/v0.5.1#dictionary-edition)
  - japanese
    - [https://github.com/WorksApplications/SudachiPy/blob/v0.5.1/docs/tutorial.md#%辞書の種類](https://github.com/WorksApplications/SudachiPy/blob/v0.5.1/docs/tutorial.md#%E8%BE%9E%E6%9B%B8%E3%81%AE%E7%A8%AE%E9%A1%9E)


pkgId: b8b06f7b40112fb8b1b2a283ad5cd6439b6874c65b66287f0833bd83e6c1a9da
name: python-SuperSuit
arch: src
version: 3.7.2
epoch: 0
release: 1
summary: Wrappers for Gymnasium and PettingZoo
url: https://github.com/Farama-Foundation/SuperSuit
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c269904-6021-4575-8b81-363d4507ed93
location_href: 00012500-python-supersuit/python-SuperSuit-3.7.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://raw.githubusercontent.com/Farama-Foundation/SuperSuit/master/supersuit-text.png" width="500px"/>
  </p>


  SuperSuit introduces a collection of small functions which can wrap reinforcement learning environments to do preprocessing ('microwrappers').
  We support Gymnasium for single agent environments and PettingZoo for multi-agent environments (both AECEnv and ParallelEnv environments).


  Using it with Gymnasium to convert space invaders to have a grey scale observation space and stack the last 4 frames looks like:

  ```
  import gymnasium
  from supersuit import color_reduction_v0, frame_stack_v1

  env = gymnasium.make('SpaceInvaders-v0')

  env = frame_stack_v1(color_reduction_v0(env, 'full'), 4)
  ```

  Similarly, using SuperSuit with PettingZoo environments looks like

  ```
  from pettingzoo.butterfly import pistonball_v0
  env = pistonball_v0.env()

  env = frame_stack_v1(color_reduction_v0(env, 'full'), 4)
  ```


  **Please note**: Once the planned wrapper rewrite of Gymnasium is complete and the vector API is stabilized, this project will be deprecated and rewritten as part of a new wrappers package in PettingZoo and the vectorized API will be redone, taking inspiration from the functionality currently in Gymnasium.


  To install SuperSuit from pypi:

  ```
  python3 -m venv env
  source env/bin/activate
  pip install --upgrade pip
  pip install supersuit
  ```

  Alternatively, to install SuperSuit from source, clone this repo, `cd` to it, and then:

  ```
  python3 -m venv env
  source env/bin/activate
  pip install --upgrade pip
  pip install -e .
  ```


pkgId: a2974e4df9462a601f0cb726c69a68c7d77f7db6ddb508c68aaf822a9c20ddb0
name: python-TGScheduler
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Pure Python Scheduler
url: https://bitbucket.org/xcg/tgscheduler
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e7607a68-d9b5-4f2d-83e7-48982ec07b78
location_href: 00002885-python-TGScheduler/python-TGScheduler-1.7.0-1.src.rpm
checksum_type: sha256
description:
  This is a pure Python scheduler that can be used in any application. Tasks can be run in-process
  (within threads), forked (as new processes) or synchronously into the code.
  The scheduler makes it easy to have one-time or recurring tasks run as needed.


pkgId: 73ad7fb16e098e63d8eaf074ce001a0dc6d53eef46154cb7de0b28edbc7823d0
name: python-TatSu
arch: src
version: 5.8.3
epoch: 0
release: 1
url: https://github.com/neogeny/tatsu
rpm_license: BSD-3-Clause-Attribution
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-060b790b-0857-41ec-92e1-d32abb17fd2a
location_href: 00012378-python-tatsu/python-TatSu-5.8.3-1.src.rpm
checksum_type: sha256
summary:
  TatSu takes a grammar in a variation of EBNF as input, and outputs a memoizing PEG/Packrat parser in Python.

description:
  |TatSu| is a tool that takes grammars in a variation of `EBNF`_ as input, and
  outputs `memoizing`_ (`Packrat`_) `PEG`_ parsers in `Python`_.
  Why use a PEG_ parser? Because `regular languages`_ (those parsable with Python's ``re`` package) *"cannot count"*. Any language with nested structures or with balancing of demarcations requires more than regular expressions to be parsed.
  |TatSu| can compile a grammar stored in a string into a
  ``tatsu.grammars.Grammar`` object that can be used to parse any given
  input, much like the `re`_ module does with regular expressions, or it can generate a Python_ module that implements the parser.
  |TatSu| supports `left-recursive`_  rules in PEG_ grammars using the
  algorithm_ by *Laurent* and *Mens*. The generated AST_ has the expected left associativity.
  Starting with version 5.8.0 |TatSu| requires Python 3.10 or later.
  While no code in |TatSu| yet depends on new language or standard library features,
  the authors don't want to be constrained by Python version comaptibility consideration
  when developing features that will be part future releases.
  Therefore, to simplify version pinning for users of the library,
  they decided to proactively bump the Python minimum required version to 3.10.
  |TatSu| releases in the 5.7 series closely track releases in the 5.8 series
  while maintaining compatibility with Python 3.8 and later.
  Bug fixes are back-ported from 5.8 releases.
  Features are back-ported from the 5.8 releases
  unless they depend on Python features not available on the supported Python versions.
  Refer to the `CHANGELOG`_ for details.


pkgId: b3215d8678f0c5c32d0247c376d7abff06d00d7e855b1bdf0ede0ca1b5bb2e2d
name: python-Telethon
arch: src
version: 1.28.2
epoch: 0
release: 1
summary: Full-featured Telegram client library for Python 3
url: https://github.com/LonamiWebs/Telethon
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb128f95-53ec-4be4-83f3-652bbec0fb3b
location_href: 00009326-python-telethon/python-Telethon-1.28.2-1.src.rpm
checksum_type: sha256
description:
    ⭐️ Thanks **everyone** who has starred the project, it means a lot!
  |logo| **Telethon** is an asyncio_ **Python 3**
  MTProto_ library to interact with Telegram_'s API
  as a user or through a bot account (bot API alternative).
      If you have code using Telethon before its 1.0 version, you must
      read `Compatibility and Convenience`_ to learn how to migrate.


pkgId: 0eb063188d0c98be0718790c595aaebe417c39840eacb31e7b0b9642c149c363
name: python-TestLink-API-Python-client
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Python XML-RPC client for TestLink DEV 1.9.20 (github a1c7aca97)
url: https://github.com/lczub/TestLink-API-Python-client
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a13c6e1-71dd-46f5-a8d7-4b312e00b54d
location_href: 00013556-python-testlink-api-python-client/python-TestLink-API-Python-client-0.8.1-1.src.rpm
checksum_type: sha256
description:
  TestLink-API-Python-client is a Python XML-RPC client for TestLink_.

  Initially based on James Stock testlink-api-python-client R7 and  Olivier
  Renault JinFeng_ idea - an interaction of TestLink_, `Robot Framework`_ and Jenkins_.

  TestLink-API-Python-client delivers two main classes

  - TestlinkAPIGeneric - Implements the TestLink API methods as generic PY methods
    with error handling
  - TestlinkAPIClient - Inherits from TestlinkAPIGeneric and defines service
    methods like "copyTCnewVersion".

  and the helper class

  - TestLinkHelper - search connection parameter from environment variables and
    command line arguments

  How to talk with TestLink in a python shell and copy a test case: ::

   set TESTLINK_API_PYTHON_SERVER_URL=http://[YOURSERVER]/testlink/lib/api/xmlrpc/v1/xmlrpc.php
   set TESTLINK_API_PYTHON_DEVKEY=[Users devKey generated by TestLink]
   python
   >>> import testlink
   >>> tls = testlink.TestLinkHelper().connect(testlink.TestlinkAPIClient)
   >>> tls.countProjects()
   3
   >>> tc_info = tls.getTestCase(None, testcaseexternalid='NPROAPI-3')
   [{'full_tc_external_id': 'NPROAPI-3', ..., 'id': '5440',  'version': '2',
     'testsuite_id': '5415', 'tc_external_id': '3','testcase_id': '5425', ...}]
   >>> tls.copyTCnewTestCase(tc_info[0]['testcase_id'], testsuiteid=newSuiteID,
                                            testcasename='a new test case name')
   >>> print tls.whatArgs('createTestPlan')
   createTestPlan(<testplanname>, <testprojectname>, [note=<note>], [active=<active>],
                  [public=<public>], [devKey=<devKey>])
     create a test plan

  More information about this library can be found on the Wiki_

  .. _TestLink: http://testlink.org
  .. _JinFeng: http://www.sqaopen.net/blog/en/?p=63
  .. _Robot Framework: http://code.google.com/p/robotframework
  .. _Jenkins: http://jenkins-ci.org
  .. _Wiki: https://github.com/lczub/TestLink-API-Python-client/wiki


pkgId: 9a86f30719d8a503fac2e04075677513b8bffcb3dbbab8b22ae711a05cd955d1
name: python-TestLink-API-Python-client-help
arch: noarch
version: 0.8.1
epoch: 0
release: 1
summary: Development documents and examples for TestLink-API-Python-client
url: https://github.com/lczub/TestLink-API-Python-client
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a13c6e1-71dd-46f5-a8d7-4b312e00b54d
rpm_sourcerpm: python-TestLink-API-Python-client-0.8.1-1.src.rpm
checksum_type: sha256
description:
  TestLink-API-Python-client is a Python XML-RPC client for TestLink_.

  Initially based on James Stock testlink-api-python-client R7 and  Olivier
  Renault JinFeng_ idea - an interaction of TestLink_, `Robot Framework`_ and Jenkins_.

  TestLink-API-Python-client delivers two main classes

  - TestlinkAPIGeneric - Implements the TestLink API methods as generic PY methods
    with error handling
  - TestlinkAPIClient - Inherits from TestlinkAPIGeneric and defines service
    methods like "copyTCnewVersion".

  and the helper class

  - TestLinkHelper - search connection parameter from environment variables and
    command line arguments

  How to talk with TestLink in a python shell and copy a test case: ::

   set TESTLINK_API_PYTHON_SERVER_URL=http://[YOURSERVER]/testlink/lib/api/xmlrpc/v1/xmlrpc.php
   set TESTLINK_API_PYTHON_DEVKEY=[Users devKey generated by TestLink]
   python
   >>> import testlink
   >>> tls = testlink.TestLinkHelper().connect(testlink.TestlinkAPIClient)
   >>> tls.countProjects()
   3
   >>> tc_info = tls.getTestCase(None, testcaseexternalid='NPROAPI-3')
   [{'full_tc_external_id': 'NPROAPI-3', ..., 'id': '5440',  'version': '2',
     'testsuite_id': '5415', 'tc_external_id': '3','testcase_id': '5425', ...}]
   >>> tls.copyTCnewTestCase(tc_info[0]['testcase_id'], testsuiteid=newSuiteID,
                                            testcasename='a new test case name')
   >>> print tls.whatArgs('createTestPlan')
   createTestPlan(<testplanname>, <testprojectname>, [note=<note>], [active=<active>],
                  [public=<public>], [devKey=<devKey>])
     create a test plan

  More information about this library can be found on the Wiki_

  .. _TestLink: http://testlink.org
  .. _JinFeng: http://www.sqaopen.net/blog/en/?p=63
  .. _Robot Framework: http://code.google.com/p/robotframework
  .. _Jenkins: http://jenkins-ci.org
  .. _Wiki: https://github.com/lczub/TestLink-API-Python-client/wiki

location_href:
  00013556-python-testlink-api-python-client/python-TestLink-API-Python-client-help-0.8.1-1.noarch.rpm


pkgId: 41a41f29e273348e27d8de527a3979606534e1683be97b94a514d6897a90e037
name: python-TestSlide
arch: src
version: 2.7.0
epoch: 0
release: 1
summary: A test framework for Python that makes mocking and iterating over code with tests a breeze
url: https://github.com/facebook/TestSlide
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-258d5eb8-c014-44db-9c85-769684c0fc9d
location_href: 00002886-python-TestSlide/python-TestSlide-2.7.0-1.src.rpm
checksum_type: sha256
description:
  ![TestSlide](./docs/testslide_logo.png)

  [![Build Status](https://github.com/facebook/TestSlide/workflows/CI/badge.svg)](https://github.com/facebook/TestSlide/actions?query=workflow%3ACI)
  [![Coverage Status](https://coveralls.io/repos/github/facebook/TestSlide/badge.svg?branch=main)](https://coveralls.io/github/facebook/TestSlide?branch=main)
  [![Documentation Status](https://readthedocs.org/projects/testslide/badge/?version=main)](https://testslide.readthedocs.io/en/main/?badge=main)
  [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
  [![PyPI version](https://badge.fury.io/py/TestSlide.svg)](https://badge.fury.io/py/TestSlide)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  A test framework for Python that enable [unit testing](https://docs.python.org/3/library/unittest.html) / [TDD](https://en.wikipedia.org/wiki/Test-driven_development) / [BDD](https://en.wikipedia.org/wiki/Behavior-driven_development) to be productive and enjoyable.

  Its well behaved mocks with thorough API validations catches bugs both when code is first written or long in the future when it is changed.

  The flexibility of using them with existing `unittest.TestCase` or TestSlide's own test runner let users get its benefits without requiring refactoring existing code.



  Install:

  ```
  pip install TestSlide
  ```

  Scaffold the code you want to test `backup.py`:

  ```python
  class Backup:
    def delete(self, path):
      pass
  ```

  Write a test case `backup_test.py` describing the expected behavior:

  ```python
  import testslide, backup, storage

  class TestBackupDelete(testslide.TestCase):
    def setUp(self):
      super().setUp()
      self.storage_mock = testslide.StrictMock(storage.Client)
      
      self.mock_constructor(storage, 'Client')\
        .for_call(timeout=60)\
        .to_return_value(self.storage_mock)

    def test_delete_from_storage(self):
      
      self.mock_callable(self.storage_mock, 'delete')\
        .for_call('/file/to/delete')\
        .to_return_value(True)\
        .and_assert_called_once()
      backup.Backup().delete('/file/to/delete')
  ```

  TestSlide's `StrictMock`, `mock_constructor()` and `mock_callable()` are seamlessly integrated with Python's TestCase.

  Run the test and see the failure:

  ![Failing test](https://raw.githubusercontent.com/facebook/TestSlide/main/docs/test_fail.png)

  TestSlide's mocks failure messages guide you towards the solution, that you can now implement:

  ```python
  import storage

  class Backup:
    def __init__(self):
      self.storage = storage.Client(timeout=60)

    def delete(self, path):
      self.storage.delete(path)
  ```

  And watch the test go green:

  ![Passing test](https://raw.githubusercontent.com/facebook/TestSlide/main/docs/test_pass.png)

  It is all about letting the failure messages guide you towards the solution. There's a plethora of validation inside TestSlide's mocks, so you can trust they will help you iterate quickly when writing code and also cover you when breaking changes are introduced.



  There's a lot more that TestSlide can offer, please check the full documentation at https://testslide.readthedocs.io/ to learn more.



  * Linux
  * Python 3



  TestSlide is open source software, contributions are very welcome!

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



  TestSlide is MIT licensed, as found in the [LICENSE](LICENSE) file.




  https://opensource.facebook.com/legal/terms




  https://opensource.facebook.com/legal/privacy


pkgId: 112e678fa4bceed685f734634b5d465d336a8a611733f6fa5af90e45bba86e70
name: python-TestSlide
arch: src
version: 2.7.1
epoch: 0
release: 1
summary: A test framework for Python that makes mocking and iterating over code with tests a breeze
url: https://github.com/facebook/TestSlide
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4c08b9b9-e21f-4105-8d82-3b0cdb69c869
location_href: 00006266-python-TestSlide/python-TestSlide-2.7.1-1.src.rpm
checksum_type: sha256
description:
  ![TestSlide](./docs/testslide_logo.png)

  [![Build Status](https://github.com/facebook/TestSlide/workflows/CI/badge.svg)](https://github.com/facebook/TestSlide/actions?query=workflow%3ACI)
  [![Coverage Status](https://coveralls.io/repos/github/facebook/TestSlide/badge.svg?branch=main)](https://coveralls.io/github/facebook/TestSlide?branch=main)
  [![Documentation Status](https://readthedocs.org/projects/testslide/badge/?version=main)](https://testslide.readthedocs.io/en/main/?badge=main)
  [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
  [![PyPI version](https://badge.fury.io/py/TestSlide.svg)](https://badge.fury.io/py/TestSlide)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  A test framework for Python that enable [unit testing](https://docs.python.org/3/library/unittest.html) / [TDD](https://en.wikipedia.org/wiki/Test-driven_development) / [BDD](https://en.wikipedia.org/wiki/Behavior-driven_development) to be productive and enjoyable.

  Its well behaved mocks with thorough API validations catches bugs both when code is first written or long in the future when it is changed.

  The flexibility of using them with existing `unittest.TestCase` or TestSlide's own test runner let users get its benefits without requiring refactoring existing code.



  Install:

  ```
  pip install TestSlide
  ```

  Scaffold the code you want to test `backup.py`:

  ```python
  class Backup:
    def delete(self, path):
      pass
  ```

  Write a test case `backup_test.py` describing the expected behavior:

  ```python
  import testslide, backup, storage

  class TestBackupDelete(testslide.TestCase):
    def setUp(self):
      super().setUp()
      self.storage_mock = testslide.StrictMock(storage.Client)
      
      self.mock_constructor(storage, 'Client')\
        .for_call(timeout=60)\
        .to_return_value(self.storage_mock)

    def test_delete_from_storage(self):
      
      self.mock_callable(self.storage_mock, 'delete')\
        .for_call('/file/to/delete')\
        .to_return_value(True)\
        .and_assert_called_once()
      backup.Backup().delete('/file/to/delete')
  ```

  TestSlide's `StrictMock`, `mock_constructor()` and `mock_callable()` are seamlessly integrated with Python's TestCase.

  Run the test and see the failure:

  ![Failing test](https://raw.githubusercontent.com/facebook/TestSlide/main/docs/test_fail.png)

  TestSlide's mocks failure messages guide you towards the solution, that you can now implement:

  ```python
  import storage

  class Backup:
    def __init__(self):
      self.storage = storage.Client(timeout=60)

    def delete(self, path):
      self.storage.delete(path)
  ```

  And watch the test go green:

  ![Passing test](https://raw.githubusercontent.com/facebook/TestSlide/main/docs/test_pass.png)

  It is all about letting the failure messages guide you towards the solution. There's a plethora of validation inside TestSlide's mocks, so you can trust they will help you iterate quickly when writing code and also cover you when breaking changes are introduced.



  There's a lot more that TestSlide can offer, please check the full documentation at https://testslide.readthedocs.io/ to learn more.



  * Linux
  * Python 3



  TestSlide is open source software, contributions are very welcome!

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



  TestSlide is MIT licensed, as found in the [LICENSE](LICENSE) file.




  https://opensource.facebook.com/legal/terms




  https://opensource.facebook.com/legal/privacy



  Copyright © 2021 Meta Platforms, Inc


pkgId: a2e9fb87728816cdf0918628e89c93c1d0b4ec219b1629cd9e2a53519455c679
name: python-TgCrypto
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: Fast and Portable Cryptography Extension Library for Pyrogram
url: https://github.com/pyrogram
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-815b17af-e228-4b46-bb62-ef97164dccb4
location_href: 00009692-python-tgcrypto/python-TgCrypto-1.2.5-1.src.rpm
checksum_type: sha256
description:
  > Fast and Portable Cryptography Extension Library for Pyrogram

  **TgCrypto** is a Cryptography Library written in C as a Python extension. It is designed to be portable, fast,
  easy to install and use. TgCrypto is intended for [Pyrogram](https://github.com/pyrogram/pyrogram) and implements the
  cryptographic algorithms Telegram requires, namely:

  - **`AES-256-IGE`** - used in [MTProto v2.0](https://core.telegram.org/mtproto).
  - **`AES-256-CTR`** - used for [CDN encrypted files](https://core.telegram.org/cdn).
  - **`AES-256-CBC`** - used for [encrypted passport credentials](https://core.telegram.org/passport).



  - Python 3.7 or higher.



  ``` bash
  $ pip3 install -U tgcrypto
  ```



  TgCrypto API consists of these six methods:

  ```python
  def ige256_encrypt(data: bytes, key: bytes, iv: bytes) -> bytes: ...
  def ige256_decrypt(data: bytes, key: bytes, iv: bytes) -> bytes: ...

  def ctr256_encrypt(data: bytes, key: bytes, iv: bytes, state: bytes) -> bytes: ...
  def ctr256_decrypt(data: bytes, key: bytes, iv: bytes, state: bytes) -> bytes: ...

  def cbc256_encrypt(data: bytes, key: bytes, iv: bytes) -> bytes: ...
  def cbc256_decrypt(data: bytes, key: bytes, iv: bytes) -> bytes: ...
  ```





  **Note**: Data must be padded to match a multiple of the block size (16 bytes).

  ``` python
  import os

  import tgcrypto

  data = os.urandom(10 * 1024 * 1024 + 7)  # 10 MB of random data + 7 bytes to show padding
  key = os.urandom(32)  # Random Key
  iv = os.urandom(32)  # Random IV


  data += bytes(-len(data) % 16)

  ige_encrypted = tgcrypto.ige256_encrypt(data, key, iv)
  ige_decrypted = tgcrypto.ige256_decrypt(ige_encrypted, key, iv)

  print(data == ige_decrypted)  # True
  ```



  ``` python
  import os

  import tgcrypto

  data = os.urandom(10 * 1024 * 1024)  # 10 MB of random data

  key = os.urandom(32)  # Random Key

  enc_iv = bytearray(os.urandom(16))  # Random IV
  dec_iv = enc_iv.copy()  # Keep a copy for decryption

  ctr_encrypted = tgcrypto.ctr256_encrypt(data, key, enc_iv, bytes(1))
  ctr_decrypted = tgcrypto.ctr256_decrypt(ctr_encrypted, key, dec_iv, bytes(1))

  print(data == ctr_decrypted)  # True
  ```



  ``` python
  import os
  from io import BytesIO

  import tgcrypto

  data = BytesIO(os.urandom(10 * 1024 * 1024))  # 10 MB of random data

  key = os.urandom(32)  # Random Key

  enc_iv = bytearray(os.urandom(16))  # Random IV
  dec_iv = enc_iv.copy()  # Keep a copy for decryption

  enc_state = bytes(1)  # Encryption state, starts from 0
  dec_state = bytes(1)  # Decryption state, starts from 0

  encrypted_data = BytesIO()  # Encrypted data buffer
  decrypted_data = BytesIO()  # Decrypted data buffer

  while True:
      chunk = data.read(1024)

      if not chunk:
          break

      
      encrypted_data.write(tgcrypto.ctr256_encrypt(chunk, key, enc_iv, enc_state))


  encrypted_data.seek(0)

  while True:
      chunk = encrypted_data.read(1024)

      if not chunk:
          break

      
      decrypted_data.write(tgcrypto.ctr256_decrypt(chunk, key, dec_iv, dec_state))

  print(data.getvalue() == decrypted_data.getvalue())  # True
  ```



  **Note**: Data must be padded to match a multiple of the block size (16 bytes).

  ``` python
  import os

  import tgcrypto

  data = os.urandom(10 * 1024 * 1024 + 7)  # 10 MB of random data + 7 bytes to show padding
  key = os.urandom(32)  # Random Key

  enc_iv = bytearray(os.urandom(16))  # Random IV
  dec_iv = enc_iv.copy()  # Keep a copy for decryption


  data += bytes(-len(data) % 16)

  cbc_encrypted = tgcrypto.cbc256_encrypt(data, key, enc_iv)
  cbc_decrypted = tgcrypto.cbc256_decrypt(cbc_encrypted, key, dec_iv)

  print(data == cbc_decrypted)  # True
  ```



  1. Clone this repository: `git clone https://github.com/pyrogram/tgcrypto`.
  2. Enter the directory: `cd tgcrypto`.
  3. Install `tox`: `pip3 install tox`
  4. Run tests: `tox`.



  [LGPLv3+](COPYING.lesser) © 2017-present [Dan](https://github.com/delivrance)


pkgId: cca36919d82f91a9b68db3ca7daa5fd02cf22b95f31632e58096837d8c5128b1
name: python-TgCrypto-debuginfo
arch: aarch64
version: 1.2.5
epoch: 0
release: 1
summary: Debug information for package python-TgCrypto
url: https://github.com/pyrogram
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-815b17af-e228-4b46-bb62-ef97164dccb4
rpm_sourcerpm: python-TgCrypto-1.2.5-1.src.rpm
location_href: 00009692-python-tgcrypto/python-TgCrypto-debuginfo-1.2.5-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-TgCrypto.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 75ef75c664b0288e18f94d7ac214604818eaf5673744101baf86d894f4d72a09
name: python-TgCrypto-debugsource
arch: aarch64
version: 1.2.5
epoch: 0
release: 1
summary: Debug sources for package python-TgCrypto
url: https://github.com/pyrogram
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-815b17af-e228-4b46-bb62-ef97164dccb4
rpm_sourcerpm: python-TgCrypto-1.2.5-1.src.rpm
location_href: 00009692-python-tgcrypto/python-TgCrypto-debugsource-1.2.5-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-TgCrypto.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: bf6b9e53a4d11961659ad7206396b2e0376d8e0e747ac19950dad1bfd67303a2
name: python-Theano-PyMC
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Optimizing compiler for evaluating mathematical expressions on CPUs and GPUs.
url: http://deeplearning.net/software/theano/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd7d5302-71e2-4a11-a7b6-94f179bfaf0d
location_href: 00010761-python-theano-pymc/python-Theano-PyMC-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Theano is a Python library that allows you to define, optimize, and efficiently evaluate mathematical expressions involving multi-dimensional arrays. It is built on top of NumPy_. Theano features:

   * **tight integration with NumPy:** a similar interface to NumPy's. numpy.ndarrays are also used internally in Theano-compiled functions.
   * **transparent use of a GPU:** perform data-intensive computations up to 140x faster than on a CPU (support for float32 only).
   * **efficient symbolic differentiation:** Theano can compute derivatives for functions of one or many inputs.
   * **speed and stability optimizations:** avoid nasty bugs when computing expressions such as log(1 + exp(x)) for large values of x.
   * **dynamic C code generation:** evaluate expressions faster.
   * **extensive unit-testing and self-verification:** includes tools for detecting and diagnosing bugs and/or potential problems.

  Theano has been powering large-scale computationally intensive scientific
  research since 2007, but it is also approachable enough to be used in the
  classroom (IFT6266 at the University of Montreal).

  .. _NumPy: http://numpy.scipy.org/


pkgId: b447b0dd4834a233acc5243b72902207964e4609e54db59d2baf1f1cd351ec27
name: python-Trololio
arch: src
version: 1.0
epoch: 0
release: 1
summary: Trollius and asyncio compatibility library
url: http://github.com/ThinkChaos/Trololio/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9af30538-c5bf-4a86-b0e1-08f9831f4c26
location_href: 00005341-python-trololio/python-Trololio-1.0-1.src.rpm
checksum_type: sha256
description:
  Trololio: Trollius and asyncio compatibility library


  Trololio provides a compatibility layer for Trollius and asyncio (aka Tulip).
  It addresses the differences listed in `Trollius and Tulip
  <http://trollius.readthedocs.org/asyncio.html>`_:

  * Allows the use of Trollius' syntax with asyncio.
  * Provides missing objects and aliases for the others.
  * Synchronizes debug environnement variables.

  *****
  Links
  *****

  * `Trololio documentation <http://trololio.readthedocs.org/>`_
  * `Trollius documentation <http://trollius.readthedocs.org/>`_
  * `asyncio documentation <https://docs.python.org/3/library/asyncio.html>`_


pkgId: 9dfca5359e78bd0a5074ae16fe8c3128b982d9bdc170a6e2efdbcde1b59c087a
name: python-TurboGears2
arch: src
version: 2.4.3
epoch: 0
release: 1
summary: Next generation TurboGears
url: http://www.turbogears.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2a8ab377-a27a-42e2-97b5-7459eb42169b
location_href: 00002889-python-TurboGears2/python-TurboGears2-2.4.3-1.src.rpm
checksum_type: sha256
description:
  TurboGears brings together a best of breed python tools
  to create a flexible, full featured, and easy to use web
  framework.

  TurboGears 2 provides an integrated and well tested set of tools for
  everything you need to build dynamic, database driven applications.
  It provides a full range of tools for front end javascript
  develeopment, back database development and everything in between:

   * dynamic javascript powered widgets (ToscaWidgets2)
   * automatic JSON generation from your controllers
   * powerful, designer friendly XHTML based templating
   * object or route based URL dispatching
   * powerful Object Relational Mappers (SQLAlchemy)

  The latest development version is available in the
  `TurboGears Git repositories`_.

  .. _TurboGears Git repositories:
      https://github.com/TurboGears


pkgId: 4d0fa711fe7ebf4182ed9fcc5a87c135dfc30bd8e73eb658c4345c36a5293d9b
name: python-Twiggy
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: a Pythonic logger
url: https://github.com/wearpants/twiggy/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ec31891f-80bd-47db-a097-4d07ec8f9138
location_href: 00005348-python-twiggy/python-Twiggy-0.5.1-1.src.rpm
checksum_type: sha256
description:
  Twiggy is a Pythonic logger.
      >>> from twiggy import quick_setup, log
      >>> quick_setup()
      >>> log.name('frank') \
                   'sunny',
                   who='world')
      INFO:frank:number=42:hello world, it's a sunny day
  You should use Twiggy because it is awesome. For more information, read the
  `documentation <https://twiggy.readthedocs.io/en/latest/>`_ or `see this blog post
  <https://wearpants.org/petecode/meet-twiggy/>`_.


pkgId: 79a0333f93ba48ae01648066cf662e6dde6e2cc7cede532df0b6c5ed64293b8e
name: python-UPnPy
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: Lightweight UPnP client library for Python.
url: https://github.com/5kyc0d3r/upnpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0a047578-aac5-4e7b-992d-5c43af4a5823
location_href: 00005376-python-upnpy/python-UPnPy-1.1.8-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/5kyc0d3r/upnpy.svg?branch=master)](https://travis-ci.org/5kyc0d3r/upnpy)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/upnpy.svg)](https://pypi.org/project/UPnPy/)
  [![PyPI package version](https://img.shields.io/pypi/v/upnpy.svg)](https://pypi.org/project/UPnPy/)
  [![MIT License](https://img.shields.io/badge/license-MIT-red.svg)](https://github.com/5kyc0d3r/upnpy/blob/master/LICENSE)

  Lightweight UPnP client library for Python.


  ```
  $ pip install upnpy
  ```




  ```python
  import upnpy

  upnp = upnpy.UPnP()



  devices = upnp.discover()




  device = upnp.get_igd()




  device.get_services()







  service = device['WANPPPConnection.1']














  service.get_actions()




  service.GetExternalIPAddress()
  ```


  ```python
  import upnpy

  upnp = upnpy.UPnP()



  devices = upnp.discover()




  device = upnp.get_igd()




  device.get_services()







  service = device['WANPPPConnection.1']














  service.get_actions()




















































  service.AddPortMapping.get_input_arguments()



  service.AddPortMapping(
      NewRemoteHost='',
      NewExternalPort=80,
      NewProtocol='TCP',
      NewInternalPort=8000,
      NewInternalClient='192.168.1.3',
      NewEnabled=1,
      NewPortMappingDescription='Test port mapping entry from UPnPy.',
      NewLeaseDuration=0
  )
  ```


  Documentation is available at [https://upnpy.readthedocs.io/en/latest/](https://upnpy.readthedocs.io/en/latest/)


  This project is licensed under the terms of the [MIT License](https://github.com/5kyc0d3r/upnpy/blob/master/LICENSE).


pkgId: 6862207e237e42386be4000795a38ec18838551a9fbd3cd2ca1474063d703e1c
name: python-Unidecode
arch: src
version: 1.3.6
epoch: 0
release: 1
summary: ASCII transliterations of Unicode text
url: https://pypi.org/project/Unidecode/
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d15614e0-f767-4349-b2cb-9b0ec37584d8
location_href: 00005371-python-unidecode/python-Unidecode-1.3.6-1.src.rpm
checksum_type: sha256
description:
  It often happens that you have text data in Unicode, but you need to
  represent it in ASCII. For example when integrating with legacy code that
  doesn't support Unicode, or for ease of entry of non-Roman names on a US
  keyboard, or when constructing ASCII machine identifiers from human-readable
  Unicode strings that should still be somewhat intelligible. A popular example
  of this is when making an URL slug from an article title.
  **Unidecode is not a replacement for fully supporting Unicode for strings in
  your program. There are a number of caveats that come with its use,
  especially when its output is directly visible to users. Please read the rest
  of this README before using Unidecode in your project.**
  In most of examples listed above you could represent Unicode characters as
  ``???`` or ``\\15BA\\15A0\\1610``, to mention two extreme cases. But that's
  nearly useless to someone who actually wants to read what the text says.
  What Unidecode provides is a middle road: the function ``unidecode()`` takes
  Unicode data and tries to represent it in ASCII characters (i.e., the
  universally displayable characters between 0x00 and 0x7F), where the
  compromises taken when mapping between two character sets are chosen to be
  near what a human with a US keyboard would choose.
  The quality of resulting ASCII representation varies. For languages of
  western origin it should be between perfect and good. On the other hand
  transliteration (i.e., conveying, in Roman letters, the pronunciation
  expressed by the text in some other writing system) of languages like
  Chinese, Japanese or Korean is a very complex issue and this library does
  not even attempt to address it. It draws the line at context-free
  character-by-character mapping. So a good rule of thumb is that the further
  the script you are transliterating is from Latin alphabet, the worse the
  transliteration will be.
  Generally Unidecode produces better results than simply stripping accents from
  characters (which can be done in Python with built-in functions). It is based
  on hand-tuned character mappings that for example also contain ASCII
  approximations for symbols and non-Latin alphabets.
  **Note that some people might find certain transliterations offending.** Most
  common examples include characters that are used in multiple languages. A user
  expects a character to be transliterated in their language but Unidecode uses a
  transliteration for a different language. It's best to not use Unidecode for
  strings that are directly visible to users of your application. See also the
  *Frequently Asked Questions* section for more info on common problems.
  This is a Python port of ``Text::Unidecode`` Perl module by Sean M. Burke
  <sburke@cpan.org>.


pkgId: b31580ea09f4b9fcf7eba56d506b4268c079654543b2ab10ffe74118599eb806
name: python-Unipath
arch: src
version: 1.1
epoch: 0
release: 1
summary: Object-oriented alternative to os/os.path/shutil
url: https://github.com/mikeorr/Unipath
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a5afda92-03ce-4b70-a60b-00e423658dde
location_href: 00005373-python-unipath/python-Unipath-1.1-1.src.rpm
checksum_type: sha256
description:
  Unipath is an object-oriented front end to the file/directory functions
  scattered throughout several Python library modules.  It's based on Jason
  Orendorff's *path.py* but has a friendlier API and higher-level features.
  Unipath is stable, well-tested, and has been used in production since 2008.
  It runs on Python 2.6+ and 3.3+.

  **Version 1.1** is a bugfix release. Most notably it fixes a Unicode
  incompatibility on Python 3 under Windows (or operating systems with native
  Unicpde filenames). The license is changed to MIT (from the Python license).


pkgId: 23e52a0f15524e2c3ad78db8ed13a03830040333ea5451f77d9744b45f10f9ce
name: python-WTForms
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Form validation and rendering for Python web development.
url: https://wtforms.readthedocs.io/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-870fda46-2233-47d3-865e-c306c6ea4e11
location_href: 00005489-python-wtforms/python-WTForms-3.0.1-1.src.rpm
checksum_type: sha256
description:
  WTForms is a flexible forms validation and rendering library for Python
  web development. It can work with whatever web framework and template
  engine you choose. It supports data validation, CSRF protection,
  internationalization (I18N), and more. There are various community
  libraries that provide closer integration with popular frameworks.


pkgId: b704eb4c22a219a45907972da5f32362d32f1b1920a7aeb8c54fc6ee76de037e
name: python-Wand
arch: src
version: 0.6.11
epoch: 0
release: 1
summary: Ctypes-based simple MagickWand API binding for Python
url: http://wand-py.org/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a5ed5c3b-5b5d-4fda-9d03-ed1a391a18cd
location_href: 00005451-python-wand/python-Wand-0.6.11-1.src.rpm
checksum_type: sha256
description:
  Wand is a ``ctypes``-based simple ImageMagick_ binding for Python,
  supporting 2.7, 3.3+, and PyPy. All functionalities of MagickWand API are
  implemented in Wand.
  You can install the package from PyPI_ by using ``pip``:
     $ pip install Wand
  Or would you like to enjoy the bleeding edge?  Check out the head
  revision of the source code from the `GitHub repository`__:
     $ git clone git://github.com/emcconville/wand.git
     $ cd wand/
     $ python setup.py install
  __ https://github.com/emcconville/wand


pkgId: ab35c2904abe35af2998f2bb7039b60ea40c80f916a0491df19cc45eeb58370e
name: python-WebOb
arch: src
version: 1.8.7
epoch: 0
release: 1
summary: WSGI request and response object
url: http://webob.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d1bed74b-e2f3-4994-8e1c-2940d4397493
location_href: 00009294-python-webob/python-WebOb-1.8.7-1.src.rpm
checksum_type: sha256
description:
  WebOb provides objects for HTTP requests and responses.  Specifically
  it does this by wrapping the `WSGI <http://wsgi.readthedocs.io/en/latest/>`_ request
  environment and response status/headers/app_iter(body).
  The request and response objects provide many conveniences for parsing
  HTTP request and forming HTTP responses.  Both objects are read/write:
  as a result, WebOb is also a nice way to create HTTP requests and
  parse HTTP responses.


pkgId: ac6478fddc4387a40874473da8fdf884bcd75b3bb09ada1a41a8239af09cda25
name: python-Werkzeug
arch: src
version: 2.2.3
epoch: 0
release: 1
summary: The comprehensive WSGI web application library.
url: https://palletsprojects.com/p/werkzeug/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-06ea1701-dec8-4bd6-bbbc-b1063e975fb3
location_href: 00008914-python-werkzeug/python-Werkzeug-2.2.3-1.src.rpm
checksum_type: sha256
description:
  *werkzeug* German noun: "tool". Etymology: *werk* ("work"), *zeug* ("stuff")
  Werkzeug is a comprehensive `WSGI`_ web application library. It began as
  a simple collection of various utilities for WSGI applications and has
  become one of the most advanced WSGI utility libraries.
  It includes:
  -   An interactive debugger that allows inspecting stack traces and
      source code in the browser with an interactive interpreter for any
      frame in the stack.
  -   A full-featured request object with objects to interact with
      headers, query args, form data, files, and cookies.
  -   A response object that can wrap other WSGI applications and handle
      streaming data.
  -   A routing system for matching URLs to endpoints and generating URLs
      for endpoints, with an extensible system for capturing variables
      from URLs.
  -   HTTP utilities to handle entity tags, cache control, dates, user
      agents, cookies, files, and more.
  -   A threaded WSGI server for use while developing applications
      locally.
  -   A test client for simulating HTTP requests during testing without
      requiring running a server.
  Werkzeug doesn't enforce any dependencies. It is up to the developer to
  choose a template engine, database adapter, and even how to handle
  requests. It can be used to build all sorts of end user applications
  such as blogs, wikis, or bulletin boards.
  `Flask`_ wraps Werkzeug, using it to handle the details of WSGI while
  providing more structure and patterns for defining powerful
  applications.


pkgId: 564acb58583f021e298b7982db96cd072eeda702fd88862faa76e448a9abd786
name: python-Whoosh
arch: src
version: 2.7.4
epoch: 0
release: 1
summary: Fast, pure-Python full text indexing, search, and spell checking library.
url: http://bitbucket.org/mchaput/whoosh
rpm_license: Two-clause BSD license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-699f6e28-b36f-4d93-8c41-cb5044dcb0ea
location_href: 00010923-python-whoosh/python-Whoosh-2.7.4-1.src.rpm
checksum_type: sha256
description:
  Whoosh is a fast, featureful full-text indexing and searching library
  implemented in pure Python. Programmers can use it to easily add search
  functionality to their applications and websites. Every part of how Whoosh
  works can be extended or replaced to meet your needs exactly.
  Some of Whoosh's features include:
  * Pythonic API.
  * Pure-Python. No compilation or binary packages needed, no mysterious crashes.
  * Fielded indexing and search.
  * Fast indexing and retrieval -- faster than any other pure-Python, scoring,
    full-text search solution I know of.
  * Pluggable scoring algorithm (including BM25F), text analysis, storage,
    posting format, etc.
  * Powerful query language.
  * Pure Python spell-checker (as far as I know, the only one).
  Whoosh might be useful in the following circumstances:
  * Anywhere a pure-Python solution is desirable to avoid having to build/compile
    native libraries (or force users to build/compile them).
  * As a research platform (at least for programmers that find Python easier to
    read and work with than Java ;)
  * When an easy-to-use Pythonic interface is more important to you than raw
    speed.
  Whoosh was created and is maintained by Matt Chaput. It was originally created
  for use in the online help system of Side Effects Software's 3D animation
  software Houdini. Side Effects Software Inc. graciously agreed to open-source
  the code.
  This software is licensed under the terms of the simplified BSD (A.K.A. "two
  clause" or "FreeBSD") license. See LICENSE.txt for information.


pkgId: 45cccc3f5f8d24a84117b42dcb18cc821e791d52e0f33b5ff829e8b0e8b3fb4e
name: python-XStatic
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: XStatic base package with minimal support code
url: https://github.com/xstatic-py/xstatic
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-56573698-432f-4679-872d-1498b1cd52f0
location_href: 00002890-python-XStatic/python-XStatic-1.0.2-1.src.rpm
checksum_type: sha256
description:
  The goal of XStatic family of packages is to provide static file packages
  with minimal overhead - without selling you some dependencies you don't want.
  XStatic has some minimal support code for working with the XStatic-* packages.
  Docs: https://xstatic.readthedocs.io/
  Repository: https://github.com/xstatic-py/xstatic (base package)
  Find more stuff already packaged as xstatic package there:
  https://github.com/xstatic-py/
  https://pypi.org/search/?q=xstatic
  Licenses:
  * MIT license (for XStatic code)
  * same license as packaged file (for static file packages)


pkgId: 5ba75a4ba9fbc8cb38d6b0af0b9b547b0c4c2a8f6ff9200e3c3d17b33a5894eb
name: python-XStatic-Angular
arch: src
version: 1.8.2.2
epoch: 0
release: 1
summary: Angular 1.8.2 (XStatic packaging standard)
url: http://angularjs.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1ad1ad56-17e1-45b8-9c2b-5fbda4c8ced9
location_href: 00002891-python-XStatic-Angular/python-XStatic-Angular-1.8.2.2-1.src.rpm
checksum_type: sha256
description:
  Angular JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 2152777b1f874efa68915cc6251859a46bcaba3f3fe145509018d0da759b0c56
name: python-XStatic-Angular-Bootstrap
arch: src
version: 2.5.0.0
epoch: 0
release: 1
summary: Angular-Bootstrap 2.5.0 (XStatic packaging standard)
url: http://angular-ui.github.io/bootstrap/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-58f286ae-5f5f-44d3-9419-67c7bcfe99ca
location_href: 00002892-python-XStatic-Angular-Bootstrap/python-XStatic-Angular-Bootstrap-2.5.0.0-1.src.rpm
checksum_type: sha256
description:
  Angular-Bootstrap JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 462a5603120d1871778e9dbd739e8196002dfdf15b9e2669ad8039c1b80f276d
name: python-XStatic-Angular-Bootstrap-help
arch: noarch
version: 2.5.0.0
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Angular-Bootstrap
url: http://angular-ui.github.io/bootstrap/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-58f286ae-5f5f-44d3-9419-67c7bcfe99ca
rpm_sourcerpm: python-XStatic-Angular-Bootstrap-2.5.0.0-1.src.rpm
checksum_type: sha256
description:
  Angular-Bootstrap JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.

location_href:
  00002892-python-XStatic-Angular-Bootstrap/python-XStatic-Angular-Bootstrap-help-2.5.0.0-1.noarch.rpm


pkgId: 7039304fd360ca844219e5dab977b9ae4db32b2d18053211c3147bac0d625e20
name: python-XStatic-Angular-Bootstrap-help
arch: noarch
version: 2.5.0.0
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Angular-Bootstrap
url: http://angular-ui.github.io/bootstrap/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1a3c9a98-76ea-412e-91f4-213b287ac9c2
rpm_sourcerpm: python-XStatic-Angular-Bootstrap-2.5.0.0-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 434 characters]

location_href:
  00006272-python-XStatic-Angular-Bootstrap/python-XStatic-Angular-Bootstrap-help-2.5.0.0-1.noarch.rpm


pkgId: 19b9e4fa85911d7a424f100a8560899e6799b975b541d9e21d6264d95d1500f1
name: python-XStatic-Angular-FileUpload
arch: src
version: 12.0.4.0
epoch: 0
release: 1
summary: Angular-FileUpload 12.0.4 (XStatic packaging standard)
url: https://github.com/danialfarid/angular-file-upload
rpm_license: (same as Angular-FileUpload)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ce11f258-27b7-4e77-a86a-6f65373c4db3
location_href: 00002893-python-XStatic-Angular-FileUpload/python-XStatic-Angular-FileUpload-12.0.4.0-1.src.rpm
checksum_type: sha256
description:
  Angular-FileUpload JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: f6968d3df3c43e9ff65e9bd630ac6263f9b30953292c9b29493d7aae673d92b2
name: python-XStatic-Angular-FileUpload-help
arch: noarch
version: 12.0.4.0
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Angular-FileUpload
url: https://github.com/danialfarid/angular-file-upload
rpm_license: (same as Angular-FileUpload)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ce11f258-27b7-4e77-a86a-6f65373c4db3
rpm_sourcerpm: python-XStatic-Angular-FileUpload-12.0.4.0-1.src.rpm
checksum_type: sha256
description:
  Angular-FileUpload JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.

location_href:
  00002893-python-XStatic-Angular-FileUpload/python-XStatic-Angular-FileUpload-help-12.0.4.0-1.noarch.rpm


pkgId: 8d71337189d05829ae92c5d3b6e083cc88b0a041e1f79387e1fea2360ef3a8a6
name: python-XStatic-Angular-FileUpload-help
arch: noarch
version: 12.0.4.0
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Angular-FileUpload
url: https://github.com/danialfarid/angular-file-upload
rpm_license: (same as Angular-FileUpload)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-38a3aecd-9c6a-4339-9928-bec87136dc9c
rpm_sourcerpm: python-XStatic-Angular-FileUpload-12.0.4.0-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 435 characters]

location_href:
  00006273-python-XStatic-Angular-FileUpload/python-XStatic-Angular-FileUpload-help-12.0.4.0-1.noarch.rpm


pkgId: 2649dca428a9bea4a2faeb92579ec9a21de2de6e534a210179220bab984746e0
name: python-XStatic-Angular-Gettext
arch: src
version: 2.4.1.0
epoch: 0
release: 1
summary: Angular-Gettext 2.4.1 (XStatic packaging standard)
url: https://angular-gettext.rocketeer.be/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0a82b62a-db23-4ba8-bf2c-59427a4c28da
location_href: 00002894-python-XStatic-Angular-Gettext/python-XStatic-Angular-Gettext-2.4.1.0-1.src.rpm
checksum_type: sha256
description:
  Angular-Gettext javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 47d3d684058c2196f51623f146aca46afd82d6c15135e4e7b14eb58a8b1c7e99
name: python-XStatic-Angular-Mock
arch: src
version: 1.2.1.1
epoch: 0
release: 1
summary: Angular-Mock 1.2.1 (XStatic packaging standard)
url: http://angularjs.org/
rpm_license: (same as Angular-Mock)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03239cde-ca6d-4146-b230-7e3134281f2e
location_href: 00002895-python-XStatic-Angular-Mock/python-XStatic-Angular-Mock-1.2.1.1-1.src.rpm
checksum_type: sha256
description:
  Angular-Mock JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 4af99a0dc9aa255ed8d840d9602b56b02f9fe55ee2151fbb74d0eab4fc5f94a2
name: python-XStatic-Angular-lrdragndrop
arch: src
version: 1.0.2.4
epoch: 0
release: 1
summary: Angular-lrdragndrop 1.0.2 (XStatic packaging standard)
url: https://github.com/lorenzofox3/lrDragNDrop
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-48a089ed-8672-4c1e-b1f6-f66b5eaf6301
location_href: 00002898-python-XStatic-Angular-lrdragndrop/python-XStatic-Angular-lrdragndrop-1.0.2.4-1.src.rpm
checksum_type: sha256
description:
  lrDragNDrop javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package
  `XStatic`.


pkgId: a182675515b53cf57a0d8d928b1c2cfd38ba274265aaeac4faaba5cc08e70f8d
name: python-XStatic-Angular-lrdragndrop-help
arch: noarch
version: 1.0.2.4
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Angular-lrdragndrop
url: https://github.com/lorenzofox3/lrDragNDrop
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-48a089ed-8672-4c1e-b1f6-f66b5eaf6301
rpm_sourcerpm: python-XStatic-Angular-lrdragndrop-1.0.2.4-1.src.rpm
checksum_type: sha256
description:
  lrDragNDrop javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package
  `XStatic`.

location_href:
  00002898-python-XStatic-Angular-lrdragndrop/python-XStatic-Angular-lrdragndrop-help-1.0.2.4-1.noarch.rpm


pkgId: f03f47a19828adde3e8cd7b3615bda6da7f2ec805e953622c9d1d346c4a899eb
name: python-XStatic-Angular-lrdragndrop-help
arch: noarch
version: 1.0.2.4
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Angular-lrdragndrop
url: https://github.com/lorenzofox3/lrDragNDrop
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72f0e7e5-697b-42e6-9fd0-afc1d3ba96e0
rpm_sourcerpm: python-XStatic-Angular-lrdragndrop-1.0.2.4-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 428 characters]

location_href:
  00006278-python-XStatic-Angular-lrdragndrop/python-XStatic-Angular-lrdragndrop-help-1.0.2.4-1.noarch.rpm


pkgId: b79cad713211baf67b552770efa10de2d86c06d776fdcc13dd67f8b20bb51896
name: python-XStatic-Bootstrap-Datepicker
arch: src
version: 1.4.0.0
epoch: 0
release: 1
summary: Bootstrap-Datepicker 1.4.0 (XStatic packaging standard)
url: https://github.com/eternicode/bootstrap-datepicker/
rpm_license: (same as Bootstrap-Datepicker)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94075c1c-7e3e-4c18-a86d-7758bae80b47
location_href: 00002899-python-XStatic-Bootstrap-Datepicker/python-XStatic-Bootstrap-Datepicker-1.4.0.0-1.src.rpm
checksum_type: sha256
description:
  Bootstrap-Datepicker JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 90a95891c578579e82ae1f2f9add86b4a4a3eeb111e9c7213bc6e5a3b9d3408f
name: python-XStatic-Bootstrap-Datepicker-help
arch: noarch
version: 1.4.0.0
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Bootstrap-Datepicker
url: https://github.com/eternicode/bootstrap-datepicker/
rpm_license: (same as Bootstrap-Datepicker)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94075c1c-7e3e-4c18-a86d-7758bae80b47
rpm_sourcerpm: python-XStatic-Bootstrap-Datepicker-1.4.0.0-1.src.rpm
checksum_type: sha256
description:
  Bootstrap-Datepicker JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.

location_href:
  00002899-python-XStatic-Bootstrap-Datepicker/python-XStatic-Bootstrap-Datepicker-help-1.4.0.0-1.noarch.rpm


pkgId: 2b46f91526ca21be14d0d25b86eecce8b8610fbeb4a211b05e4c6656342c377a
name: python-XStatic-Bootstrap-Datepicker-help
arch: noarch
version: 1.4.0.0
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Bootstrap-Datepicker
url: https://github.com/eternicode/bootstrap-datepicker/
rpm_license: (same as Bootstrap-Datepicker)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6443ed12-2fa1-44c0-b4b2-aab02496a0fa
rpm_sourcerpm: python-XStatic-Bootstrap-Datepicker-1.4.0.0-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 437 characters]

location_href:
  00006279-python-XStatic-Bootstrap-Datepicker/python-XStatic-Bootstrap-Datepicker-help-1.4.0.0-1.noarch.rpm


pkgId: 9e18aefa7caf2b915d5f1ec736050802ebce6484a0e83509a9500ff7789d2b73
name: python-XStatic-Bootstrap-SCSS
arch: src
version: 3.4.1.0
epoch: 0
release: 1
summary: Bootstrap-SCSS 3.4.1 (XStatic packaging standard)
url: https://github.com/twbs/bootstrap-sass
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2da431cf-b9a5-49b7-bbfa-f7cf43a88dcf
location_href: 00002900-python-XStatic-Bootstrap-SCSS/python-XStatic-Bootstrap-SCSS-3.4.1.0-1.src.rpm
checksum_type: sha256
description:
  Bootstrap style library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: e0ac7d55bb687b22bfd37641e97ccea65855436d108df67e404804525ade1320
name: python-XStatic-D3
arch: src
version: 3.5.17.0
epoch: 0
release: 1
summary: D3 3.5.17 (XStatic packaging standard)
url: http://d3js.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-66c5fa1c-0ae4-488d-9c4c-9099c0f4b55e
location_href: 00002901-python-XStatic-D3/python-XStatic-D3-3.5.17.0-1.src.rpm
checksum_type: sha256
description:
  D3 JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 396763cb7b895e882621a4db477008eb53d7e74375fd71c16a214ad50aa92865
name: python-XStatic-DataTables
arch: src
version: 1.10.15.1
epoch: 0
release: 1
summary: DataTables 1.10.15 (XStatic packaging standard)
url: http://www.datatables.net
rpm_license: (same as DataTables)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3f0e49df-71a1-4936-9385-92f62c25ce3a
location_href: 00002902-python-XStatic-DataTables/python-XStatic-DataTables-1.10.15.1-1.src.rpm
checksum_type: sha256
description:
  The DataTables plugin for jQuery packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 782e87837983642ea748723a4701037770e457c7f33ebf3e82ed93ec7900354a
name: python-XStatic-Font-Awesome
arch: src
version: 6.2.1.1
epoch: 0
release: 1
summary: Font-Awesome 6.2.1 (XStatic packaging standard)
url: https://github.com/FortAwesome/Font-Awesome
rpm_license: (same as Font-Awesome)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e76a757f-99fa-4297-87eb-cdec9f6d2d2b
location_href: 00002904-python-XStatic-Font-Awesome/python-XStatic-Font-Awesome-6.2.1.1-1.src.rpm
checksum_type: sha256
description:
  Font Awesome packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 81d4c293b55fdea433b1baf2d48c0a4f443673be8bb669df3f9f76cdcebd99b7
name: python-XStatic-Hogan
arch: src
version: 2.0.0.3
epoch: 0
release: 1
summary: Hogan 2.0.0 (XStatic packaging standard)
url: http://twitter.github.io/hogan.js/
rpm_license: (same as Hogan)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e753913d-4ab1-4e30-a121-7a9116adb5e1
location_href: 00002905-python-XStatic-Hogan/python-XStatic-Hogan-2.0.0.3-1.src.rpm
checksum_type: sha256
description:
  Hogan JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 5dbe9042c90181bdf49e442e1f8835ca97ba7fdd8f2848078d87b4db15894910
name: python-XStatic-JQuery-Migrate
arch: src
version: 3.3.2.1
epoch: 0
release: 1
summary: JQuery-Migrate 3.3.2 (XStatic packaging standard)
url: https://github.com/jquery/jquery-migrate
rpm_license: (same as JQuery-Migrate)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b377b3d2-eadd-4b88-b1aa-c4870e7f0384
location_href: 00002906-python-XStatic-JQuery-Migrate/python-XStatic-JQuery-Migrate-3.3.2.1-1.src.rpm
checksum_type: sha256
description:
  JQuery-Migrate JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 9e10b62db47f0ca36a057c216d5225a8f97266715b1d0059fcaf99d819a05340
name: python-XStatic-JQuery.TableSorter
arch: src
version: 2.14.5.2
epoch: 0
release: 1
summary: JQuery.TableSorter 2.14.5 (XStatic packaging standard)
url: https://github.com/Mottie/tablesorter
rpm_license: (same as JQuery.TableSorter)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-74cb3e42-fc04-404e-b34d-29625b7f60aa
location_href: 00002907-python-XStatic-JQuery-TableSorter/python-XStatic-JQuery.TableSorter-2.14.5.2-1.src.rpm
checksum_type: sha256
description:
  JQuery.TableSorter JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: e5c08b5562da103b87af4fb55f89a8459b5f6a302e1d7b8594e85eaf292b0c2a
name: python-XStatic-JQuery.TableSorter-help
arch: noarch
version: 2.14.5.2
epoch: 0
release: 1
summary: Development documents and examples for XStatic-JQuery.TableSorter
url: https://github.com/Mottie/tablesorter
rpm_license: (same as JQuery.TableSorter)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-74cb3e42-fc04-404e-b34d-29625b7f60aa
rpm_sourcerpm: python-XStatic-JQuery.TableSorter-2.14.5.2-1.src.rpm
checksum_type: sha256
description:
  JQuery.TableSorter JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.

location_href:
  00002907-python-XStatic-JQuery-TableSorter/python-XStatic-JQuery.TableSorter-help-2.14.5.2-1.noarch.rpm


pkgId: 3559d2c004bbde80b6be185e9d0d40ce04f197ec32442489db8239450100fc6d
name: python-XStatic-JQuery.TableSorter-help
arch: noarch
version: 2.14.5.2
epoch: 0
release: 1
summary: Development documents and examples for XStatic-JQuery.TableSorter
url: https://github.com/Mottie/tablesorter
rpm_license: (same as JQuery.TableSorter)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-82794ebc-3238-4d39-933a-b4c6ab40570b
rpm_sourcerpm: python-XStatic-JQuery.TableSorter-2.14.5.2-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 435 characters]

location_href:
  00006287-python-XStatic-JQuery-TableSorter/python-XStatic-JQuery.TableSorter-help-2.14.5.2-1.noarch.rpm


pkgId: fa7242f8d5d7d7fba91dbaab85be8601214507b1b291c967192d862de29de0a2
name: python-XStatic-JQuery.quicksearch
arch: src
version: 2.0.3.2
epoch: 0
release: 1
summary: JQuery.quicksearch 2.0.3 (XStatic packaging standard)
url: http://plugins.jquery.com/jquery.quicksearch/
rpm_license: (same as JQuery.quicksearch)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddb6664a-532d-4c6b-a615-18d4bb45db9f
location_href: 00002908-python-XStatic-JQuery-quicksearch/python-XStatic-JQuery.quicksearch-2.0.3.2-1.src.rpm
checksum_type: sha256
description:
  JQuery.quicksearch JavaScript library packaged for setuptools (easy_install)
  / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 1acb0bb19efb609e6171842cb5a3f77155fe10e0a4e3c7afce5ada37bd6f14c5
name: python-XStatic-JQuery.quicksearch-help
arch: noarch
version: 2.0.3.2
epoch: 0
release: 1
summary: Development documents and examples for XStatic-JQuery.quicksearch
url: http://plugins.jquery.com/jquery.quicksearch/
rpm_license: (same as JQuery.quicksearch)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddb6664a-532d-4c6b-a615-18d4bb45db9f
rpm_sourcerpm: python-XStatic-JQuery.quicksearch-2.0.3.2-1.src.rpm
checksum_type: sha256
description:
  JQuery.quicksearch JavaScript library packaged for setuptools (easy_install)
  / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.

location_href:
  00002908-python-XStatic-JQuery-quicksearch/python-XStatic-JQuery.quicksearch-help-2.0.3.2-1.noarch.rpm


pkgId: b3356b471a0b9bb06ef50e947c4558c09b94a97f2461ec6257f3e6fd52691b7a
name: python-XStatic-JQuery.quicksearch-help
arch: noarch
version: 2.0.3.2
epoch: 0
release: 1
summary: Development documents and examples for XStatic-JQuery.quicksearch
url: http://plugins.jquery.com/jquery.quicksearch/
rpm_license: (same as JQuery.quicksearch)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a0d5e07a-6574-4833-a5ca-d610a6bb65bb
rpm_sourcerpm: python-XStatic-JQuery.quicksearch-2.0.3.2-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 435 characters]

location_href:
  00006288-python-XStatic-JQuery-quicksearch/python-XStatic-JQuery.quicksearch-help-2.0.3.2-1.noarch.rpm


pkgId: b288e82f1e15cffb1b1b785ad447fc2e7d30416c6db82f5736d7ab37b93304a0
name: python-XStatic-JSEncrypt
arch: src
version: 2.3.1.1
epoch: 0
release: 1
summary: JSEncrypt 2.3.1 (XStatic packaging standard)
url: http://travistidwell.com/jsencrypt/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f446749-6921-4b9a-bb11-a4b0a0e7d883
location_href: 00002910-python-XStatic-JSEncrypt/python-XStatic-JSEncrypt-2.3.1.1-1.src.rpm
checksum_type: sha256
description:
  JSEncrypt JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: ce1c6b73741d181a728e91cf18dfa5b0c63985d963d64d94a8669d29ad91c388
name: python-XStatic-Jasmine
arch: src
version: 2.4.1.2
epoch: 0
release: 1
summary: Jasmine 2.4.1 (XStatic packaging standard)
url: http://jasmine.github.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ffd45f09-ad64-47c3-a43d-4723f376d902
location_href: 00002911-python-XStatic-Jasmine/python-XStatic-Jasmine-2.4.1.2-1.src.rpm
checksum_type: sha256
description:
  Jasmine JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: dfa708fb1301bdf405c07ae827287a02d1b0e1132bbdad44048417d08837a69c
name: python-XStatic-Magic-Search
arch: src
version: 0.2.5.2
epoch: 0
release: 1
summary: Magic-Search 0.2.5 (XStatic packaging standard)
url: https://github.com/eucalyptus/magic-search
rpm_license: (same as Magic-Search)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e2cf97b-8c09-44c7-a50c-54f40e7c5396
location_href: 00002913-python-XStatic-Magic-Search/python-XStatic-Magic-Search-0.2.5.2-1.src.rpm
checksum_type: sha256
description:
  MagicSearch is an AngularJS directive that provides a UI for both faceted
  filtering and as-you-type filtering. It is intended for filtering tables,
  such as an AngularJS smart-table, but it can be used in any situation
  where you can provide it with facets/options and consume its events.
  MagicSearch was initially developed by David Kavanagh for Eucalyptus.
  MagicSearch javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 970fd2b091e0fb6f3c836003c3c53ca8eb1129071654fc7c3a67b248743afd99
name: python-XStatic-Patternfly
arch: src
version: 3.21.0.1
epoch: 0
release: 1
summary: Patternfly 3.21.0 (XStatic packaging standard)
url: https://www.patternfly.org/
rpm_license: Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-589383ab-9cdc-4ddb-9780-8614bf9f962f
location_href: 00002914-python-XStatic-Patternfly/python-XStatic-Patternfly-3.21.0.1-1.src.rpm
checksum_type: sha256
description:
  Patternfly style library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 49ceabe0605503eaab7c80bceb2a381cce157f2a681499c1c609160da37221aa
name: python-XStatic-Patternfly-Bootstrap-Treeview
arch: src
version: 2.1.3.2
epoch: 0
release: 1
summary: Patternfly-Bootstrap-Treeview 2.1.3 (XStatic packaging standard)
url: https://www.patternfly.org/
rpm_license: Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de7e7142-a030-40a6-b8e8-627f521d22d1
checksum_type: sha256
description:
  Patternfly Bootstrap Treeview library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.

location_href:
  00002915-python-XStatic-Patternfly-Bootstrap-Treeview/python-XStatic-Patternfly-Bootstrap-Treeview-2.1.3.2-1.src.rpm


pkgId: 6a0e10a96efba648958b30618a447c5c8f97cc82bb78032345f81485ff9c0154
name: python-XStatic-Patternfly-Bootstrap-Treeview
arch: src
version: 2.1.3.2
epoch: 0
release: 1
summary: Patternfly-Bootstrap-Treeview 2.1.3 (XStatic packaging standard)
url: https://www.patternfly.org/
rpm_license: Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7ef7fab2-7541-4eee-bb13-1da1a900f0c5
checksum_type: sha256
description:
  Patternfly Bootstrap Treeview library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.

location_href:
  00006295-python-XStatic-Patternfly-Bootstrap-Treeview/python-XStatic-Patternfly-Bootstrap-Treeview-2.1.3.2-1.src.rpm


pkgId: a66830a2ce60931b81912fbc2ea5c51dc235c47247a2e2f3ffe11df94d091877
name: python-XStatic-Patternfly-Bootstrap-Treeview-help
arch: noarch
version: 2.1.3.2
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Patternfly-Bootstrap-Treeview
url: https://www.patternfly.org/
rpm_license: Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de7e7142-a030-40a6-b8e8-627f521d22d1
rpm_sourcerpm: python-XStatic-Patternfly-Bootstrap-Treeview-2.1.3.2-1.src.rpm
checksum_type: sha256
description:
  Patternfly Bootstrap Treeview library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.

location_href:
  00002915-python-XStatic-Patternfly-Bootstrap-Treeview/python-XStatic-Patternfly-Bootstrap-Treeview-help-2.1.3.2-1.noarch.rpm


pkgId: 1fd074e57e40b66cefbcd6477e7a5eb7053683dbe98cfc88b99011281a386378
name: python-XStatic-Patternfly-Bootstrap-Treeview-help
arch: noarch
version: 2.1.3.2
epoch: 0
release: 1
summary: Development documents and examples for XStatic-Patternfly-Bootstrap-Treeview
url: https://www.patternfly.org/
rpm_license: Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7ef7fab2-7541-4eee-bb13-1da1a900f0c5
rpm_sourcerpm: python-XStatic-Patternfly-Bootstrap-Treeview-2.1.3.2-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 435 characters]

location_href:
  00006295-python-XStatic-Patternfly-Bootstrap-Treeview/python-XStatic-Patternfly-Bootstrap-Treeview-help-2.1.3.2-1.noarch.rpm


pkgId: 4dea5cd4f23d2f36d3ac91049d923f625eccaaebce4a52202f1928a4c61c858b
name: python-XStatic-QUnit
arch: src
version: 1.14.0.2
epoch: 0
release: 1
summary: QUnit 1.14.0 (XStatic packaging standard)
url: http://qunitjs.com
rpm_license: (same as QUnit)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c926c17c-bca6-4ec4-af69-86607863da06
location_href: 00002916-python-XStatic-QUnit/python-XStatic-QUnit-1.14.0.2-1.src.rpm
checksum_type: sha256
description:
  QUnit JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 30b0131e27568d7c3d17fc640e9cadc500c995ccd7208e413dd0c6e9e8a6f9c0
name: python-XStatic-Rickshaw
arch: src
version: 1.5.1.0
epoch: 0
release: 1
summary: Rickshaw 1.5.1 (XStatic packaging standard)
url: http://code.shutterstock.com/rickshaw/
rpm_license: (same as Rickshaw)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a1c676ea-8364-4dd8-8ee4-61aa1434e9b2
location_href: 00002917-python-XStatic-Rickshaw/python-XStatic-Rickshaw-1.5.1.0-1.src.rpm
checksum_type: sha256
description:
  Rickshaw JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: fde2eece0b7386dc8f610697efb4c8853632340f5a157cf8c2870f1e0ded819e
name: python-XStatic-Spin
arch: src
version: 1.2.5.3
epoch: 0
release: 1
summary: Spin 1.2.5 (XStatic packaging standard)
url: http://fgnass.github.io/spin.js/
rpm_license: (same as Spin)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e6a0f0bd-6c36-45c3-9cd4-1492ea572380
location_href: 00002918-python-XStatic-Spin/python-XStatic-Spin-1.2.5.3-1.src.rpm
checksum_type: sha256
description:
  Spin JavaScript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: 5fa6f189bcb46846348a2d821c3e899a8827d990edf6c3212d24dc0f05c5ea5c
name: python-XStatic-bootswatch
arch: src
version: 3.3.7.0
epoch: 0
release: 1
summary: bootswatch 3.3.7 (XStatic packaging standard)
url: http://bootswatch.com
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7b573a23-7199-44c1-a2ab-13c7046c5185
location_href: 00002919-python-XStatic-bootswatch/python-XStatic-bootswatch-3.3.7.0-1.src.rpm
checksum_type: sha256
description:
  bootswatch javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package
  `XStatic`.


pkgId: bfa0962891dbf55e0e7213117b26c5c6deb679e5265ebc4efe4a6ab9a3d14e70
name: python-XStatic-jquery-ui
arch: src
version: 1.13.0.1
epoch: 0
release: 1
summary: jquery-ui 1.13.0 (XStatic packaging standard)
url: http://jqueryui.com/
rpm_license: (same as jquery-ui)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de2dc119-7672-45d4-8ef2-bf4f4eddd35f
location_href: 00002920-python-XStatic-jquery-ui/python-XStatic-jquery-ui-1.13.0.1-1.src.rpm
checksum_type: sha256
description:
  jquery-ui javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package `XStatic`.


pkgId: f8ed711ff2067e1d65f91abcae9e7428b06a27f18314751ad0cc6719629264ec
name: python-XStatic-mdi
arch: src
version: 1.6.50.2
epoch: 0
release: 1
summary: mdi 1.6.50 (XStatic packaging standard)
url: http://materialdesignicons.com
rpm_license: SIL OFL 1.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2c18b1c4-4be5-4640-947f-bb59986b9135
location_href: 00002921-python-XStatic-mdi/python-XStatic-mdi-1.6.50.2-1.src.rpm
checksum_type: sha256
description:
  mdi javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package
  `XStatic`.


pkgId: 3f95cd32105e4cdf9dd03fe6ec348436baddfa4a0909648acc1a96b1c05c410b
name: python-XStatic-roboto-fontface
arch: src
version: 0.5.0.0
epoch: 0
release: 1
summary: roboto-fontface 0.5.0 (XStatic packaging standard)
url: https://github.com/choffmeister/roboto-fontface-bower
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f873338-7aa7-4178-a149-d42bfe1e3963
location_href: 00002922-python-XStatic-roboto-fontface/python-XStatic-roboto-fontface-0.5.0.0-1.src.rpm
checksum_type: sha256
description:
  roboto-fontface javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package
  `XStatic`.


pkgId: b78648cafac69d0652aa47ac3414c5daded8b36fc5d1c7795324a1615623dd6c
name: python-XStatic-smart-table
arch: src
version: 1.4.13.2
epoch: 0
release: 1
summary: smart-table 1.4.13 (XStatic packaging standard)
url: https://github.com/lorenzofox3/Smart-Table
rpm_license: (same as smart-table)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e687cd31-05e4-4c53-b128-298bd0b4c047
location_href: 00002923-python-XStatic-smart-table/python-XStatic-smart-table-1.4.13.2-1.src.rpm
checksum_type: sha256
description:
  smart-table javascript library packaged for setuptools (easy_install) / pip.
  This package is intended to be used by **any** project that needs these files.
  It intentionally does **not** provide any extra code except some metadata
  **nor** has any extra requirements. You MAY use some minimal support code from
  the XStatic base package, if you like.
  You can find more info about the xstatic packaging way in the package
  `XStatic`.


pkgId: 5a745b0fae18c8a80ca57f25d88cb06aa2e32b2cd1b2a7a47e0153e4bb2aa3b8
name: python-XlsxWriter
arch: src
version: 3.0.8
epoch: 0
release: 1
summary: A Python module for creating Excel XLSX files.
url: https://github.com/jmcnamara/XlsxWriter
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b6f823b4-6d94-4479-9312-e1695276734b
location_href: 00005505-python-xlsxwriter/python-XlsxWriter-3.0.8-1.src.rpm
checksum_type: sha256
description:
  **XlsxWriter** is a Python module for writing files in the Excel 2007+ XLSX
  file format.
  XlsxWriter can be used to write text, numbers, formulas and hyperlinks to
  multiple worksheets and it supports features such as formatting and many more,
  including:
  * 100% compatible Excel XLSX files.
  * Full formatting.
  * Merged cells.
  * Defined names.
  * Charts.
  * Autofilters.
  * Data validation and drop down lists.
  * Conditional formatting.
  * Worksheet PNG/JPEG/GIF/BMP/WMF/EMF images.
  * Rich multi-format strings.
  * Cell comments.
  * Integration with Pandas.
  * Textboxes.
  * Support for adding Macros.
  * Memory optimization mode for writing large files.
  It supports Python 3.4+ and PyPy3 and uses standard libraries only.
  Here is a simple example:
     import xlsxwriter
     
     workbook = xlsxwriter.Workbook('demo.xlsx')
     worksheet = workbook.add_worksheet()
     
     worksheet.set_column('A:A', 20)
     
     bold = workbook.add_format({'bold': True})
     
     worksheet.write('A1', 'Hello')
     
     worksheet.write('A2', 'World', bold)
     
     worksheet.write(2, 0, 123)
     worksheet.write(3, 0, 123.456)
     
     worksheet.insert_image('B5', 'logo.png')
     workbook.close()
  See the full documentation at: https://xlsxwriter.readthedocs.io
  Release notes: https://xlsxwriter.readthedocs.io/changes.html


pkgId: 84b3e85e3ff139a225c962258b764439595eeaa1056678ebd4befbe4ad92f013
name: python-XlsxWriter
arch: src
version: 3.0.9
epoch: 0
release: 1
summary: A Python module for creating Excel XLSX files.
url: https://github.com/jmcnamara/XlsxWriter
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6a3e038a-0ee0-4b75-809f-24125153e1fd
location_href: 00008822-python-xlsxwriter/python-XlsxWriter-3.0.9-1.src.rpm
checksum_type: sha256
description:
  **XlsxWriter** is a Python module for writing files in the Excel 2007+ XLSX
  file format.
  XlsxWriter can be used to write text, numbers, formulas and hyperlinks to
  multiple worksheets and it supports features such as formatting and many more,
  including:
  * 100% compatible Excel XLSX files.
  * Full formatting.
  * Merged cells.
  * Defined names.
  * Charts.
  * Autofilters.
  * Data validation and drop down lists.
  * Conditional formatting.
  * Worksheet PNG/JPEG/GIF/BMP/WMF/EMF images.
  * Rich multi-format strings.
  * Cell comments.
  * Integration with Pandas and Polars.
  * Textboxes.
  * Support for adding Macros.
  * Memory optimization mode for writing large files.
  It supports Python 3.4+ and PyPy3 and uses standard libraries only.
  Here is a simple example:
     import xlsxwriter
     
     workbook = xlsxwriter.Workbook('demo.xlsx')
     worksheet = workbook.add_worksheet()
     
     worksheet.set_column('A:A', 20)
     
     bold = workbook.add_format({'bold': True})
     
     worksheet.write('A1', 'Hello')
     
     worksheet.write('A2', 'World', bold)
     
     worksheet.write(2, 0, 123)
     worksheet.write(3, 0, 123.456)
     
     worksheet.insert_image('B5', 'logo.png')
     workbook.close()
  See the full documentation at: https://xlsxwriter.readthedocs.io
  Release notes: https://xlsxwriter.readthedocs.io/changes.html


pkgId: ede72aa7504bbcf84fad49b0f31937b3642368b7c2065799a7a88159cd1642e5
name: python-Yapsy
arch: src
version: 1.12.2
epoch: 0
release: 1
summary: Yet another plugin system
url: http://yapsy.sourceforge.net
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-132561bf-1909-4fee-a389-26b88289393b
location_href: 00005521-python-yapsy/python-Yapsy-1.12.2-1.src.rpm
checksum_type: sha256
description:
  Yapsy is a small library implementing the core mechanisms needed to
  build a plugin system into a wider application.

  The main purpose is to depend only on Python's standard libraries and
  to implement only the basic functionalities needed to detect, load and
  keep track of several plugins. It supports both Python 2 and 3.

  To use yapsy, make sure that the "yapsy" directory is in your Python
  loading path and just import the needed class from yapsy (e.g. "from
  yapsy.PluginManager import PluginManager").

  To see more examples, you can have a look at the unit tests inside the
  "test" directory or at the "Showcase and tutorials" section of the
  documentation (http://yapsy.sourceforge.net/#showcase-and-tutorials).

  Please let me know if you find this useful.

  Site of the project: http://yapsy.sourceforge.net/

  List of Contributors:
    - Thibauld Nion
    - Rob McMullen
    - Roger Gammans
    - Mathieu Havel
    - Mathieu Clabaut
    - Mark Fickett
    - Agustin Henze
    - qitta
    - Roberto Alsina
    - Josip Delic (delijati)
    - frmdstryr
    - Pierre-Yves Langlois
    - Guillaume Binet (gbin)
    - Blake Oliver (Oliver2213)
    - Xuecheng Zhang (csuzhangxc)
    - Marc Brooks (mbrooks-public)


  Contributions are welcome as pull requests, patches or tickets on the
  forge (https://sourceforge.net/projects/yapsy/) or on github
  (https://github.com/tibonihoo/yapsy).


pkgId: 72c432a863f393a1e312f0f65cf0fa19ec20a81ef6ff8aaeeff64f5825a6cda9
name: python-a-pytube-fork-for-spotdl-users
arch: src
version: 9.6.4
epoch: 0
release: 1
summary: Python 3 library for downloading YouTube Videos.
url: https://github.com/nficano/pytube
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9351e33c-8f13-4841-80a1-7cfc43ac1505
checksum_type: sha256
description:
  Ping @ronncc if you would like to help out

  <div align="center">
    <p>
    <img src="https://github.com/nficano/pytube/blob/master/images/pytube.png?raw=true" width="350" height="328" alt="pytube logo" />
    </p>
    <p align="center">
  	  <img src="https://img.shields.io/pypi/v/pytube.svg" alt="pypi">
  	  <a href="https://travis-ci.org/nficano/pytube"><img src="https://travis-ci.org/nficano/pytube.svg?branch=master" /></a>
  	  <a href="http://python-pytube.readthedocs.io/en/latest/?badge=latest"><img src="https://readthedocs.org/projects/python-pytube/badge/?version=latest" /></a>
  	  <a href="https://coveralls.io/github/nficano/pytube?branch=master"><img src="https://coveralls.io/repos/github/nficano/pytube/badge.svg?branch=master#23e6f7ac56dd3bde" /></a>
        <a href="https://pypi.org/project/pytube/"><img src="https://img.shields.io/pypi/dm/pytube.svg" alt="pypi"></a>
  	  <a href="https://pypi.python.org/pypi/pytube/"><img src="https://img.shields.io/pypi/pyversions/pytube.svg" /></a>
      <p>
    </p>
  </div>


  *pytube* is a very serious, lightweight, dependency-free Python library (and command-line utility) for downloading YouTube Videos.


  YouTube is the most popular video-sharing platform in the world and as a hacker you may encounter a situation where you want to script something to download videos.  For this I present to you *pytube*.

  *pytube* is a lightweight library written in Python. It has no third party dependencies and aims to be highly reliable.

  *pytube* also makes pipelining easy, allowing you to specify callback functions for different download events, such as  ``on progress`` or ``on complete``.

  Finally *pytube* also includes a command-line utility, allowing you to quickly download videos right from terminal.



  ```python
   >>> YouTube('https://youtu.be/9bZkp7q19f0').streams.first().download()
   >>> yt = YouTube('http://youtube.com/watch?v=9bZkp7q19f0')
   >>> yt.streams
    ... .filter(progressive=True, file_extension='mp4')
    ... .order_by('resolution')
    ... .desc()
    ... .first()
    ... .download()
  ```


  - Support for Both Progressive & DASH Streams
  - Support for downloading complete playlist
  - Easily Register ``on_download_progress`` & ``on_download_complete`` callbacks
  - Command-line Interfaced Included
  - Caption Track Support
  - Outputs Caption Tracks to .srt format (SubRip Subtitle)
  - Ability to Capture Thumbnail URL.
  - Extensively Documented Source Code
  - No Third-Party Dependencies



  Download using pip via pypi.

  ```bash
  $ pip install pytube
  ```



  Let's begin with showing how easy it is to download a video with pytube:

  ```python
  >>> from pytube import YouTube
  >>> YouTube('http://youtube.com/watch?v=9bZkp7q19f0').streams.first().download()
  ```
  This example will download the highest quality progressive download stream available.

  Next, let's explore how we would view what video streams are available:

  ```python
  >>> yt = YouTube('http://youtube.com/watch?v=9bZkp7q19f0')
  >>> yt.streams.all()
   [<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">,
   <Stream: itag="43" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp8.0" acodec="vorbis">,
   <Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">,
   <Stream: itag="36" mime_type="video/3gpp" res="240p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">,
   <Stream: itag="17" mime_type="video/3gpp" res="144p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">,
   <Stream: itag="137" mime_type="video/mp4" res="1080p" fps="30fps" vcodec="avc1.640028">,
   <Stream: itag="248" mime_type="video/webm" res="1080p" fps="30fps" vcodec="vp9">,
   <Stream: itag="136" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.4d401f">,
   <Stream: itag="247" mime_type="video/webm" res="720p" fps="30fps" vcodec="vp9">,
   <Stream: itag="135" mime_type="video/mp4" res="480p" fps="30fps" vcodec="avc1.4d401e">,
   <Stream: itag="244" mime_type="video/webm" res="480p" fps="30fps" vcodec="vp9">,
   <Stream: itag="134" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.4d401e">,
   <Stream: itag="243" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp9">,
   <Stream: itag="133" mime_type="video/mp4" res="240p" fps="30fps" vcodec="avc1.4d4015">,
   <Stream: itag="242" mime_type="video/webm" res="240p" fps="30fps" vcodec="vp9">,
   <Stream: itag="160" mime_type="video/mp4" res="144p" fps="30fps" vcodec="avc1.4d400c">,
   <Stream: itag="278" mime_type="video/webm" res="144p" fps="30fps" vcodec="vp9">,
   <Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">,
   <Stream: itag="171" mime_type="audio/webm" abr="128kbps" acodec="vorbis">,
   <Stream: itag="249" mime_type="audio/webm" abr="50kbps" acodec="opus">,
   <Stream: itag="250" mime_type="audio/webm" abr="70kbps" acodec="opus">,
   <Stream: itag="251" mime_type="audio/webm" abr="160kbps" acodec="opus">]
  ```
  You may notice that some streams listed have both a video codec and audio codec, while others have just video or just audio, this is a result of YouTube supporting a streaming technique called Dynamic Adaptive Streaming over HTTP (DASH).

  In the context of pytube, the implications are for the highest quality streams; you now need to download both the audio and video tracks and then post-process them with software like FFmpeg to merge them.

  The legacy streams that contain the audio and video in a single file (referred to as "progressive download") are still available, but only for resolutions 720p and below.

  To only view these progressive download streams:

  ```python
   >>> yt.streams.filter(progressive=True).all()
    [<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">,
    <Stream: itag="43" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp8.0" acodec="vorbis">,
    <Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">,
    <Stream: itag="36" mime_type="video/3gpp" res="240p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">,
    <Stream: itag="17" mime_type="video/3gpp" res="144p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">]
  ```

  Conversely, if you only want to see the DASH streams (also referred to as "adaptive") you can do:

  ```python
  >>> yt.streams.filter(adaptive=True).all()
   [<Stream: itag="137" mime_type="video/mp4" res="1080p" fps="30fps" vcodec="avc1.640028">,
    <Stream: itag="248" mime_type="video/webm" res="1080p" fps="30fps" vcodec="vp9">,
    <Stream: itag="136" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.4d401f">,
    <Stream: itag="247" mime_type="video/webm" res="720p" fps="30fps" vcodec="vp9">,
    <Stream: itag="135" mime_type="video/mp4" res="480p" fps="30fps" vcodec="avc1.4d401e">,
    <Stream: itag="244" mime_type="video/webm" res="480p" fps="30fps" vcodec="vp9">,
    <Stream: itag="134" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.4d401e">,
    <Stream: itag="243" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp9">,
    <Stream: itag="133" mime_type="video/mp4" res="240p" fps="30fps" vcodec="avc1.4d4015">,
    <Stream: itag="242" mime_type="video/webm" res="240p" fps="30fps" vcodec="vp9">,
    <Stream: itag="160" mime_type="video/mp4" res="144p" fps="30fps" vcodec="avc1.4d400c">,
    <Stream: itag="278" mime_type="video/webm" res="144p" fps="30fps" vcodec="vp9">,
    <Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">,
    <Stream: itag="171" mime_type="audio/webm" abr="128kbps" acodec="vorbis">,
    <Stream: itag="249" mime_type="audio/webm" abr="50kbps" acodec="opus">,
    <Stream: itag="250" mime_type="audio/webm" abr="70kbps" acodec="opus">,
    <Stream: itag="251" mime_type="audio/webm" abr="160kbps" acodec="opus">]
  ```

  You can also download a complete Youtube playlist:

  ```python
  >>> from pytube import Playlist
  >>> pl = Playlist("https://www.youtube.com/watch?v=Edpy1szoG80&list=PL153hDY-y1E00uQtCVCVC8xJ25TYX8yPU")
  >>> pl.download_all()
  >>> # or if you want to download in a specific directory
  >>> pl.download_all('/path/to/directory/')
  ```
  This will download the highest progressive stream available (generally 720p) from the given playlist. Later more options would be given for user's flexibility
  to choose video resolution.

  Pytube allows you to filter on every property available (see the documentation for the complete list), let's take a look at some of the most useful ones.

  To list the audio only streams:

  ```python
  >>> yt.streams.filter(only_audio=True).all()
    [<Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">,
    <Stream: itag="171" mime_type="audio/webm" abr="128kbps" acodec="vorbis">,
    <Stream: itag="249" mime_type="audio/webm" abr="50kbps" acodec="opus">,
    <Stream: itag="250" mime_type="audio/webm" abr="70kbps" acodec="opus">,
    <Stream: itag="251" mime_type="audio/webm" abr="160kbps" acodec="opus">]
  ```

  To list only ``mp4`` streams:

  ```python
  >>> yt.streams.filter(subtype='mp4').all()
   [<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">,
    <Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">,
    <Stream: itag="137" mime_type="video/mp4" res="1080p" fps="30fps" vcodec="avc1.640028">,
    <Stream: itag="136" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.4d401f">,
    <Stream: itag="135" mime_type="video/mp4" res="480p" fps="30fps" vcodec="avc1.4d401e">,
    <Stream: itag="134" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.4d401e">,
    <Stream: itag="133" mime_type="video/mp4" res="240p" fps="30fps" vcodec="avc1.4d4015">,
    <Stream: itag="160" mime_type="video/mp4" res="144p" fps="30fps" vcodec="avc1.4d400c">,
    <Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">]
  ```

  Multiple filters can also be specified:

  ```python
  >>> yt.streams.filter(subtype='mp4', progressive=True).all()
  >>> # this can also be expressed as:
  >>> yt.streams.filter(subtype='mp4').filter(progressive=True).all()
    [<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">,
    <Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">]
  ```
  You also have an interface to select streams by their itag, without needing to filter:

  ```python
  >>> yt.streams.get_by_itag(22)
    <Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">
  ```

  If you need to optimize for a specific feature, such as the "highest resolution" or "lowest average bitrate":

  ```python
  >>> yt.streams.filter(progressive=True).order_by('resolution').desc().all()
  ```
  Note that ``order_by`` cannot be used if your attribute is undefined in any of the Stream instances, so be sure to apply a filter to remove those before calling it.

  If your application requires post-processing logic, pytube allows you to specify an "on download complete" callback function:

  ```python
   >>> def convert_to_aac(stream, file_handle):
           return  # do work

   >>> yt.register_on_complete_callback(convert_to_aac)
  ```

  Similarly, if your application requires on-download progress logic, pytube exposes a callback for this as well:

  ```python
   >>> def show_progress_bar(stream, chunk, file_handle, bytes_remaining):
           return  # do work

   >>> yt.register_on_progress_callback(show_progress_bar)
  ```



  pytube also ships with a tiny cli interface for downloading and probing videos.

  Let's start with downloading:

  ```bash
  $ pytube http://youtube.com/watch?v=9bZkp7q19f0 --itag=22
  ```
  To view available streams:

  ```bash
  $ pytube http://youtube.com/watch?v=9bZkp7q19f0 --list
  ```

  Finally, if you're filing a bug report, the cli contains a switch called ``--build-playback-report``, which bundles up the state, allowing others to easily replay your issue.

location_href:
  00011372-python-a-pytube-fork-for-spotdl-users/python-a-pytube-fork-for-spotdl-users-9.6.4-1.src.rpm


pkgId: d09b6e9e575d79e08904e6c3b877768605216c470566ed7723b90a5199563aa7
name: python-a-pytube-fork-for-spotdl-users-help
arch: noarch
version: 9.6.4
epoch: 0
release: 1
summary: Development documents and examples for a-pytube-fork-for-spotdl-users
url: https://github.com/nficano/pytube
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9351e33c-8f13-4841-80a1-7cfc43ac1505
rpm_sourcerpm: python-a-pytube-fork-for-spotdl-users-9.6.4-1.src.rpm
checksum_type: sha256
description:
  Ping @ronncc if you would like to help out

  <div align="center">
    <p>
    <img src="https://github.com/nficano/pytube/blob/master/images/pytube.png?raw=true" width="350" height="328" alt="pytube logo" />
    </p>
    <p align="center">
  	  <img src="https://img.shields.io/pypi/v/pytube.svg" alt="pypi">
  	  <a href="https://travis-ci.org/nficano/pytube"><img src="https://travis-ci.org/nficano/pytube.svg?branch=master" /></a>
  	  <a href="http://python-pytube.readthedocs.io/en/latest/?badge=latest"><img src="https://readthedocs.org/projects/python-pytube/badge/?version=latest" /></a>
  	  <a href="https://coveralls.io/github/nficano/pytube?branch=master"><img src="https://coveralls.io/repos/github/nficano/pytube/badge.svg?branch=master#23e6f7ac56dd3bde" /></a>
        <a href="https://pypi.org/project/pytube/"><img src="https://img.shields.io/pypi/dm/pytube.svg" alt="pypi"></a>
  	  <a href="https://pypi.python.org/pypi/pytube/"><img src="https://img.shields.io/pypi/pyversions/pytube.svg" /></a>
      <p>
    </p>
  </div>


  *pytube* is a very serious, lightweight, dependency-free Python library (and command-line utility) for downloading YouTube Videos.


  YouTube is the most popular video-sharing platform in the world and as a hacker you may encounter a situation where you want to script something to download videos.  For this I present to you *pytube*.

  *pytube* is a lightweight library written in Python. It has no third party dependencies and aims to be highly reliable.

  *pytube* also makes pipelining easy, allowing you to specify callback functions for different download events, such as  ``on progress`` or ``on complete``.

  Finally *pytube* also includes a command-line utility, allowing you to quickly download videos right from terminal.



  ```python
   >>> YouTube('https://youtu.be/9bZkp7q19f0').streams.first().download()
   >>> yt = YouTube('http://youtube.com/watch?v=9bZkp7q19f0')
   >>> yt.streams
    ... .filter(progressive=True, file_extension='mp4')
    ... .order_by('resolution')
    ... .desc()
    ... .first()
    ... .download()
  ```


  - Support for Both Progressive & DASH Streams
  - Support for downloading complete playlist
  - Easily Register ``on_download_progress`` & ``on_download_complete`` callbacks
  - Command-line Interfaced Included
  - Caption Track Support
  - Outputs Caption Tracks to .srt format (SubRip Subtitle)
  - Ability to Capture Thumbnail URL.
  - Extensively Documented Source Code
  - No Third-Party Dependencies



  Download using pip via pypi.

  ```bash
  $ pip install pytube
  ```



  Let's begin with showing how easy it is to download a video with pytube:

  ```python
  >>> from pytube import YouTube
  >>> YouTube('http://youtube.com/watch?v=9bZkp7q19f0').streams.first().download()
  ```
  This example will download the highest quality progressive download stream available.

  Next, let's explore how we would view what video streams are available:

  ```python
  >>> yt = YouTube('http://youtube.com/watch?v=9bZkp7q19f0')
  >>> yt.streams.all()
   [<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">,
   <Stream: itag="43" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp8.0" acodec="vorbis">,
   <Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">,
   <Stream: itag="36" mime_type="video/3gpp" res="240p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">,
   <Stream: itag="17" mime_type="video/3gpp" res="144p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">,
   <Stream: itag="137" mime_type="video/mp4" res="1080p" fps="30fps" vcodec="avc1.640028">,
   <Stream: itag="248" mime_type="video/webm" res="1080p" fps="30fps" vcodec="vp9">,
   <Stream: itag="136" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.4d401f">,
   <Stream: itag="247" mime_type="video/webm" res="720p" fps="30fps" vcodec="vp9">,
   <Stream: itag="135" mime_type="video/mp4" res="480p" fps="30fps" vcodec="avc1.4d401e">,
   <Stream: itag="244" mime_type="video/webm" res="480p" fps="30fps" vcodec="vp9">,
   <Stream: itag="134" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.4d401e">,
   <Stream: itag="243" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp9">,
   <Stream: itag="133" mime_type="video/mp4" res="240p" fps="30fps" vcodec="avc1.4d4015">,
   <Stream: itag="242" mime_type="video/webm" res="240p" fps="30fps" vcodec="vp9">,
   <Stream: itag="160" mime_type="video/mp4" res="144p" fps="30fps" vcodec="avc1.4d400c">,
   <Stream: itag="278" mime_type="video/webm" res="144p" fps="30fps" vcodec="vp9">,
   <Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">,
   <Stream: itag="171" mime_type="audio/webm" abr="128kbps" acodec="vorbis">,
   <Stream: itag="249" mime_type="audio/webm" abr="50kbps" acodec="opus">,
   <Stream: itag="250" mime_type="audio/webm" abr="70kbps" acodec="opus">,
   <Stream: itag="251" mime_type="audio/webm" abr="160kbps" acodec="opus">]
  ```
  You may notice that some streams listed have both a video codec and audio codec, while others have just video or just audio, this is a result of YouTube supporting a streaming technique called Dynamic Adaptive Streaming over HTTP (DASH).

  In the context of pytube, the implications are for the highest quality streams; you now need to download both the audio and video tracks and then post-process them with software like FFmpeg to merge them.

  The legacy streams that contain the audio and video in a single file (referred to as "progressive download") are still available, but only for resolutions 720p and below.

  To only view these progressive download streams:

  ```python
   >>> yt.streams.filter(progressive=True).all()
    [<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">,
    <Stream: itag="43" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp8.0" acodec="vorbis">,
    <Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">,
    <Stream: itag="36" mime_type="video/3gpp" res="240p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">,
    <Stream: itag="17" mime_type="video/3gpp" res="144p" fps="30fps" vcodec="mp4v.20.3" acodec="mp4a.40.2">]
  ```

  Conversely, if you only want to see the DASH streams (also referred to as "adaptive") you can do:

  ```python
  >>> yt.streams.filter(adaptive=True).all()
   [<Stream: itag="137" mime_type="video/mp4" res="1080p" fps="30fps" vcodec="avc1.640028">,
    <Stream: itag="248" mime_type="video/webm" res="1080p" fps="30fps" vcodec="vp9">,
    <Stream: itag="136" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.4d401f">,
    <Stream: itag="247" mime_type="video/webm" res="720p" fps="30fps" vcodec="vp9">,
    <Stream: itag="135" mime_type="video/mp4" res="480p" fps="30fps" vcodec="avc1.4d401e">,
    <Stream: itag="244" mime_type="video/webm" res="480p" fps="30fps" vcodec="vp9">,
    <Stream: itag="134" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.4d401e">,
    <Stream: itag="243" mime_type="video/webm" res="360p" fps="30fps" vcodec="vp9">,
    <Stream: itag="133" mime_type="video/mp4" res="240p" fps="30fps" vcodec="avc1.4d4015">,
    <Stream: itag="242" mime_type="video/webm" res="240p" fps="30fps" vcodec="vp9">,
    <Stream: itag="160" mime_type="video/mp4" res="144p" fps="30fps" vcodec="avc1.4d400c">,
    <Stream: itag="278" mime_type="video/webm" res="144p" fps="30fps" vcodec="vp9">,
    <Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">,
    <Stream: itag="171" mime_type="audio/webm" abr="128kbps" acodec="vorbis">,
    <Stream: itag="249" mime_type="audio/webm" abr="50kbps" acodec="opus">,
    <Stream: itag="250" mime_type="audio/webm" abr="70kbps" acodec="opus">,
    <Stream: itag="251" mime_type="audio/webm" abr="160kbps" acodec="opus">]
  ```

  You can also download a complete Youtube playlist:

  ```python
  >>> from pytube import Playlist
  >>> pl = Playlist("https://www.youtube.com/watch?v=Edpy1szoG80&list=PL153hDY-y1E00uQtCVCVC8xJ25TYX8yPU")
  >>> pl.download_all()
  >>> # or if you want to download in a specific directory
  >>> pl.download_all('/path/to/directory/')
  ```
  This will download the highest progressive stream available (generally 720p) from the given playlist. Later more options would be given for user's flexibility
  to choose video resolution.

  Pytube allows you to filter on every property available (see the documentation for the complete list), let's take a look at some of the most useful ones.

  To list the audio only streams:

  ```python
  >>> yt.streams.filter(only_audio=True).all()
    [<Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">,
    <Stream: itag="171" mime_type="audio/webm" abr="128kbps" acodec="vorbis">,
    <Stream: itag="249" mime_type="audio/webm" abr="50kbps" acodec="opus">,
    <Stream: itag="250" mime_type="audio/webm" abr="70kbps" acodec="opus">,
    <Stream: itag="251" mime_type="audio/webm" abr="160kbps" acodec="opus">]
  ```

  To list only ``mp4`` streams:

  ```python
  >>> yt.streams.filter(subtype='mp4').all()
   [<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">,
    <Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">,
    <Stream: itag="137" mime_type="video/mp4" res="1080p" fps="30fps" vcodec="avc1.640028">,
    <Stream: itag="136" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.4d401f">,
    <Stream: itag="135" mime_type="video/mp4" res="480p" fps="30fps" vcodec="avc1.4d401e">,
    <Stream: itag="134" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.4d401e">,
    <Stream: itag="133" mime_type="video/mp4" res="240p" fps="30fps" vcodec="avc1.4d4015">,
    <Stream: itag="160" mime_type="video/mp4" res="144p" fps="30fps" vcodec="avc1.4d400c">,
    <Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2">]
  ```

  Multiple filters can also be specified:

  ```python
  >>> yt.streams.filter(subtype='mp4', progressive=True).all()
  >>> # this can also be expressed as:
  >>> yt.streams.filter(subtype='mp4').filter(progressive=True).all()
    [<Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">,
    <Stream: itag="18" mime_type="video/mp4" res="360p" fps="30fps" vcodec="avc1.42001E" acodec="mp4a.40.2">]
  ```
  You also have an interface to select streams by their itag, without needing to filter:

  ```python
  >>> yt.streams.get_by_itag(22)
    <Stream: itag="22" mime_type="video/mp4" res="720p" fps="30fps" vcodec="avc1.64001F" acodec="mp4a.40.2">
  ```

  If you need to optimize for a specific feature, such as the "highest resolution" or "lowest average bitrate":

  ```python
  >>> yt.streams.filter(progressive=True).order_by('resolution').desc().all()
  ```
  Note that ``order_by`` cannot be used if your attribute is undefined in any of the Stream instances, so be sure to apply a filter to remove those before calling it.

  If your application requires post-processing logic, pytube allows you to specify an "on download complete" callback function:

  ```python
   >>> def convert_to_aac(stream, file_handle):
           return  # do work

   >>> yt.register_on_complete_callback(convert_to_aac)
  ```

  Similarly, if your application requires on-download progress logic, pytube exposes a callback for this as well:

  ```python
   >>> def show_progress_bar(stream, chunk, file_handle, bytes_remaining):
           return  # do work

   >>> yt.register_on_progress_callback(show_progress_bar)
  ```



  pytube also ships with a tiny cli interface for downloading and probing videos.

  Let's start with downloading:

  ```bash
  $ pytube http://youtube.com/watch?v=9bZkp7q19f0 --itag=22
  ```
  To view available streams:

  ```bash
  $ pytube http://youtube.com/watch?v=9bZkp7q19f0 --list
  ```

  Finally, if you're filing a bug report, the cli contains a switch called ``--build-playback-report``, which bundles up the state, allowing others to easily replay your issue.

location_href:
  00011372-python-a-pytube-fork-for-spotdl-users/python-a-pytube-fork-for-spotdl-users-help-9.6.4-1.noarch.rpm


pkgId: ec1004776e519239f68adf6268b6dedd37170f24b3906016747adc4a47634a02
name: python-aaargh
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: An astonishingly awesome application argument helper
url: https://github.com/wbolster/aaargh
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-710f47dc-5d43-4ed4-9c12-1db99f615f8f
location_href: 00002930-python-aaargh/python-aaargh-0.7.1-1.src.rpm
checksum_type: sha256
description:
  The Python standard library contains the *optparse*, *getopt*, and *argparse*
  modules, and out in the wild you will find many alternative command line
  interface libraries stacked on top of these, such as *cliff*, *cement*,
  *opster*, *plac*, and many others. Some of these libraries separate the command
  line interface setup of your application from the actual code, some force yet
  another argument parsing API upon you, some force you to hide your code in
  non-obvious framework constructs, and some even add dependencies on other
  modules.
  This makes you scream *aaargh*. And, lo and behold, here it is!


pkgId: aa56ec81ac65fdf335d7aaa89ad058f597ea310f6171ae723cc6e687ff6d82a7
name: python-absl-py
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Abseil Python Common Libraries, see https://github.com/abseil/abseil-py.
url: https://github.com/abseil/abseil-py
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e15fc3a-55bf-4cf1-b5ef-3c59523a88fe
location_href: 00008958-python-absl-py/python-absl-py-1.4.0-1.src.rpm
checksum_type: sha256
description:
  This repository is a collection of Python library code for building Python
  applications. The code is collected from Google's own Python code base, and has
  been extensively tested and used in production.



  * Simple application startup
  * Distributed commandline flags system
  * Custom logging module with additional features
  * Testing utilities





  To install the package, simply run:

  ```bash
  pip install absl-py
  ```

  Or install from source:

  ```bash
  python setup.py install
  ```



  To run Abseil tests, you can clone the git repo and run
  [bazel](https://bazel.build/):

  ```bash
  git clone https://github.com/abseil/abseil-py.git
  cd abseil-py
  bazel test absl/...
  ```



  Please refer to
  [smoke_tests/sample_app.py](https://github.com/abseil/abseil-py/blob/main/smoke_tests/sample_app.py)
  as an example to get started.



  See the [Abseil Python Developer Guide](https://abseil.io/docs/python/).



  The current repository includes an initial set of libraries for early adoption.
  More components and interoperability with Abseil C++ Common Libraries
  will come in future releases.



  The Abseil Python library is licensed under the terms of the Apache
  license. See [LICENSE](LICENSE) for more information.


pkgId: 1ad42a9166995b50755d39ea6897a8000383ff3d5f6ceb28b80ba4d09a0c255d
name: python-accelerate
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Accelerate
url: https://github.com/huggingface/accelerate
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-57edc348-5070-4343-818d-7a182c9ba129
location_href: 00012430-python-accelerate/python-accelerate-0.18.0-1.src.rpm
checksum_type: sha256
description:
  <!---
  Copyright 2021 The HuggingFace Team. All rights reserved.

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

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

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

  <p align="center">
      <br>
      <img src="docs/source/imgs/accelerate_logo.png" width="400"/>
      <br>
  <p>

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

  <h3 align="center">
  <p>Run your *raw* PyTorch training script on any kind of device
  </h3>

  <h3 align="center">
      <a href="https://hf.co/course"><img src="https://raw.githubusercontent.com/huggingface/accelerate/main/docs/source/imgs/course_banner.png"></a>
  </h3>



  🤗 Accelerate was created for PyTorch users who like to write the training loop of PyTorch models but are reluctant to write and maintain the boilerplate code needed to use multi-GPUs/TPU/fp16.

  🤗 Accelerate abstracts exactly and only the boilerplate code related to multi-GPUs/TPU/fp16 and leaves the rest of your code unchanged.

  Here is an example:

  ```diff
    import torch
    import torch.nn.functional as F
    from datasets import load_dataset
  + from accelerate import Accelerator

  + accelerator = Accelerator()
  - device = 'cpu'
  + device = accelerator.device

    model = torch.nn.Transformer().to(device)
    optimizer = torch.optim.Adam(model.parameters())

    dataset = load_dataset('my_dataset')
    data = torch.utils.data.DataLoader(dataset, shuffle=True)

  + model, optimizer, data = accelerator.prepare(model, optimizer, data)

    model.train()
    for epoch in range(10):
        for source, targets in data:
            source = source.to(device)
            targets = targets.to(device)

            optimizer.zero_grad()

            output = model(source)
            loss = F.cross_entropy(output, targets)

  -         loss.backward()
  +         accelerator.backward(loss)

            optimizer.step()
  ```

  As you can see in this example, by adding 5-lines to any standard PyTorch training script you can now run on any kind of single or distributed node setting (single CPU, single GPU, multi-GPUs and TPUs) as well as with or without mixed precision (fp16).

  In particular, the same code can then be run without modification on your local machine for debugging or your training environment.

  🤗 Accelerate even handles the device placement for you (which requires a few more changes to your code, but is safer in general), so you can even simplify your training loop further:

  ```diff
    import torch
    import torch.nn.functional as F
    from datasets import load_dataset
  + from accelerate import Accelerator

  - device = 'cpu'
  + accelerator = Accelerator()

  - model = torch.nn.Transformer().to(device)
  + model = torch.nn.Transformer()
    optimizer = torch.optim.Adam(model.parameters())

    dataset = load_dataset('my_dataset')
    data = torch.utils.data.DataLoader(dataset, shuffle=True)

  + model, optimizer, data = accelerator.prepare(model, optimizer, data)

    model.train()
    for epoch in range(10):
        for source, targets in data:
  -         source = source.to(device)
  -         targets = targets.to(device)

            optimizer.zero_grad()

            output = model(source)
            loss = F.cross_entropy(output, targets)

  -         loss.backward()
  +         accelerator.backward(loss)

            optimizer.step()
  ```

  Want to learn more? Check out the [documentation](https://huggingface.co/docs/accelerate) or have look at our [examples](https://github.com/huggingface/accelerate/tree/main/examples).



  🤗 Accelerate also provides an optional CLI tool that allows you to quickly configure and test your training environment before launching the scripts. No need to remember how to use `torch.distributed.run` or to write a specific launcher for TPU training!
  On your machine(s) just run:

  ```bash
  accelerate config
  ```

  and answer the questions asked. This will generate a config file that will be used automatically to properly set the default options when doing

  ```bash
  accelerate launch my_script.py --args_to_my_script
  ```

  For instance, here is how you would run the GLUE example on the MRPC task (from the root of the repo):

  ```bash
  accelerate launch examples/nlp_example.py
  ```

  This CLI tool is **optional**, and you can still use `python my_script.py` or `python -m torchrun my_script.py` at your convenance.



  🤗 Here is another way to launch multi-CPU run using MPI. You can learn how to install Open MPI on [this page](https://www.open-mpi.org/faq/?category=building#easy-build). You can use Intel MPI or MVAPICH as well.
  Once you have MPI setup on your cluster, just run:

  ```bash
  mpirun -np 2 python examples/nlp_example.py
  ```



  🤗 Accelerate supports training on single/multiple GPUs using DeepSpeed. To use it, you don't need to change anything in your training code; you can set everything using just `accelerate config`. However, if you desire to tweak your DeepSpeed related args from your python script, we provide you the `DeepSpeedPlugin`.

  ```python
  from accelerate import Accelerator, DeepSpeedPlugin



  deepspeed_plugin = DeepSpeedPlugin(zero_stage=2, gradient_accumulation_steps=2)
  accelerator = Accelerator(mixed_precision='fp16', deepspeed_plugin=deepspeed_plugin)


  accelerator.wait_for_everyone()
  unwrapped_model = accelerator.unwrap_model(model)
  unwrapped_model.save_pretrained(save_dir, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model))
  ```

  Note: DeepSpeed support is experimental for now. In case you get into some problem, please open an issue.



  🤗 Accelerate also provides a `notebook_launcher` function you can use in a notebook to launch a distributed training. This is especially useful for Colab or Kaggle notebooks with a TPU backend. Just define your training loop in a `training_function` then in your last cell, add:

  ```python
  from accelerate import notebook_launcher

  notebook_launcher(training_function)
  ```

  An example can be found in [this notebook](https://github.com/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb). [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/accelerate_examples/simple_nlp_example.ipynb)



  You should use 🤗 Accelerate when you want to easily run your training scripts in a distributed environment without having to renounce full control over your training loop. This is not a high-level framework above PyTorch, just a thin wrapper so you don't have to learn a new library, In fact the whole API of 🤗 Accelerate is in one class, the `Accelerator` object.



  You shouldn't use 🤗 Accelerate if you don't want to write a training loop yourself. There are plenty of high-level libraries above PyTorch that will offer you that, 🤗 Accelerate is not one of them.



  If you like the simplicity of 🤗 Accelerate but would prefer a higher-level abstraction around its capabilities, some frameworks and libraries that are built on top of 🤗 Accelerate are listed below:

  * [Animus](https://github.com/Scitator/animus) is a minimalistic framework to run machine learning experiments. Animus highlights common "breakpoints" in ML experiments and provides a unified interface for them within [IExperiment](https://github.com/Scitator/animus/blob/main/animus/core.py#L76).
  * [Catalyst](https://github.com/catalyst-team/catalyst#getting-started) is a PyTorch framework for Deep Learning Research and Development. It focuses on reproducibility, rapid experimentation, and codebase reuse so you can create something new rather than write yet another train loop. Catalyst provides a [Runner](https://catalyst-team.github.io/catalyst/api/core.html#runner) to connect all parts of the experiment: hardware backend, data transformations, model train, and inference logic.
  * [fastai](https://github.com/fastai/fastai#installing) is a PyTorch framework for Deep Learning that simplifies training fast and accurate neural nets using modern best practices. fastai provides a [Learner](https://docs.fast.ai/learner.html#Learner) to handle the training, fine-tuning, and inference of deep learning algorithms.
  * [Finetuner](https://github.com/jina-ai/finetuner) is a service that enables models to create higher-quality embeddings for semantic search, visual similarity search, cross-modal text<->image search, recommendation systems, clustering, duplication detection, anomaly detection, or other uses.
  * [InvokeAI](https://github.com/invoke-ai/InvokeAI) is a creative engine for Stable Diffusion models, offering industry-leading WebUI, terminal usage support, and serves as the foundation for many commercial products.
  * [Kornia](https://kornia.readthedocs.io/en/latest/get-started/introduction.html) is a differentiable library that allows classical computer vision to be integrated into deep learning models. Kornia provides a [Trainer](https://kornia.readthedocs.io/en/latest/x.html#kornia.x.Trainer) with the specific purpose to train and fine-tune the supported deep learning algorithms within the library.
  * [Open Assistant](https://projects.laion.ai/Open-Assistant/) is a chat-based assistant that understands tasks, can interact with their party systems, and retrieve information dynamically to do so.
  * [pytorch-accelerated](https://github.com/Chris-hughes10/pytorch-accelerated) is a lightweight training library, with a streamlined feature set centred around a general-purpose [Trainer](https://pytorch-accelerated.readthedocs.io/en/latest/trainer.html), that places a huge emphasis on simplicity and transparency; enabling users to understand exactly what is going on under the hood, but without having to write and maintain the boilerplate themselves!
  * [Stable Diffusion web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) is an open-source browser-based easy-to-use interface based on the Gradio library for Stable Diffusion.




  This repository is tested on Python 3.6+ and PyTorch 1.4.0+

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

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

  Then, you will need to install PyTorch: refer to the [official installation page](https://pytorch.org/get-started/locally/#start-locally) regarding the specific install command for your platform. Then 🤗 Accelerate can be installed using pip as follows:

  ```bash
  pip install accelerate
  ```



  - CPU only
  - multi-CPU on one node (machine)
  - multi-CPU on several nodes (machines)
  - single GPU
  - multi-GPU on one node (machine)
  - multi-GPU on several nodes (machines)
  - TPU
  - FP16 with native AMP (apex on the roadmap)
  - DeepSpeed support (Experimental)
  - PyTorch Fully Sharded Data Parallel (FSDP) support (Experimental)
  - Megatron-LM support (Experimental)



  If you use 🤗 Accelerate in your publication, please cite it by using the following BibTeX entry.

  ```bibtex
  @Misc{accelerate,
    title =        {Accelerate: Training and inference at scale made simple, efficient and adaptable.},
    author =       {Sylvain Gugger, Lysandre Debut, Thomas Wolf, Philipp Schmid, Zachary Mueller, Sourab Mangrulkar},
    howpublished = {\url{https://github.com/huggingface/accelerate}},
    year =         {2022}
  }
  ```


pkgId: f35197d645ba6c110b80226d26090783bc92c3dff06c6e74871139f5ab494d67
name: python-accuweather
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Python wrapper for getting weather data from AccuWeather servers.
url: https://github.com/bieniu/accuweather
rpm_license: Apache-2.0 License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-132f6251-015e-48de-9857-d77ad7db9ffa
location_href: 00002933-python-accuweather/python-accuweather-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![PyPI][pypi-releases-shield]][pypi-releases]
  [![PyPI - Downloads][pypi-downloads]][pypi-statistics]
  [![Buy me a coffee][buy-me-a-coffee-shield]][buy-me-a-coffee]
  [![PayPal_Me][paypal-me-shield]][paypal-me]



  Python wrapper for getting weather data from AccuWeather servers for Limited Trial package.




  To generate API key go to https://developer.accuweather.com/user/register and after registration create an app.



  ```python
  import asyncio
  import logging

  from aiohttp import ClientError, ClientSession

  from accuweather import (
      AccuWeather,
      ApiError,
      InvalidApiKeyError,
      InvalidCoordinatesError,
      RequestsExceededError,
  )

  LATITUDE = 52.0677904
  LONGITUDE = 19.4795644
  LOCATION_KEY = "268068"
  API_KEY = "xxxxx"

  logging.basicConfig(level=logging.DEBUG)


  async def main():
      async with ClientSession() as websession:
          try:
              accuweather = AccuWeather(
                  API_KEY, websession, latitude=LATITUDE, longitude=LONGITUDE
              )
              current_conditions = await accuweather.async_get_current_conditions()
              forecast = await accuweather.async_get_forecast(metric=True)
              forecast_hourly = await accuweather.async_get_forecast_hourly(metric=True)
          except (
              ApiError,
              InvalidApiKeyError,
              InvalidCoordinatesError,
              ClientError,
              RequestsExceededError,
          ) as error:
              print(f"Error: {error}")
          else:
              print(f"Location: {accuweather.location_name} ({accuweather.location_key})")
              print(f"Requests remaining: {accuweather.requests_remaining}")
              print(f"Current: {current_conditions}")
              print(f"Forecast: {forecast}")
              print(f"Forecast hourly: {forecast_hourly}")


  loop = asyncio.new_event_loop()
  loop.run_until_complete(main())
  loop.close()

  ```

  [releases]: https://github.com/bieniu/accuweather/releases
  [releases-shield]: https://img.shields.io/github/release/bieniu/accuweather.svg?style=popout
  [pypi-releases]: https://pypi.org/project/accuweather/
  [pypi-statistics]: https://pepy.tech/project/accuweather
  [pypi-releases-shield]: https://img.shields.io/pypi/v/accuweather
  [pypi-downloads]: https://pepy.tech/badge/accuweather/month
  [buy-me-a-coffee-shield]: https://img.shields.io/static/v1.svg?label=%20&message=Buy%20me%20a%20coffee&color=6f4e37&logo=buy%20me%20a%20coffee&logoColor=white
  [buy-me-a-coffee]: https://www.buymeacoffee.com/QnLdxeaqO
  [paypal-me-shield]: https://img.shields.io/static/v1.svg?label=%20&message=PayPal.Me&logo=paypal
  [paypal-me]: https://www.paypal.me/bieniu79


pkgId: 4f39f5a45f54af51bfffbd5a9b4a583ef94880822d2b98732d98791ec7078524
name: python-actdiag
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: actdiag generates activity-diagram image from text
url: http://blockdiag.com/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-42d7111e-379b-4eda-a7d7-c8f273d88ca7
location_href: 00002948-python-actdiag/python-actdiag-3.0.0-1.src.rpm
checksum_type: sha256
description:
  * Generate activity-diagram from dot like text (basic feature).
  * Multilingualization for node-label (utf-8 only).
  You can get some examples and generated images on
  `blockdiag.com <http://blockdiag.com/actdiag/build/html/index.html>`_ .


pkgId: 5fd499eba7cde1a211dfa7009c71163ddc0d01193fb145b83a32ea8493ac942a
name: python-adal
arch: src
version: 1.2.7
epoch: 0
release: 1
url: https://github.com/AzureAD/azure-activedirectory-library-for-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-78299828-5a23-496d-a90d-6566667c6d4c
location_href: 00002951-python-adal/python-adal-1.2.7-1.src.rpm
checksum_type: sha256
summary:
  Note: This library is already replaced by MSAL Python, available here: https://pypi.org/project/msal/ .ADAL Python remains available here as a legacy. The ADAL for Python library makes it easy for python application to authenticate to Azure Active Directory (AAD) in order to access AAD protected web resources.

description:
  This library, ADAL for Python, will no longer receive new feature improvements. Instead, use the new library
  [MSAL for Python](https://github.com/AzureAD/microsoft-authentication-library-for-python).
  * If you are starting a new project, you can get started with the
    [MSAL Python docs](https://github.com/AzureAD/microsoft-authentication-library-for-python/wiki)
    for details about the scenarios, usage, and relevant concepts.
  * If your application is using the previous ADAL Python library, you can follow this
    [migration guide](https://docs.microsoft.com/en-us/azure/active-directory/develop/migrate-python-adal-msal)
    to update to MSAL Python.


pkgId: 982fa1b7bea53f507454f1ceedba67ef4365b5cb868292483c5ade6a00e4a288
name: python-adapt
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Awesome Domain Adaptation Python Toolbox for Tensorflow and Scikit-learn
url: https://github.com/adapt-python/adapt.git
rpm_license: BSD-2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3e052727-42bf-46cc-82fd-29287761413f
location_href: 00002952-python-adapt/python-adapt-0.4.2-1.src.rpm
checksum_type: sha256
description:
  ADAPT is an open source library providing numerous tools to perform Transfer Learning and Domain Adaptation.
  The purpose of the ADAPT library is to facilitate the access to transfer learning algorithms for a large public, including industrial players. ADAPT is specifically designed for [Scikit-learn](https://scikit-learn.org/stable/) and [Tensorflow](https://www.tensorflow.org/) users with a "user-friendly" approach. All objects in ADAPT implement the ***fit***, ***predict*** and ***score*** methods like any scikit-learn object. A very detailed documentation with several examples is provided:
  <table>
    <tr valign="top">
      <td width="50%" >
          <a href="https://adapt-python.github.io/adapt/examples/Sample_bias_example.html">
              <br>
              <b>Sample bias correction</b>
              <br>
              <br>
              <img src="https://github.com/adapt-python/adapt/raw/41c13055facc0733faf49c4e3979709e82be10e5/docs/_static/images/sample_bias_corr_img.png">
          </a>
      </td>
      <td width="50%">
          <a href="https://adapt-python.github.io/adapt/examples/Flowers_example.html">
              <br>
              <b>Model-based Transfer</b>
              <br>
              <br>
              <img src="https://github.com/adapt-python/adapt/raw/41c13055facc0733faf49c4e3979709e82be10e5/docs/_static/images/finetuned.png">
          </a>
      </td>
    </tr>
    <tr valign="top">
      <td width="50%">
          <a href="https://adapt-python.github.io/adapt/examples/Office_example.html">
              <br>
              <b>Deep Domain Adaptation</b>
              <br>
              <br>
              <img src="https://github.com/adapt-python/adapt/raw/41c13055facc0733faf49c4e3979709e82be10e5/docs/_static/images/office_item.png">
          </a>
      </td>
      <td width="50%">
          <a href="https://adapt-python.github.io/adapt/examples/Multi_fidelity.html">
              <br>
              <b>Multi-Fidelity Transfer</b>
              <br>
              <br>
              <img src="https://raw.githubusercontent.com/adapt-python/adapt/a490a5c4cefb80d6222bc831a8cc25b2f65221ce/docs/_static/images/multifidelity_setup.png">
          </a>
      </td>
    </tr>
  </table>

  This package is available on [Pypi](https://pypi.org/project/adapt) and can be installed with the following command line:
  ```
  pip install adapt
  ```
  The following dependencies are required and will be installed with the library:
  - `numpy`
  - `scipy`
  - `tensorflow` (>= 2.0)
  - `scikit-learn`
  - `cvxopt`
  If for some reason, these packages failed to install, you can do it manually with:
  ```
  pip install numpy scipy tensorflow scikit-learn cvxopt
  ```
  Finally import the module in your python scripts with:
  ```python
  import adapt
  ```
  A simple example of usage is given in the [Qick-Start](#Quick-Start) below.

  The transfer learning methods implemented in ADAPT can be seen as scikit-learn "Meta-estimators" or tensorflow "Custom Model":
  <table>
  <tr valign="top">
  <td width="33%" >
  <br>
  <b>Adapt Estimator</b>
  <br>
  <br>
  ```python
  AdaptEstimator(
  	estimator = """A scikit-learn estimator
  	            (like Ridge(alpha=1.) for example)
  		    or a Tensorflow Model""",
  	Xt = "The target input features",
  	yt = "The target output labels (if any)",
  	**params = "Hyper-parameters of the AdaptEstimator"
  )
  ```
  <td width="33%">
  <br>
  <b>Deep Adapt Estimator</b>
  <br>
  <br>
  ```python
  DeepAdaptEstimator(
  	encoder = "A Tensorflow Model (if required)",
  	task = "A Tensorflow Model (if required)",
  	discriminator = "A Tensorflow Model (if required)",
  	Xt = "The target input features",
  	yt = "The target output labels (if any)",
  	**params = """Hyper-parameters of the DeepAdaptEstimator and
  		      the compile and fit params (optimizer, epochs...)"""
  )
  ```
  </td>
  </td>
  <td width="33%">
  <br>
  <b>Scikit-learn Meta-Estimator</b>
  <br>
  <br>
  ```python
  SklearnMetaEstimator(
  	base_estimator = """A scikit-learn estimator
  			 (like Ridge(alpha=1.) for example)""",
  	**params = "Hyper-parameters of the SklearnMetaEstimator"
  )
  ```
  </td>
  </tr>
  </table>
  As you can see, the main difference between ADAPT models and scikit-learn and tensorflow objects is the two arguments `Xt, yt` which refer to the target data. Indeed, in classical machine learning, one assumes that the fitted model is applied on data distributed according to the training distribution. This is why, in this setting, one performs cross-validation and splits uniformly the training set to evaluate a model.
  In the transfer learning framework, however, one assumes that the target data (on which the model will be used at the end) are not distributed like the source training data. Moreover, one assumes that the target distribution can be estimated and compared to the training distribution. Either because a small sample of labeled target data `Xt, yt` is avalaible or because a large sample of unlabeled target data `Xt` is at one's disposal.
  Thus, the transfer learning models from the ADAPT library can be seen as machine learning models that are fitted with a specific target in mind. This target is different but somewhat related to the training data. This is generally achieved by a transformation of the input features (see [feature-based transfer](https://adapt-python.github.io/adapt/contents.html#adapt-feature-based-feature-based-methods)) or by importance weighting (see [instance-based transfer](https://adapt-python.github.io/adapt/contents.html#adapt-instance-based)). In some cases, the training data are no more available but one aims at fine-tuning a pre-trained source model on a new target dataset (see [parameter-based transfer](https://adapt-python.github.io/adapt/contents.html#adapt-parameter-based)).

  The ADAPT library proposes numerous transfer algorithms and it can be hard to know which algorithm is best suited for a particular problem. If you do not know which algorithm to choose, this [flowchart](https://adapt-python.github.io/adapt/map.html) may help you:
  [<img src="https://github.com/adapt-python/adapt/raw/master/src_docs/_static/images/thumbnai_flowchart.PNG" width=30%>](https://adapt-python.github.io/adapt/map.html)

  Here is a simple usage example of the ADAPT library. This is a simulation of a 1D sample bias problem with binary classfication task. The source input data are distributed according to a Gaussian distribution centered in -1 with standard deviation of 2. The target data are drawn from Gaussian distribution centered in 1 with standard deviation of 2. The output labels are equal to 1 in the interval [-1, 1] and 0 elsewhere. We apply the transfer method [KMM](https://adapt-python.github.io/adapt/generated/adapt.instance_based.KMM.html) which is an unsupervised instance-based algortihm.
  ```python

  import numpy as np
  from sklearn.linear_model import LogisticRegression

  from adapt.instance_based import KMM
  np.random.seed(0)


  Xs = np.random.randn(1000, 1)*2-1
  ys = (Xs[:, 0] > -1.) & (Xs[:, 0] < 1.)

  Xt = np.random.randn(1000, 1)*2+1
  yt = (Xt[:, 0] > -1.) & (Xt[:, 0] < 1.)

  src_only = LogisticRegression(penalty="none")
  src_only.fit(Xs, ys)


  adapt_model = KMM(
      estimator=LogisticRegression(penalty="none"),
      Xt=Xt,
      kernel="rbf",  # Gaussian kernel
      gamma=1.,     # Bandwidth of the kernel
      verbose=0,
      random_state=0
  )

  adapt_model.fit(Xs, ys);

  adapt_model.score(Xt, yt)
  ```
  ```python
  >>> 0.574
  ```
  | <img src="https://github.com/adapt-python/adapt/raw/41c13055facc0733faf49c4e3979709e82be10e5/docs/_static/images/results_qs.png"> |
  |:--:|
  | **Quick-Start Plotting Results**. *The dotted and dashed lines are respectively the class separation of the "source only" and KMM models. Note that the predicted positive class is on the right of the dotted line for the "source only" model but on the left of the dashed line for KMM. (The code for plotting the Figure is available [here](https://adapt-python.github.io/adapt/examples/Quick_start.html))* |

  ADAPT package is divided in three sub-modules containing the following domain adaptation methods:

  <img src="https://raw.githubusercontent.com/adapt-python/adapt/a490a5c4cefb80d6222bc831a8cc25b2f65221ce/docs/_static/images/feature_based.png">
  - [FA](https://adapt-python.github.io/adapt/generated/adapt.feature_based.FA.html) (*Frustratingly Easy Domain Adaptation*) [[paper]](https://arxiv.org/pdf/0907.1815.pdf)
  - [SA](https://adapt-python.github.io/adapt/generated/adapt.feature_based.SA.html) (*Subspace Alignment*) [[paper]](https://arxiv.org/abs/1409.5241)
  - [fMMD](https://adapt-python.github.io/adapt/generated/adapt.feature_based.SA.html) (*feature Selection with MMD*) [[paper]](https://www.cs.cmu.edu/afs/cs/Web/People/jgc/publication/Feature%20Selection%20for%20Transfer%20Learning.pdf)
  - [DANN](https://adapt-python.github.io/adapt/generated/adapt.feature_based.DANN.html) (*Discriminative Adversarial Neural Network*) [[paper]](https://jmlr.org/papers/volume17/15-239/15-239.pdf)
  - [ADDA](https://adapt-python.github.io/adapt/generated/adapt.feature_based.ADDA.html) (*Adversarial Discriminative Domain Adaptation*) [[paper]](https://arxiv.org/pdf/1702.05464.pdf)
  - [CORAL](https://adapt-python.github.io/adapt/generated/adapt.feature_based.CORAL.html) (*CORrelation ALignment*) [[paper]](https://arxiv.org/pdf/1511.05547.pdf)
  - [DeepCORAL](https://adapt-python.github.io/adapt/generated/adapt.feature_based.DeepCORAL.html) (*Deep CORrelation ALignment*) [[paper]](https://arxiv.org/pdf/1607.01719.pdf)
  - [MCD](https://adapt-python.github.io/adapt/generated/adapt.feature_based.MCD.html) (*Maximum Classifier Discrepancy*) [[paper]](https://arxiv.org/pdf/1712.02560.pdf)
  - [MDD](https://adapt-python.github.io/adapt/generated/adapt.feature_based.MDD.html) (*Margin Disparity Discrepancy*) [[paper]](https://arxiv.org/pdf/1904.05801.pdf)
  - [WDGRL](https://adapt-python.github.io/adapt/generated/adapt.feature_based.WDGRL.html) (*Wasserstein Distance Guided Representation Learning*) [[paper]](https://arxiv.org/pdf/1707.01217.pdf)
  - [CDAN](https://adapt-python.github.io/adapt/generated/adapt.feature_based.CDAN.html) (*Conditional Adversarial Domain Adaptation*) [[paper]](https://arxiv.org/pdf/1705.10667.pdf)
  - [CCSA](https://adapt-python.github.io/adapt/generated/adapt.feature_based.CCSA.html) (*Classification and Contrastive Semantic Alignment*) [[paper]](https://arxiv.org/abs/1709.10190)

  <img src="https://raw.githubusercontent.com/adapt-python/adapt/a490a5c4cefb80d6222bc831a8cc25b2f65221ce/docs/_static/images/instance_based.png">
  - [LDM](https://adapt-python.github.io/adapt/generated/adapt.instance_based.LDM.html) (*Linear Discrepancy Minimization*) [[paper]](https://arxiv.org/pdf/0902.3430.pdf)
  - [KMM](https://adapt-python.github.io/adapt/generated/adapt.instance_based.KMM.html) (*Kernel Mean Matching*) [[paper]](https://proceedings.neurips.cc/paper/2006/file/a2186aa7c086b46ad4e8bf81e2a3a19b-Paper.pdf)
  - [KLIEP](https://adapt-python.github.io/adapt/generated/adapt.instance_based.KLIEP.html) (*Kullbackâ€“Leibler Importance Estimation Procedure*) [[paper]](https://proceedings.neurips.cc/paper/2007/file/be83ab3ecd0db773eb2dc1b0a17836a1-Paper.pdf)
  - [TrAdaBoost](https://adapt-python.github.io/adapt/generated/adapt.instance_based.TrAdaBoost.html) (*Transfer AdaBoost*) [[paper]](https://cse.hkust.edu.hk/~qyang/Docs/2007/tradaboost.pdf)
  - [TrAdaBoostR2](https://adapt-python.github.io/adapt/generated/adapt.instance_based.TrAdaBoostR2.html) (*Transfer AdaBoost for Regression*) [[paper]](https://www.cs.utexas.edu/~dpardoe/papers/ICML10.pdf)
  - [TwoStageTrAdaBoostR2](https://adapt-python.github.io/adapt/generated/adapt.instance_based.TwoStageTrAdaBoostR2.html) (*Two Stage Transfer AdaBoost for Regression*) [[paper]](https://www.cs.utexas.edu/~dpardoe/papers/ICML10.pdf)
  - [NearestNeighborsWeighting](https://adapt-python.github.io/adapt/generated/adapt.instance_based.NearestNeighborsWeighting.html) (*Nearest Neighbors Weighting*) [[paper]](https://arxiv.org/pdf/2102.02291.pdf)
  - [WANN](https://adapt-python.github.io/adapt/generated/adapt.instance_based.WANN.html) (*Weighting Adversarial Neural Network*) [[paper]](https://arxiv.org/pdf/2006.08251.pdf)

  <img src="https://raw.githubusercontent.com/adapt-python/adapt/a490a5c4cefb80d6222bc831a8cc25b2f65221ce/docs/_static/images/parameter_based.png">
  - [RegularTransferLR](https://adapt-python.github.io/adapt/generated/adapt.parameter_based.RegularTransferLR.html) (*Regular Transfer with Linear Regression*) [[paper]](https://www.microsoft.com/en-us/research/wp-content/uploads/2004/07/2004-chelba-emnlp.pdf)
  - [RegularTransferLC](https://adapt-python.github.io/adapt/generated/adapt.parameter_based.RegularTransferLC.html) (*Regular Transfer with Linear Classification*) [[paper]](https://www.microsoft.com/en-us/research/wp-content/uploads/2004/07/2004-chelba-emnlp.pdf)
  - [RegularTransferNN](https://adapt-python.github.io/adapt/generated/adapt.parameter_based.RegularTransferNN.html) (*Regular Transfer with Neural Network*) [[paper]](https://hal.inria.fr/hal-00911179v1/document)
  - [FineTuning](https://adapt-python.github.io/adapt/generated/adapt.parameter_based.FineTuning.html) (*Fine-Tuning*) [[paper]](https://hal.inria.fr/hal-00911179v1/document)
  - [TransferTreeClassifier](https://adapt-python.github.io/adapt/generated/adapt.parameter_based.TransferTreeClassifier.html) (*Transfer Tree Classifier*) [[paper]](https://ieeexplore.ieee.org/document/8995296)
  - [TransferTreeForest](https://adapt-python.github.io/adapt/generated/adapt.parameter_based.TransferTreeForest.html) (*Transfer Tree Forest*) [[paper]](https://ieeexplore.ieee.org/document/8995296)

  If you use this library in your research, please cite ADAPT using the following reference: https://arxiv.org/pdf/2107.03049.pdf
  ```
  @article{de2021adapt,
  	  title={ADAPT: Awesome Domain Adaptation Python Toolbox},
  	  author={de Mathelin, Antoine and Deheeger, Fran{\c{c}}ois and Richard, Guillaume and Mougeot, Mathilde and Vayatis, Nicolas},
  	  journal={arXiv preprint arXiv:2107.03049},
  	  year={2021}
  	}
  ```

  This work has been funded by Michelin and the Industrial Data Analytics and Machine Learning chair from ENS Paris-Saclay, Borelli center.
  [<img src="https://github.com/adapt-python/adapt/raw/41c13055facc0733faf49c4e3979709e82be10e5/docs/_static/images/michelin.png" width=200px alt="Michelin">](https://www.michelin.com/) [<img src="https://github.com/adapt-python/adapt/raw/41c13055facc0733faf49c4e3979709e82be10e5/docs/_static/images/idaml.jpg" width=200px alt="IDAML">](https://centreborelli.ens-paris-saclay.fr/fr/chaire-idaml) [<img src="https://github.com/adapt-python/adapt/raw/41c13055facc0733faf49c4e3979709e82be10e5/docs/_static/images/borelli.jpg" alt="Centre Borelli" width=150px>](https://centreborelli.ens-paris-saclay.fr/fr)


pkgId: 40caf0c00402db3d1d21290e3b88edecf2cca4cfd04f8217257aeac46096fcfd
name: python-adb
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A pure python implementation of the Android ADB and Fastboot protocols
url: https://github.com/google/python-adb
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-752a97cd-dc9e-4b09-957e-703867bad2c0
location_href: 00002953-python-adb/python-adb-1.3.0-1.src.rpm
checksum_type: sha256
description:
  This repository contains a pure-python implementation of the Android
  ADB and Fastboot protocols, using libusb1 for USB communications.

  This is a complete replacement and rearchitecture of the Android
  project's ADB and fastboot code available at
  https://github.com/android/platform_system_core/tree/master/adb

  This code is mainly targeted to users that need to communicate with
  Android devices in an automated fashion, such as in automated
  testing. It does not have a daemon between the client and the device,
  and therefore does not support multiple simultaneous commands to the
  same device. It does support any number of devices and never
  communicates with a device that it wasn't intended to, unlike the
  Android project's ADB.


pkgId: 8d443ae6a5c4ce3b0e9846151f0ac7bd97117134cbb0352c02dc47898555a012
name: python-adb-shell
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: A Python implementation of ADB with shell and FileSync functionality.
url: https://github.com/JeffLIrion/adb_shell
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b1a0a20e-3522-4cd3-85bf-ee9265b1bbf0
location_href: 00002954-python-adb-shell/python-adb-shell-0.4.3-1.src.rpm
checksum_type: sha256
description:
  Documentation for this package can be found at https://adb-shell.readthedocs.io/.
  Prebuilt wheel can be downloaded from `nightly.link <https://nightly.link/JeffLIrion/adb_shell/workflows/python-package/master/wheel.zip>`_.
  This Python package implements ADB shell and FileSync functionality.  It originated from `python-adb <https://github.com/google/python-adb>`_.


pkgId: 529419373a47946fc4a26e6717df1910ea72e62a6568f74759334fcaf1e28b38
name: python-adext
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: AlarmDecoder extended
url: https://github.com/ajschmidt8/adext
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-38f380f5-1103-47fc-923c-3c74618d590c
location_href: 00002955-python-adext/python-adext-0.4.2-1.src.rpm
checksum_type: sha256
description:
  `adext` is a small package that extends [alarmdecoder](https://github.com/nutechsoftware/alarmdecoder/) to include some additional methods for [Home Assistant](https://github.com/home-assistant/core).

  Specifically, the following methods have been added:

  - `arm_home`
  - `arm_away`
  - `arm_night`

  Each method accepts the arguments described below to determine which key sequences are used to arm a panel based on factors like panel brand and user config settings.



  - **code**: (`None` or `str`) - the code used to arm a panel (i.e. `'1234'`)
  - **auto_bypass**: (`bool`) - for Honeywell only. set to `True` to prefix an arming sequence with `<code> + 6#` in order to automatically bypass any faulted zones. This will require a code to be entered even if `code_arm_required` is set to `false`."
  - **code_arm_required**: (`bool`) - set to `False` to enable arming without a code. see [Arming Key Sequences](#Arming-Key-Sequences) below.
  - **alt_night_mode**: (`bool`) - For Honeywell systems, set to `true` to enable *Night-Stay* mode instead of *Instant* mode for night arming. For DSC systems, set to `true` to enable *No-Entry* mode instead of *Stay* mode for night arming. For both systems, whenever this option is set to `true`, a code will be required for night arming **regardless of the `code_arm_required` setting.** See [Arming Key Sequences](#Arming-Key-Sequences) section below for more information.




  The tables below show the key press sequences used for arming for the different panel brands and configuration setting combinations.





  | Mode                                                    | Key Sequence                |
  | ------------------------------------------------------- | --------------------------- |
  | `alarm_arm_home`                                        | `code` + `3`                |
  | `alarm_arm_away`                                        | `code` + `2`                |
  | `alarm_arm_night` (`alt_night_mode` = `false`, default) | `code` + `7`                |
  | `alarm_arm_night` (`alt_night_mode` = `true`)           | `code` + `33`               |



  | Mode                                                    | Key Sequence                |
  | ------------------------------------------------------- | --------------------------- |
  | `alarm_arm_home`                                        | `#3`                        |
  | `alarm_arm_away`                                        | `#2`                        |
  | `alarm_arm_night` (`alt_night_mode` = `false`, default) | `#7`                        |
  | `alarm_arm_night` (`alt_night_mode` = `true`)           | `code` + `33`               |





  | Mode                                                    | Key Sequence                |
  | ------------------------------------------------------- | --------------------------- |
  | `alarm_arm_home`                                        | `code`                      |
  | `alarm_arm_away`                                        | `code`                      |
  | `alarm_arm_night` (`alt_night_mode` = `false`, default) | `code`                      |
  | `alarm_arm_night` (`alt_night_mode` = `true`)           | `*9` + `code`               |



  <div class='note'>

  The `chr(4)` and `chr(5)` sequences below are equivalent to pressing the <em>Stay</em> and <em>Away</em> keypad keys respectively (as outlined in the <a href='http://www.alarmdecoder.com/wiki/index.php/Protocol#Special_Keys'>AlarmDecoder documentation</a>).

  </div>

  | Mode                                                    | Key Sequence                    |
  | ------------------------------------------------------- | ------------------------------- |
  | `alarm_arm_home`                                        | `chr(4)` + `chr(4)` + `chr(4)`  |
  | `alarm_arm_away`                                        | `chr(5)` + `chr(5)` + `chr(5)`  |
  | `alarm_arm_night` (`alt_night_mode` = `false`, default) | `chr(4)` + `chr(4)` + `chr(4)`  |
  | `alarm_arm_night` (`alt_night_mode` = `true`)           | `*9` + `code`                   |


pkgId: f83b8747086ecd92ed47e4d76d4c7035bb79c4adcab759ce4cd8af88eb9a24d3
name: python-admesh
arch: src
version: 0.98.9
epoch: 0
release: 1
summary: Python bindings for ADMesh, STL maipulation library
url: https://github.com/admesh/python-admesh
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22b5a1cf-a3e0-4e77-b203-7070a19a0f3c
location_href: 00002956-python-admesh/python-admesh-0.98.9-1.src.rpm
checksum_type: sha256
description:
  This module provides bindings for the `ADMesh <https://github.com/admesh/admesh>`_ library. It lets you manipulate 3D models in binary or ASCII STL format and partially repair them if necessary.


pkgId: 6c766ee3276dcbffed1906bc8bd83592471a7e2b412615a1a9e440b4a4d4aa32
name: python-advisory-parser
arch: src
version: 1.12
epoch: 0
release: 1
summary: Security flaw parser for upstream security advisories
url: https://github.com/RedHatProductSecurity/advisory-parser
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-16f19212-ed03-4476-8ea2-1e4214a7e085
location_href: 00002957-python-advisory-parser/python-advisory-parser-1.12-1.src.rpm
checksum_type: sha256
description:
  This library allows you to parse data from security advisories of certain
  projects to extract information about security issues. The parsed
  information includes metadata such as impact, CVSS score, summary,
  description, and others; for a full list, see the
  ``advisory_parser/flaw.py`` file.
  **DISCLAIMER**: Much of the advisory parsing is fairly fragile. Because web
  pages change all the time, it is not uncommon for parsers to break when a
  page is changed in some way. Also, the advisory parsers only work with the
  latest version of the advisory pages.
  The need for parsing raw security advisories in this way could be avoided
  if vendors provided their security pages in a machine readable (and
  preferably standardized) format. An example of this would be Red Hat's
  security advisories that can be pulled in from a separate Security Data API
  (`RHSA-2016:1883.json <https://access.redhat.com/labs/securitydataapi/cvrf/RHSA-2016:1883.json>`_)
  or downloaded as an XML file
  (`cvrf-rhsa-2016-1883.xml <https://www.redhat.com/security/data/cvrf/2016/cvrf-rhsa-2016-1883.xml>`_),
  or OpenSSL's list of issues available in XML
  (`vulnerabilities.xml <https://www.openssl.org/news/vulnerabilities.xml>`_).
  If you are a vendor or an upstream project owner interested in providing
  your security advisories in a machine readable format and don't know where
  to start, feel free to reach out to mprpic@redhat.com.
  Currently available parsers include:
      "Google Chrome", `<https://chromereleases.googleblog.com/2017/06/stable-channel-update-for-desktop_15.html>`_
      "Adobe Flash", `<https://helpx.adobe.com/security/products/flash-player/apsb17-17.html>`_
      "Jenkins", ""
      "MySQL", `<http://www.oracle.com/technetwork/security-advisory/cpujul2017verbose-3236625.html>`_
      "phpMyAdmin", ""
      "Wireshark", ""


pkgId: 086f38d90ba0dd65becd0861265a987f729db861b4461e90bfefc446ea2a3380
name: python-aenum
arch: src
version: 3.1.11
epoch: 0
release: 1
summary: Advanced Enumerations (compatible with Python's stdlib Enum), NamedTuples, and NamedConstants
url: https://github.com/ethanfurman/aenum
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2334e718-3844-428f-b72a-04ff100396f2
location_href: 00002958-python-aenum/python-aenum-3.1.11-1.src.rpm
checksum_type: sha256
description:
  Advanced Enumerations (compatible with Python's stdlib Enum), NamedTuples, and NamedConstants

  WARNING: Version 3.1 has breaking changes in custom Enum settings
  WARNING:
  WARNING: AutoNumber has been removed
  WARNING: AutoValue has been removed

  aenum includes a Python stdlib Enum-compatible data type, as well as a metaclass-based NamedTuple implementation and a NamedConstant class.

  An Enum is a set of symbolic names (members) bound to unique, constant values. Within an enumeration, the members can be compared by identity, and the enumeration itself can be iterated over.  Support exists for unique values, multiple values, auto-numbering, and suspension of aliasing (members with the same value are not identical), plus the ability to have values automatically bound to attributes.

  A NamedTuple is a class-based, fixed-length tuple with a name for each possible position accessible using attribute-access notation as well as the standard index notation.

  A NamedConstant is a class whose members cannot be rebound; it lacks all other Enum capabilities, however.

  Enum classes:

  - Enum: Base class for creating enumerated constants.

  - IntEnum: Base class for creating enumerated constants that are also
             subclasses of int.

  - Flag: Base class for creating enumerated constants that can be combined
          using the bitwise operations without losing their Flag membership.

  - IntFlag: Base class for creating enumerated constants that can be combined
             using the bitwise operators without losing their IntFlag membership.
             IntFlag members are also subclasses of int.

  - AutoNumberEnum: Derived class that automatically assigns an int value to each
                    member.

  - OrderedEnum: Derived class that adds <, <=, >=, and > methods to an Enum.

  - UniqueEnum: Derived class that ensures only one name is bound to any one
                value.

  Utility functions include:

  - convert: helper to convert target global variables into an Enum

  - constant: helper class for creating constant members

  - enum: helper class for creating members with keywords

  - enum_property: property to enable enum members to have same named attributes
                   (e.g. `name` and `value`)

  - export: helper to insert Enum members into a namespace (usually globals())

  - extend_enum: add new members to enumerations after creation

  - module: inserts NamedConstant and Enum classes into sys.modules
            where it will appear to be a module whose top-level names
            cannot be rebound

  - skip: class that prevents attributes from being converted to a
          constant or enum member

  - unique: decorator that ensures no duplicate members


pkgId: ad78328f6ea8d4542527bc5f230b9b53681149bd968dc5775ff3dc1698fb41e7
name: python-affinegap-debuginfo
arch: aarch64
version: 1.12
epoch: 0
release: 1
summary: Debug information for package python-affinegap
url: https://github.com/datamade/affinegap
rpm_license: The MIT License: http://www.opensource.org/licenses/mit-license.php
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-6734d2af-74a3-4ce9-94ce-fdac24c6c1b5
rpm_sourcerpm: python-affinegap-1.12-1.src.rpm
location_href: 00010989-python-affinegap/python-affinegap-debuginfo-1.12-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-affinegap.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 9a33662efc14b4c36c9bc9ce586a483ec9991d00a41f8804690fbef0535db5c6
name: python-affinegap-debugsource
arch: aarch64
version: 1.12
epoch: 0
release: 1
summary: Debug sources for package python-affinegap
url: https://github.com/datamade/affinegap
rpm_license: The MIT License: http://www.opensource.org/licenses/mit-license.php
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-6734d2af-74a3-4ce9-94ce-fdac24c6c1b5
rpm_sourcerpm: python-affinegap-1.12-1.src.rpm
location_href: 00010989-python-affinegap/python-affinegap-debugsource-1.12-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-affinegap.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 2341e3fc99089b6bd4bdc1568104346fb4bbae61000b20bc8624551ed09c5193
name: python-afsapi
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: Asynchronous Implementation of the Frontier Silicon API
url: https://github.com/zhelev/python-afsapi.git
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9ebe7cb3-0f95-43ef-8803-dbfaec9749f9
location_href: 00002960-python-afsapi/python-afsapi-0.2.8-1.src.rpm
checksum_type: sha256
description:
  ```python
  import asyncio
  from afsapi import AFSAPI
  URL = 'http://192.168.1.XYZ:80/device'
  PIN = 1234
  TIMEOUT = 1 # in seconds
  async def test():
      afsapi = await AFSAPI.create(URL, PIN, TIMEOUT)
      print(f'Set power succeeded? - {await afsapi.set_power(True)}' )
      print(f'Power on: {await afsapi.get_power()}')
      print(f'Friendly name: {await afsapi.get_friendly_name()}')
      for mode in await afsapi.get_modes():
          print(f'Available Mode: {mode}')
      print(f'Current Mode: {await afsapi.get_mode()}')
      for equaliser in await afsapi.get_equalisers():
          print(f'Equaliser: {equaliser}')
      print(f'EQ Preset: {await afsapi.get_eq_preset()}' )
      for preset in await afsapi.get_presets():
          print(f"Preset: {preset}")
      print(f'Set power succeeded? - {await afsapi.set_power(False)}')
      print(f'Set sleep succeeded? - {await afsapi.set_sleep(10)}')
      print(f'Sleep: {await afsapi.get_sleep()}')
      print(f'Get power {await afsapi.get_power()}' )
  loop = asyncio.new_event_loop()
  loop.run_until_complete(test())
  ```


pkgId: 70a6976a80a2ae7fd8e92cc6e79766024a6b8a46f3e7b843c1187ab28f1faf0b
name: python-agate
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: A data analysis library that is optimized for humans instead of machines.
url: http://agate.readthedocs.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df22f900-7f2a-4b9e-ba80-deabe1025215
location_href: 00002961-python-agate/python-agate-1.7.1-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://github.com/wireservice/agate/workflows/CI/badge.svg
      :target: https://github.com/wireservice/agate/actions
      :alt: Build status

  .. image:: https://img.shields.io/pypi/dm/agate.svg
      :target: https://pypi.python.org/pypi/agate
      :alt: PyPI downloads

  .. image:: https://img.shields.io/pypi/v/agate.svg
      :target: https://pypi.python.org/pypi/agate
      :alt: Version

  .. image:: https://img.shields.io/pypi/l/agate.svg
      :target: https://pypi.python.org/pypi/agate
      :alt: License

  .. image:: https://img.shields.io/pypi/pyversions/agate.svg
      :target: https://pypi.python.org/pypi/agate
      :alt: Support Python versions

  agate is a Python data analysis library that is optimized for humans instead of machines. It is an alternative to numpy and pandas that solves real-world problems with readable code.

  agate was previously known as journalism.

  Important links:

  * Documentation:    http://agate.rtfd.org
  * Repository:       https://github.com/wireservice/agate
  * Issues:           https://github.com/wireservice/agate/issues


pkgId: 911bf456eeec9ad2d8cacdbca35f6f9084c55e6269af48838349e6f74e273e0b
name: python-agate-dbf
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: agate-dbf adds read support for dbf files to agate.
url: http://agate-dbf.readthedocs.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f48d5050-8a81-40ca-8507-7c0421adfae0
location_href: 00002962-python-agate-dbf/python-agate-dbf-0.2.2-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://travis-ci.org/wireservice/agate-dbf.png
      :target: https://travis-ci.org/wireservice/agate-dbf
      :alt: Build status

  .. image:: https://img.shields.io/pypi/dw/agate-dbf.svg
      :target: https://pypi.python.org/pypi/agate-dbf
      :alt: PyPI downloads

  .. image:: https://img.shields.io/pypi/v/agate-dbf.svg
      :target: https://pypi.python.org/pypi/agate-dbf
      :alt: Version

  .. image:: https://img.shields.io/pypi/l/agate-dbf.svg
      :target: https://pypi.python.org/pypi/agate-dbf
      :alt: License

  .. image:: https://img.shields.io/pypi/pyversions/agate-dbf.svg
      :target: https://pypi.python.org/pypi/agate-dbf
      :alt: Support Python versions

  agate-dbf adds read support for dbf files to `agate <https://github.com/wireservice/agate>`_.

  Important links:

  * agate             http://agate.rtfd.org
  * Documentation:    http://agate-dbf.rtfd.org
  * Repository:       https://github.com/wireservice/agate-dbf
  * Issues:           https://github.com/wireservice/agate-dbf/issues


pkgId: fa17d9baa05ac0b5a79993ba57d619a759103d402a7078375f33c7f97426b954
name: python-agate-excel
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: agate-excel adds read support for Excel files (xls and xlsx) to agate.
url: http://agate-excel.readthedocs.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-08f4b03e-fe84-4941-830c-51f07d912489
location_href: 00002963-python-agate-excel/python-agate-excel-0.2.5-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://github.com/wireservice/agate-excel/workflows/CI/badge.svg
      :target: https://github.com/wireservice/agate-excel/actions
      :alt: Build status

  .. image:: https://img.shields.io/pypi/dm/agate-excel.svg
      :target: https://pypi.python.org/pypi/agate-excel
      :alt: PyPI downloads

  .. image:: https://img.shields.io/pypi/v/agate-excel.svg
      :target: https://pypi.python.org/pypi/agate-excel
      :alt: Version

  .. image:: https://img.shields.io/pypi/l/agate-excel.svg
      :target: https://pypi.python.org/pypi/agate-excel
      :alt: License

  .. image:: https://img.shields.io/pypi/pyversions/agate-excel.svg
      :target: https://pypi.python.org/pypi/agate-excel
      :alt: Support Python versions

  agate-excel adds read support for Excel files (xls and xlsx) to `agate <https://github.com/wireservice/agate>`_.

  Important links:

  * agate             http://agate.rtfd.org
  * Documentation:    http://agate-excel.rtfd.org
  * Repository:       https://github.com/wireservice/agate-excel
  * Issues:           https://github.com/wireservice/agate-excel/issues


pkgId: 1f37299e56b0802a91d280c6f859964d1c1bcfc806eef1503ac45c5bb81fc84f
name: python-agate-sql
arch: src
version: 0.5.9
epoch: 0
release: 1
summary: agate-sql adds SQL read/write support to agate.
url: http://agate-sql.readthedocs.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3db6903-9046-4fde-ac0f-4a13e424cf9b
location_href: 00002964-python-agate-sql/python-agate-sql-0.5.9-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://github.com/wireservice/agate-sql/workflows/CI/badge.svg
      :target: https://github.com/wireservice/agate-sql/actions
      :alt: Build status

  .. image:: https://img.shields.io/pypi/dm/agate-sql.svg
      :target: https://pypi.python.org/pypi/agate-sql
      :alt: PyPI downloads

  .. image:: https://img.shields.io/pypi/v/agate-sql.svg
      :target: https://pypi.python.org/pypi/agate-sql
      :alt: Version

  .. image:: https://img.shields.io/pypi/l/agate-sql.svg
      :target: https://pypi.python.org/pypi/agate-sql
      :alt: License

  .. image:: https://img.shields.io/pypi/pyversions/agate-sql.svg
      :target: https://pypi.python.org/pypi/agate-sql
      :alt: Support Python versions

  agate-sql adds SQL read/write support to `agate <https://github.com/wireservice/agate>`_.

  Important links:

  * agate             http://agate.rtfd.org
  * Documentation:    http://agate-sql.rtfd.org
  * Repository:       https://github.com/wireservice/agate-sql
  * Issues:           https://github.com/wireservice/agate-sql/issues


pkgId: 4cf1a1810d1ee8482cf6143a7a9b5bfd81258e9090b3096ee1d53c4fcee22ce9
name: python-ahocorapy
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: ahocorapy - Pure python ahocorasick implementation
url: https://github.com/abusix/ahocorapy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94c7f6f3-3f3e-40d5-8456-c56bbc540b0d
location_href: 00010437-python-ahocorapy/python-ahocorapy-1.6.2-1.src.rpm
checksum_type: sha256
description:
  [![Test](https://img.shields.io/github/workflow/status/abusix/ahocorapy/test/master)](https://github.com/abusix/ahocorapy/actions)
  [![Test Coverage](https://img.shields.io/codecov/c/gh/abusix/ahocorapy/master)](https://codecov.io/gh/abusix/ahocorapy)
  [![Downloads](https://pepy.tech/badge/ahocorapy)](https://pepy.tech/project/ahocorapy)
  [![PyPi Version](https://img.shields.io/pypi/v/ahocorapy.svg)](https://pypi.python.org/pypi/ahocorapy)
  [![PyPi License](https://img.shields.io/pypi/l/ahocorapy.svg)](https://pypi.python.org/pypi/ahocorapy)
  [![PyPi Versions](https://img.shields.io/pypi/pyversions/ahocorapy.svg)](https://pypi.python.org/pypi/ahocorapy)
  [![PyPi Wheel](https://img.shields.io/pypi/wheel/ahocorapy.svg)](https://pypi.python.org/pypi/ahocorapy)



  ahocorapy is a pure python implementation of the Aho-Corasick Algorithm.
  Given a list of keywords one can check if at least one of the keywords exist in a given text in linear time.





  We started working on this in the beginning of 2016. Our requirements included unicode support combined with python2.7. That
  was impossible with C-extension based libraries (like [pyahocorasick](https://github.com/WojciechMula/pyahocorasick/)). Pure
  python libraries were very slow or unusable due to memory explosion. Since then another pure python library was released
  [py-aho-corasick](https://github.com/JanFan/py-aho-corasick). The repository also contains some discussion about different
  implementations.
  There is also [acora](https://github.com/scoder/acora), but it includes the note ('current construction algorithm is not
  suitable for really large sets of keywords') which really was the case the last time I tested, because RAM ran out quickly.



  - Compared to [pyahocorasick](https://github.com/WojciechMula/pyahocorasick/) our library supports unicode in python 2.7 just like [py-aho-corasick](https://github.com/JanFan/py-aho-corasick).
    We don't use any C-Extension so the library is not platform dependant.

  - On top of the standard Aho-Corasick longest suffix search, we also perform a shortcutting routine in the end, so
    that our lookup is fast while, the setup takes longer. During set up we go through the states and directly add transitions that are
    "offered" by the longest suffix or their longest suffixes. This leads to faster lookup times, because in the end we only have to
    follow simple transitions and don't have to perform any additional suffix lookup. It also leads to a bigger memory footprint,
    because the number of transitions is higher, because they are all included explicitely and not implicitely hidden by suffix pointers.

  - We added a small tool that helps you visualize the resulting graph. This may help understanding the algorithm, if you'd like. See below.

  - Fully pickleable (pythons built-in de-/serialization). ahocorapy uses a non-recursive custom implementation for de-/serialization so that even huge keyword trees can be pickled.



  I compared the two libraries mentioned above with ahocorapy. We used 50,000 keywords long list and an input text of 34,199 characters.
  In the text only one keyword of the list is contained.
  The setup process was run once per library and the search process was run 100 times. The following results are in seconds (not averaged for the lookup).

  You can perform this test yourself using `python tests/ahocorapy_performance_test.py`. (Except for the pyahocorasick_py results. These were taken by importing the
  pure python version of the code of [pyahocorasick](https://github.com/WojciechMula/pyahocorasick/). It's not available through pypi
  as stated in the code.)

  I also added measurements for the pure python libraries with run with pypy.

  These are the results:

  | Library (Variant)                                      | Setup (1x) | Search (100x) |
  | ------------------------------------------------------ | ---------- | ------------- |
  | ahocorapy\*                                            | 0.30s      | 0.29s         |
  | ahocorapy (run with pypy)\*                            | 0.37s      | 0.10s         |
  | pyahocorasick\*                                        | 0.04s      | 0.04s         |
  | pyahocorasick (run with pypy)\*                        | 0.10s      | 0.05s         |
  | pyahocorasick (pure python variant in github repo)\*\* | 0.50s      | 1.68s         |
  | py_aho_corasick\*                                      | 0.72s      | 4,60s         |
  | py_aho_corasick (run with pypy)\*                      | 0.83s      | 2.02s         |

  As expected the C-Extension shatters the pure python implementations. Even though there is probably still room for optimization in
  ahocorapy we are not going to get to the mark that pyahocorasick sets. ahocorapy's lookups are faster than py_aho_corasick.
  When run with pypy ahocorapy is almost as fast as pyahocorasick, at least when it comes to
  searching. The setup overhead is higher due to the suffix shortcutting mechanism used.

  \* Specs

  CPU: AMD Ryzen 2700X
  Linux Kernel: 6.0.6
  CPython: 3.11.0
  pypy: PyPy 7.3.9 (Python 3.9.12) with GCC 10.2.1 20210130
  Date tested: 2022-11-22

  \*\* Old measurement with different specs





  ```
  pip install ahocorapy
  ```



  ```python
  from ahocorapy.keywordtree import KeywordTree
  kwtree = KeywordTree(case_insensitive=True)
  kwtree.add('malaga')
  kwtree.add('lacrosse')
  kwtree.add('mallorca')
  kwtree.add('mallorca bella')
  kwtree.add('orca')
  kwtree.finalize()
  ```



  ```python
  result = kwtree.search('My favorite islands are malaga and sylt.')
  print(result)
  ```

  Prints :

  ```python
  ('malaga', 24)
  ```

  The search_all method returns a generator for all keywords found, or None if there is none.

  ```python
  results = kwtree.search_all('malheur on mallorca bellacrosse')
  for result in results:
      print(result)
  ```

  Prints :

  ```python
  ('mallorca', 11)
  ('orca', 15)
  ('mallorca bella', 11)
  ('lacrosse', 23)
  ```



  The construction of the tree is currently NOT thread safe. That means `add`ing shouldn't be called multiple times concurrently. Behavior is undefined.

  After `finalize` is called you can use the `search` functionality on the same tree from multiple threads at the same time. So that part is thread safe.



  You can print the underlying graph with the Visualizer class.
  This feature requires a working pygraphviz library installed.

  ```python
  from ahocorapy_visualizer.visualizer import Visualizer
  visualizer = Visualizer()
  visualizer.draw('readme_example.png', kwtree)
  ```

  The resulting .png of the graph looks like this:

  ![graph for kwtree](https://raw.githubusercontent.com/abusix/ahocorapy/master/img/readme_example.png "Keyword Tree")


pkgId: 8cdd89897ea77923c719d12df22e80a656bfdfd28b4ee29351eac10c6ee53811
name: python-ailment
arch: src
version: 9.2.40
epoch: 0
release: 1
summary: The angr intermediate language.
url: https://github.com/angr/ailment
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ee892ca9-7fc7-4171-b018-8b31b999aa3d
location_href: 00002965-python-ailment/python-ailment-9.2.40-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  AIL is the angr intermediate language.


pkgId: b630c0e75dd42ae08d02b761b6a8329692ee3db3ec6f1e1c63f67499e0b9dd9d
name: python-aioasuswrt
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Api wrapper for Asuswrt https://www.asus.com/ASUSWRT/
url: https://github.com/kennedyshead/aioasuswrt
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b9eab82f-2e99-4618-bcff-2a5705e9632f
location_href: 00002966-python-aioasuswrt/python-aioasuswrt-1.4.0-1.src.rpm
checksum_type: sha256
description:
  Small wrapper for asuswrt. ![Python package](https://github.com/kennedyshead/aioasuswrt/workflows/Python%20package/badge.svg)



  `python setup.py test`


  [@mvn23](https://github.com/mvn23)
  [@halkeye](https://github.com/halkeye)
  [@maweki](https://github.com/maweki)
  [@quarcko](https://github.com/quarcko)
  [@wdullaer](https://github.com/wdullaer)


  There are many different versions of asuswrt and sometimes they just dont work in current implementation.
  If you have a problem with your specific router open an issue, but please add as much info as you can and atleast:

  * Version of router
  * Version of Asuswrt




  You can always create an issue in this tracker.
  To test and give us the information needed you could run:
  ```python

  import asyncio
  import logging

  import sys

  from aioasuswrt.asuswrt import AsusWrt

  component = AsusWrt('192.168.1.1', 22, username='****', password='****')
  logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
  logger = logging.getLogger(__name__)


  async def print_data():
      logger.debug("wl")
      logger.debug(await component.connection.async_run_command('for dev in `nvram get wl_ifnames`; do wl -i $dev assoclist; done'))
      dev = await component.async_get_wl()
      logger.debug(dev)
      logger.debug("arp")
      logger.debug(await component.connection.async_run_command('arp -n'))
      dev.update(await component.async_get_arp())
      logger.debug(dev)
      logger.debug("neigh")
      logger.debug(await component.connection.async_run_command('ip neigh'))
      dev.update(await component.async_get_neigh(dev))
      logger.debug(dev)
      logger.debug("leases")
      logger.debug(await component.connection.async_run_command('cat /var/lib/misc/dnsmasq.leases'))
      dev.update(await component.async_get_leases(dev))
      logger.debug(dev)


  loop = asyncio.get_event_loop()

  loop.run_until_complete(print_data())
  loop.close()

  ```
  Coffeefund: 1Huz6vNN6drX3Fq1sU98wPqNSdMPvkMBJG


pkgId: 386b152771ae1ef484d18ac8d44194a2a26a1eab651ad5f10a0300bbc6c8f2ce
name: python-aiobotocore
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Async client for aws services using botocore and aiohttp
url: https://github.com/aio-libs/aiobotocore
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b1eaaba7-4e6e-46d2-8bbc-dac2d139853e
location_href: 00009006-python-aiobotocore/python-aiobotocore-2.5.0-1.src.rpm
checksum_type: sha256
description:
  Async client for amazon services using botocore_ and aiohttp_/asyncio_.
  This library is a mostly full featured asynchronous version of botocore.


pkgId: e4f599dd9e6bb3653073382096d8661170d283a18830f0b6be6f20da4afde594
name: python-aioconsole
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Asynchronous console and interfaces for asyncio
url: https://github.com/vxgmichel/aioconsole
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0e13e8b2-4979-46fe-afff-cd6136b8244e
location_href: 00009581-python-aioconsole/python-aioconsole-0.6.1-1.src.rpm
checksum_type: sha256
description:
  Asynchronous console and interfaces for asyncio
  aioconsole_ provides:
  * asynchronous equivalents to `input`_, `print`_, `exec`_ and `code.interact`_
  * an interactive loop running the asynchronous python console
  * a way to customize and run command line interface using `argparse`_
  * `stream`_ support to serve interfaces instead of using standard streams
  * the ``apython`` script to access asyncio code at runtime without modifying the sources


pkgId: caafc5388c00c5741225137640d5a0d89550aa61159b275f569c57d81cec5562
name: python-aiodiscover
arch: src
version: 1.4.16
epoch: 0
release: 1
summary: Discover hosts by arp and ptr lookup
url: https://github.com/bdraco/aiodiscover
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f8ad4f1-754c-4c2d-aaae-50bf6a2a33d8
location_href: 00013031-python-aiodiscover/python-aiodiscover-1.4.16-1.src.rpm
checksum_type: sha256
description:
  -   Discover hosts on the network via ARP and PTR lookup

  ```python
  import asyncio
  import pprint
  from aiodiscover import DiscoverHosts
  discover_hosts = DiscoverHosts()
  hosts = asyncio.run(discover_hosts.async_discover())
  pprint.pprint(hosts)
  ```

  **Stable Release:** `pip install aiodiscover`<br>
  **Development Head:** `pip install git+https://github.com/bdraco/aiodiscover.git`

  For full package documentation please visit [bdraco.github.io/aiodiscover](https://bdraco.github.io/aiodiscover).

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.

  1. `pip install -e .[dev]`
      This will install your package in editable mode with all the required development
      dependencies (i.e. `tox`).
  2. `make build`
      This will run `tox` which will run all your tests in both Python 3.7
      and Python 3.8 as well as linting your code.
  3. `make clean`
      This will clean up various Python and build generated files so that you can ensure
      that you are working in a clean environment.
  4. `make docs`
      This will generate and launch a web browser to view the most up-to-date
      documentation for your Python package.

  -   Turn your project into a GitHub repository:
      -   Make an account on [github.com](https://github.com)
      -   Go to [make a new repository](https://github.com/new)
      -   _Recommendations:_
          -   _It is strongly recommended to make the repository name the same as the Python
              package name_
          -   _A lot of the following optional steps are *free* if the repository is Public,
              plus open source is cool_
      -   After a GitHub repo has been created, run the commands listed under:
          "...or push an existing repository from the command line"
  -   Register your project with Codecov:
      -   Make an account on [codecov.io](https://codecov.io)(Recommended to sign in with GitHub)
          everything else will be handled for you.
  -   Ensure that you have set GitHub pages to build the `gh-pages` branch by selecting the
      `gh-pages` branch in the dropdown in the "GitHub Pages" section of the repository settings.
      ([Repo Settings](https://github.com/bdraco/aiodiscover/settings))
  -   Register your project with PyPI:
      -   Make an account on [pypi.org](https://pypi.org)
      -   Go to your GitHub repository's settings and under the
          [Secrets tab](https://github.com/bdraco/aiodiscover/settings/secrets/actions),
          add a secret called `PYPI_TOKEN` with your password for your PyPI account.
          Don't worry, no one will see this password because it will be encrypted.
      -   Next time you push to the branch `main` after using `bump2version`, GitHub
          actions will build and deploy your Python package to PyPI.

  1. `main` is for the most up-to-date development, very rarely should you directly
     commit to this branch. GitHub Actions will run on every push and on a CRON to this
     branch but still recommended to commit to your development branches and make pull
     requests to main. If you push a tagged commit with bumpversion, this will also release to PyPI.
  2. Your day-to-day work should exist on branches separate from `main`. Even if it is
     just yourself working on the repository, make a PR from your working branch to `main`
     so that you can ensure your commits don't break the development head. GitHub Actions
     will run on every push to any branch or any pull request from any branch to any other
     branch.
  3. It is recommended to use "Squash and Merge" commits when committing PR's. It makes
     each set of changes to `main` atomic and as a side effect naturally encourages small
     well defined PR's.
  **Apache Software License 2.0**


pkgId: de120349410dc4561ac9ef75221a086bbc77c927874188ffd2adc9adbafd92d1
name: python-aioesphomeapi
arch: src
version: 13.5.0
epoch: 0
release: 1
summary: Python API for interacting with ESPHome devices.
url: https://esphome.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a3b68801-6682-4772-bdb5-fcb96253a38b
location_href: 00002971-python-aioesphomeapi/python-aioesphomeapi-13.5.0-1.src.rpm
checksum_type: sha256
description:
  ``aioesphomeapi`` allows you to interact with devices flashed with `ESPHome <https://esphome.io/>`_.


pkgId: 5fdebf0e681510d847a5b1b1e9912f8029be532b23c9dfa28290ed8b51758bf3
name: python-aioextensions
arch: src
version: 21.7.2261349
epoch: 0
release: 1
summary: High performance functions to work with the async IO
url: https://fluidattacks.github.io/aioextensions
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22d738f7-0bb8-4846-ac34-d933bf15b898
location_href: 00011200-python-aioextensions/python-aioextensions-21.7.2261349-1.src.rpm
checksum_type: sha256
description:
  [![Release](
  https://img.shields.io/pypi/v/aioextensions?color=success&label=Release&style=flat-square)](
  https://pypi.org/project/aioextensions)
  [![Documentation](
  https://img.shields.io/badge/Documentation-click_here!-success?style=flat-square)](
  https://fluidattacks.github.io/aioextensions/)
  [![Downloads](
  https://img.shields.io/pypi/dm/aioextensions?label=Downloads&style=flat-square)](
  https://pypi.org/project/aioextensions)
  [![Status](
  https://img.shields.io/pypi/status/aioextensions?label=Status&style=flat-square)](
  https://pypi.org/project/aioextensions)
  [![Coverage](
  https://img.shields.io/badge/Coverage-100%25-success?style=flat-square)](
  https://fluidattacks.github.io/aioextensions/)
  [![License](
  https://img.shields.io/pypi/l/aioextensions?color=success&label=License&style=flat-square)](
  https://github.com/fluidattacks/aioextensions/blob/latest/LICENSE.md)


pkgId: 06530bbdf2ee91321ca916a680fc861d898f670d1db7d5aae7536a0a10edd2be
name: python-aiofiles
arch: src
version: 23.1.0
epoch: 0
release: 1
summary: File support for asyncio.
url: https://github.com/Tinche/aiofiles
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-43a96bb3-513d-467b-87fb-ce159a1977b3
location_href: 00002972-python-aiofiles/python-aiofiles-23.1.0-1.src.rpm
checksum_type: sha256
description:
  **aiofiles** is an Apache2 licensed library, written in Python, for handling local
  disk files in asyncio applications.
  Ordinary local file IO is blocking, and cannot easily and portably made
  asynchronous. This means doing file IO may interfere with asyncio applications,
  which shouldn't block the executing thread. aiofiles helps with this by
  introducing asynchronous versions of files that support delegating operations to
  a separate thread pool.
      async with aiofiles.open('filename', mode='r') as f:
          contents = await f.read()
      print(contents)
      'My file contents'
  Asynchronous iteration is also supported.
      async with aiofiles.open('filename') as f:
          async for line in f:
  Asynchronous interface to tempfile module.
      async with aiofiles.tempfile.TemporaryFile('wb') as f:
          await f.write(b'Hello, World!')


pkgId: 0de37a143e1b55f8a1f3f146b0fef01212dcf497520895a1f961af5108360cc3
name: python-aioflo
arch: src
version: 2021.11.0
epoch: 0
release: 1
summary: A Python3, async-friendly library for Flo by Moen Smart Water Detectors
url: https://github.com/bachya/aioflo
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-33d618a9-9082-4044-b89d-89b0920b1eef
location_href: 00002973-python-aioflo/python-aioflo-2021.11.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bachya/aioflo/workflows/CI/badge.svg)](https://github.com/bachya/aioflo/actions)
  [![PyPi](https://img.shields.io/pypi/v/aioflo.svg)](https://pypi.python.org/pypi/aioflo)
  [![Version](https://img.shields.io/pypi/pyversions/aioflo.svg)](https://pypi.python.org/pypi/aioflo)
  [![License](https://img.shields.io/pypi/l/aioflo.svg)](https://github.com/bachya/aioflo/blob/master/LICENSE)
  [![Code Coverage](https://codecov.io/gh/bachya/aioflo/branch/master/graph/badge.svg)](https://codecov.io/gh/bachya/aioflo)
  [![Maintainability](https://api.codeclimate.com/v1/badges/1b6949e0c97708925315/maintainability)](https://codeclimate.com/github/bachya/aioflo/maintainability)
  [![Say Thanks](https://img.shields.io/badge/SayThanks-!-1EAEDB.svg)](https://saythanks.io/to/bachya)

  `aioflo` is a Python 3, `asyncio`-friendly library for interacting with
  [Flo by Moen Smart Water Detectors](https://www.moen.com/flo).



  `aioflo` is currently supported on:

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



  ```python
  pip install aioflo
  ```



  ```python
  import asyncio

  from aiohttp import ClientSession

  from aioflo import async_get_api


  async def main() -> None:
      """Run!"""
      api = await async_get_api("<EMAIL>", "<PASSWORD>")

      
      user_info = await api.user.get_info()
      a_location_id = user_info["locations"][0]["id"]

      
      location_info = await api.location.get_info(a_location_id)

      
      first_device_id = location_info["devices"][0]["id"]
      device_info = await api.device.get_info(first_device_id)

      
      health_test_response = await api.device.run_health_test(first_device_id)

      
      close_valve_response = await api.device.close_valve(first_device_id)

      
      open_valve_response = await api.device.open_valve(first_device_id)

      
      consumption_info = await api.water.get_consumption_info(
          a_location_id,
          datetime(2020, 1, 16, 0, 0),
          datetime(2020, 1, 16, 23, 59, 59, 999000),
      )

      
      metrics = await api.water.get_metrics(
          "<DEVICE_MAC_ADDRESS>",
          datetime(2020, 1, 16, 0, 0),
          datetime(2020, 1, 16, 23, 59, 59, 999000),
      )

      
      await set_mode_away(a_location_id)

      
      await set_mode_home(a_location_id)

      
      await set_mode_sleep(a_location_id, 120, "away")


  asyncio.run(main())
  ```

  By default, the library creates a new connection to Flo 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 aioflo import async_get_api


  async def main() -> None:
      """Create the aiohttp session and run the example."""
      async with ClientSession() as websession:
          api = await async_get_api("<EMAIL>", "<PASSWORD>", session=session)

          
          ping_response = await api.presence.ping()

          
          user_info = await api.user.get_info()
          a_location_id = user_info["locations"][0]["id"]

          
          location_info = await api.location.get_info(a_location_id)

          
          first_device_id = location_info["devices"][0]["id"]
          device_info = await api.device.get_info(first_device_id)

          
          health_test_response = await api.device.run_health_test(first_device_id)

          
          close_valve_response = await api.device.close_valve(first_device_id)

          
          open_valve_response = await api.device.open_valve(first_device_id)

          
          consumption_info = await api.water.get_consumption_info(
              a_location_id,
              datetime(2020, 1, 16, 0, 0),
              datetime(2020, 1, 16, 23, 59, 59, 999000),
          )

          
          metrics = await api.water.get_metrics(
              "<DEVICE_MAC_ADDRESS>",
              datetime(2020, 1, 16, 0, 0),
              datetime(2020, 1, 16, 23, 59, 59, 999000),
          )

          
          await set_mode_away(a_location_id)

          
          await set_mode_home(a_location_id)

          
          await set_mode_sleep(a_location_id, 120, "away")


  asyncio.run(main())
  ```



  1. [Check for open features/bugs](https://github.com/bachya/aioflo/issues)
    or [initiate a discussion on one](https://github.com/bachya/aioflo/issues/new).
  2. [Fork the repository](https://github.com/bachya/aioflo/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: `script/test`
  9. Update `README.md` with any new documentation.
  10. Add yourself to `AUTHORS.md`.
  11. Submit a pull request!


pkgId: f8490ae4b42084e27c61e96fa37864bb17cc0fcc4122a85149cc5a1a6f39766b
name: python-aiogqlc
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: aiohttp based GraphQL client with file upload support
url: https://github.com/DoctorJohn/aiogqlc
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95b2f7c5-6b15-4cc2-9cbf-f92fd7f3f0fe
location_href: 00002975-python-aiogqlc/python-aiogqlc-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Versions][versions-image]][versions-url]
  [![PyPI][pypi-image]][pypi-url]
  [![Downloads][downloads-image]][downloads-url]
  [![Codecov][codecov-image]][codecov-url]
  [![License][license-image]][license-url]

  [versions-image]: https://img.shields.io/pypi/pyversions/aiogqlc
  [versions-url]: https://github.com/DoctorJohn/aiogqlc/blob/master/setup.py
  [pypi-image]: https://img.shields.io/pypi/v/aiogqlc
  [pypi-url]: https://pypi.org/project/aiogqlc/
  [downloads-image]: https://img.shields.io/pypi/dm/aiogqlc
  [downloads-url]: https://pypi.org/project/aiogqlc/
  [codecov-image]: https://codecov.io/gh/DoctorJohn/aiogqlc/branch/main/graph/badge.svg?token=63WRUHG8SW
  [codecov-url]: https://codecov.io/gh/DoctorJohn/aiogqlc
  [license-image]: https://img.shields.io/pypi/l/aiogqlc
  [license-url]: https://github.com/DoctorJohn/aiogqlc/blob/master/LICENSE

  A Python asynchronous/IO GraphQL client based on [aiohttp][aiohttp-url].

  In addition to standard HTTP POST `queries` and `mutations` this client fully supports
  the [GraphQL multipart form requests spec][multipart-specs-url] for file uploads
  and the [graphql-ws subprotocol][graphql-ws-url] for WebSocket based `subscriptions`.

  **[Read the documentation][docs-url]**



  ```sh
  pip install aiogqlc
  ```



  Check the [documentation][docs-url] for detailed and more advanced usage examples.



  ```python
  import asyncio
  import aiohttp
  from aiogqlc import GraphQLClient

  ENDPOINT = "https://swapi-graphql.netlify.app/.netlify/functions/index"

  document = """
      query {
          allFilms {
              films {
                  title
              }
          }
      }
  """


  async def main():
      async with aiohttp.ClientSession() as session:
          client = GraphQLClient(document, session=session)
          response = await client.execute(document)
          print(await response.json())


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  ```python
  import aiohttp
  from aiogqlc import GraphQLClient

  document = """
      mutation ($userId: ID!) {
          deleteUser (id: $userId) {
              id
          }
      }
  """

  variables = {
      "userId": "42",
  }


  async def main():
      async with aiohttp.ClientSession() as session:
          client = GraphQLClient("https://example.com/graphql/", session=session)
          response = await client.execute(document, variables=variables)
          print(await response.json())
  ```



  ```python
  import aiohttp
  from aiogqlc import GraphQLClient

  document = """
      mutation($file: Upload!) {
          uploadFile(file: $file) {
              size
          }
      }
  """

  variables = {
      "file": open("test.txt", "rb")
  }


  async def foo():
      async with aiohttp.ClientSession() as session:
          client = GraphQLClient("https://example.com/graphql/", session=session)
          response = await client.execute(document, variables=variables)
          print(await response.json())

  ```



  ```python
  import aiohttp
  from aiogqlc import GraphQLClient

  document = """
      subscription($postId: ID!) {
          likeAdded(postId: $postId)
      }
  """

  variables = {
      "postId": "42"
  }


  async def main():
      async with aiohttp.ClientSession() as session:
          client = GraphQLClient("https://example.com/graphql/", session=session)

          async with client.connect() as connection:
              async for payload in connection.subscribe(document, variables=variables):
                  print(payload)
  ```



  [Read the documentation][docs-url] to learn more about queries, mutations, subscriptions, file uploads and even authentication.

  [aiohttp-url]: https://github.com/aio-libs/aiohttp
  [multipart-specs-url]: https://github.com/jaydenseric/graphql-multipart-request-spec
  [graphql-ws-url]: https://github.com/apollographql/subscriptions-transport-ws
  [docs-url]: https://doctorjohn.github.io/aiogqlc/


pkgId: c0d12b8be03e8d8f0a7802b3b44efb0f80d1badc3d0b4c9ef250b1bbb10563a5
name: python-aioguardian
arch: src
version: 2022.10.0
epoch: 0
release: 1
summary: A Python3 library for Elexa Guardian water valves and sensors
url: https://github.com/bachya/aioguardian
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ae7f454-c074-47f7-a7c6-49eda5e02c3e
location_href: 00002976-python-aioguardian/python-aioguardian-2022.10.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bachya/aioguardian/workflows/CI/badge.svg)](https://github.com/bachya/aioguardian/actions)
  [![PyPi](https://img.shields.io/pypi/v/aioguardian.svg)](https://pypi.python.org/pypi/aioguardian)
  [![Version](https://img.shields.io/pypi/pyversions/aioguardian.svg)](https://pypi.python.org/pypi/aioguardian)
  [![License](https://img.shields.io/pypi/l/aioguardian.svg)](https://github.com/bachya/aioguardian/blob/main/LICENSE)
  [![Code Coverage](https://codecov.io/gh/bachya/aioguardian/branch/dev/graph/badge.svg)](https://codecov.io/gh/bachya/aioguardian)
  [![Maintainability](https://api.codeclimate.com/v1/badges/a03c9e96f19a3dc37f98/maintainability)](https://codeclimate.com/github/bachya/aioguardian/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>

  `aioguardian` is a Python3, `asyncio`-focused library for interacting with
  [the Guardian line of water valves and sensors from Elexa](http://getguardian.com).

  - [Installation](#installation)
  - [Python Versions](#python-versions)
  - [Documentation](#documentation)
  - [Contributing](#contributing)



  ```bash
  pip install aioguardian
  ```



  `aioguardian` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  Complete documentation can be found here: http://aioguardian.readthedocs.io



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


pkgId: cd73de5d91e1a290f039156a59f97519dd6c12b595cedeaf69c4fcba8261ab46
name: python-aiohomekit
arch: src
version: 2.6.2
epoch: 0
release: 1
summary: An asyncio HomeKit client
url: https://github.com/Jc2k/aiohomekit
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1b2e19c-64e1-485c-b9a3-8f0fe8856583
location_href: 00002977-python-aiohomekit/python-aiohomekit-2.6.2-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/Jc2k/aiohomekit/workflows/CI/badge.svg?event=push) [![codecov](https://codecov.io/gh/Jc2k/aiohomekit/branch/master/graph/badge.svg)](https://codecov.io/gh/Jc2k/aiohomekit)

  This library implements the HomeKit protocol for controlling Homekit accessories using asyncio.

  It's primary use is for with Home Assistant. We target the same versions of python as them and try to follow their code standards.

  At the moment we don't offer any API guarantees. API stability and documentation will happen after we are happy with how things are working within Home Assistant.



  `aiohomekit` is primarily for use with Home Assistant. Lots of users are using it with devices from a wide array of vendors. As a community open source project we do not have the hardware or time resources to certify every device with multiple vendors projects. We may be conservative about larger changes or changes that are low level. We do ask where possible that any changes should be tested with a certified HomeKit implementations of shipping products, not just against emulators or other uncertified implementations.

  Because API breaking changes would hamper our ability to quickly update Home Assistant to the latest code, if you can please submit a PR to update [homekit_controller](https://github.com/home-assistant/core/tree/dev/homeassistant/components/homekit_controller) too. If they don't your PR maybe on hold until someone is available to write such a PR.

  Please bear in mind that some shipping devices interpret the HAP specification loosely. In general we prefer to match the behaviour of real HAP controllers even where their behaviour is not strictly specified. Here are just some of the kinds of problems we've had to work around:

  * Despite the precise formatting of JSON being unspecified, there are devices in the wild that cannot handle spaces when parsing JSON. For example, `{"foo": "bar"}` vs `{"foo":"bar"}`. This means we never use a "pretty" encoding of JSON.
  * Despite a boolean being explicitly defined as `0`, `1`, `true` or `false` in the spec, some devices only support 3 of the 4. This means booleans must be encoded as `0` or `1`.
  * Some devices have shown themselves to be sensitive to headers being missing, in the wrong order or if there are extra headers. So we ensure that only the headers iOS sends are present, and that the casing and ordering is the same.
  * Some devices are sensitive to a HTTP message being split into separate TCP packets. So we take care to only write a full message to the network stack.

  And so on. As a rule we need to be strict about what we send and loose about what we receive.



  `aiohomekit` is primarily tested via Home Assistant with a Phillips Hue bridge and an Eve Extend bridge. It is known to work to some extent with many more devices though these are not currently explicitly documented anywhere at the moment.

  You can look at the problems your device has faced in the home-assistant [issues list](https://github.com/home-assistant/core/issues?q=is%3Aopen+is%3Aissue+label%3A%22integration%3A+homekit_controller%22).





  It's published on pypi as `aiohomekit` but its still under early development - proceed with caution.

  The main consumer of the API is the [homekit_controller](https://github.com/home-assistant/core/tree/dev/homeassistant/components/homekit_controller) in Home Assistant so that's the best place to get a sense of the API.



  No. Eventually we hope to via [aioble](https://github.com/detectlabs/aioble) which provides an asyncio bluetooth abstraction that works on Linux, macOS and Windows.



  No, this is just the client part. You should use one the of other implementations:

   * [homekit_python](https://github.com/jlusiardi/homekit_python/) (this is used a lot during aiohomekit development)
   * [HAP-python](https://github.com/ikalchev/HAP-python)



  At the time of writing this is the only python 3.7/3.8 asyncio HAP client with events support.



  Where possible aiohomekit uses libraries that are easy to install with pip, are ready available as wheels (including on Raspberry Pi via piwheels), are cross platform (including Windows) and are already used by Home Assistant. They should not introduce hard dependencies on uncommon system libraries. The intention here is to avoid any difficulty in the Home Assistant build process.

  People are often alarmed at the hand rolled HTTP code and suggest using an existing HTTP library like `aiohttp`. High level HTTP libraries are pretty much a non-starter because:

  * Of the difficulty of adding in HAP session security without monkey patches.
  * They don't expect responses without requests (i.e. events).
  * As mentioned above, some of these devices are very sensitive. We don't care if your change is compliant with every spec if it still makes a real world device cry. We are not in a position to demand these devices be fixed. So instead we strive for byte-for-byte accuracy on our write path. Any library would need to give us that flexibility.
  * Some parts of the responses are actually not HTTP, even though they look it.

  We are also just reluctant to make a change that large for something that is working with a lot of devices. There is a big chance of introducing a regression.

  Of course a working proof of concept (using a popular well maintained library) that has been tested with something like a Tado internet bridge (including events) would be interesting.



  This library wouldn't have been possible without homekit_python, a synchronous implementation of both the client and server parts of HAP.


pkgId: b28a8776340db8d947c9588e9929a3b5964e50b861198bdbe68d62289bf38e64
name: python-aiohttp-debuginfo
arch: aarch64
version: 3.8.4
epoch: 0
release: 1
summary: Debug information for package python-aiohttp
url: https://github.com/aio-libs/aiohttp
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-04538c45-954d-448a-aaaa-e9d02549d80a
rpm_sourcerpm: python-aiohttp-3.8.4-1.src.rpm
location_href: 00002978-python-aiohttp/python-aiohttp-debuginfo-3.8.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-aiohttp.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e82bc8b4f73d39c001ebc9b6c5585df623b613a9a6cd17362bbeb51bb2703dcc
name: python-aiohttp-debugsource
arch: aarch64
version: 3.8.4
epoch: 0
release: 1
summary: Debug sources for package python-aiohttp
url: https://github.com/aio-libs/aiohttp
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-04538c45-954d-448a-aaaa-e9d02549d80a
rpm_sourcerpm: python-aiohttp-3.8.4-1.src.rpm
location_href: 00002978-python-aiohttp/python-aiohttp-debugsource-3.8.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-aiohttp.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 70df2387bf1ad70afde983a37bdc44054607cf91caad247999489522ae5e6cc1
name: python-aiohttp-socks
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Proxy connector for aiohttp
url: https://github.com/romis2012/aiohttp-socks
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-70a5aae6-faf9-4fb8-869d-8afde487b37b
location_href: 00002981-python-aiohttp-socks/python-aiohttp-socks-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://api.travis-ci.com/romis2012/aiohttp-socks.svg?branch=master)](https://travis-ci.com/github/romis2012/aiohttp-socks)
  [![Coverage Status](https://coveralls.io/repos/github/romis2012/aiohttp-socks/badge.svg?branch=master&_=x)](https://coveralls.io/github/romis2012/aiohttp-socks?branch=master)
  [![PyPI version](https://badge.fury.io/py/aiohttp-socks.svg)](https://badge.fury.io/py/aiohttp-socks)
  <!--
  [![Downloads](https://pepy.tech/badge/aiohttp-socks/month)](https://pepy.tech/project/aiohttp-socks)
  -->
  The `aiohttp-socks` package provides a proxy connector for [aiohttp](https://github.com/aio-libs/aiohttp).
  Supports SOCKS4(a), SOCKS5(h), HTTP (tunneling) as well as Proxy chains.
  It uses [python-socks](https://github.com/romis2012/python-socks) for core proxy functionality.



  - Python >= 3.6
  - aiohttp >= 2.3.2
  - python-socks[asyncio] >= 1.0.1


  ```
  pip install aiohttp_socks
  ```




  ```python
  import aiohttp
  from aiohttp_socks import ProxyType, ProxyConnector, ChainProxyConnector


  async def fetch(url):
      connector = ProxyConnector.from_url('socks5://user:password@127.0.0.1:1080')

      
      
      
      
      
      
      
      
      

      
      
      
      
      
      
      async with aiohttp.ClientSession(connector=connector) as session:
          async with session.get(url) as response:
              return await response.text()
  ```



  ```python
  from aiohttp_socks import open_connection

  async def fetch():
      reader, writer = await open_connection(
          proxy_url='socks5://user:password@127.0.0.1:1080',
          host='check-host.net',
          port=80
      )
      request = (b"GET /ip HTTP/1.1\r\n"
                 b"Host: check-host.net\r\n"
                 b"Connection: close\r\n\r\n")

      writer.write(request)
      return await reader.read(-1)
  ```



  Unlike [aiosocksy](https://github.com/romis2012/aiosocksy), aiohttp_socks has only single point of integration with aiohttp.
  This makes it easier to maintain compatibility with new aiohttp versions.


pkgId: b6947e5f55f8230683c682459f28f0648bf8f20450f9950fc7f8113a1bd857dd
name: python-aiohttp-swagger
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: Swagger API Documentation builder for aiohttp server
url: https://github.com/cr0hn/aiohttp-swagger
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c87b16f6-8829-49f1-82ee-adb93e4cec94
location_href: 00013168-python-aiohttp-swagger/python-aiohttp-swagger-1.0.16-1.src.rpm
checksum_type: sha256
description:
  **LOOCKING FOR MAINTAINERS**!!!!!
  ![Logo](doc/source/_static/logo.png)
  [![Build Status](https://travis-ci.org/cr0hn/aiohttp-swagger.svg?branch=master)](https://travis-ci.org/cr0hn/aiohttp-swagger)
  [![codecov.io](https://codecov.io/github/cr0hn/aiohttp-swagger/coverage.svg?branch=master)](https://codecov.io/github/cr0hn/aiohttp-swagger)
  *aiohttp-swagger: Swagger API Documentation builder for aiohttp server*


pkgId: 83c6b69a9ab656e3ea6e8b5212c47dc468f1aa48eadc81bafb8f52a81fe71e9d
name: python-aiohue
arch: src
version: 4.6.2
epoch: 0
release: 1
summary: Python module to talk to Philips Hue.
url: https://github.com/home-assistant-libs/aiohue
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eacace55-df25-4d1d-9b77-88e1c8871bdc
location_href: 00002983-python-aiohue/python-aiohue-4.6.2-1.src.rpm
checksum_type: sha256
description:
  Requires Python 3.8+ and uses asyncio and aiohttp.

  For usage examples, see the examples folder.



  This library supports both the new style V2 API (only available on V2 bridges) and the old style V1 API.
  The biggest advantage of the V2 API is that it supports event based updates so polling is not required.



  Object hierarchy and property/method names should match the Philips Hue API.


pkgId: 0e204a90d3ced50a1096715b675454fda67b18ac8c9797914c7f9407290a915a
name: python-aioiotprov
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Library/utility to help provision various IoT devices.
url: http://github.com/frawau/aioiotprov
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-100e15d6-4c92-4534-924a-216bc734478d
location_href: 00002984-python-aioiotprov/python-aioiotprov-0.0.8-1.src.rpm
checksum_type: sha256
description:
  A library/utility to provision IoT devices

  [![PyPI version fury.io](https://badge.fury.io/py/aioiotprov.svg)](https://pypi.python.org/pypi/aioiotprov)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-licen)
  [![GITHUB-BADGE](https://github.com/frawau/aioiotprov/workflows/black/badge.svg)](https://github.com/psf/black)

  This is early day.  Currently it can provision TP-Link smartplugs, Broadlink IR blasters,  Sonoff switches running
  the Tasmota firmware, Shelly devices and E-Trix power monitors, Xiaomi Yeelights (Possibly other Xiaomi too)

  This uses nmcli or wpa_cli to control and configure WIFI access. This means this will work only with
  Linux, and then again not all. It is working on a RaspberryPi running Debian Stretch (No NetworkManager) and works on a laptop ruunning Ubuntu 18.10 to 20.04

  When using nmcli, it is possible to use a connected WiFi adapter, this has not yet been tested with wpa_cli




  We are on PyPi so

      pip3 install aioiotprov




  You can just run it by doing

      python3 -m aioiotprov "My SSID" "My Secret Key"

  If you want to set user, password and for sonoff, MQTT, do something like

      python3 -m aioiotprov -u user -p password "My SSID" "My Secret Key" \
      -o "sonoff::mqtt==on||user=mqttuser||password=mqttpass||host=somehost||port=1883||client=DVES_XXXXXX||topic=sonoff-XXXXXX||full topic=blabla/%prefix%/%topic%/"

  For Shellies,

      python3 -m aioiotprov -u user -p password "My SSID" "My Secret Key" \
      -o "shelly::mqtt==on||user==mqttuser||password==mqttpass||host==somehost||port==1883"

  For Tasmota,

      python3 -m aioiotprov -d -u user -p passwd -o 'tasmota::mqtt==on||template=={"NAME":"Sonoff T1 3CH","GPIO":[17,255,255,255,23,22,18,19,21,56,0,0,0],"FLAG":0,"BASE":30}||host==somehost||user==mqttuser||password==mqttpasswd'
      -- SSID KEY


  Setting option will only works with plugins that can handle those. Use '::' after name of the plugin. Use '==' to set value
  and use '||' to separate options





  This is a plugin to provision [Broadlink](http://www.ibroadlink.com/) devices, like the A1 sensor or the RM4 Mini IR blaster.

  The device cannot be secured (no user/password setting) nor is any option available for this plugin.



  This is a plugin to provision [E-Trix](https://creativepowerthai.com/intro/) electrix metering devices.

  The device cannot be secured (no user/password setting) nor is any option available for this plugin.



  This is a plugin to provision [Shelly](https://shelly.cloud/) devices.

  If you set the user and the password, the device will be secured with those.

  The plugin supports the following options:

      mqtt:    on or off Use MQTT or not
          host: mqtt host URI (with port if needed) (only if mqtt=='on'
          user: mqtt username
          password: mqtt password




  This is a plugin to provision devices running the [Tasmota](https://tasmota.github.io/docs/) software.

  If you set the user and the password, the device will be secured with those.

  The plugin supports the following options:

      module:  The index of the module to use (e.g. 29 is for Sonoff T1 2CH)
      template: A device template. See the Tasmota documentation for details.
      mqtt:    on or off Use MQTT or not
          host: mqtt host (only if mqtt=='on'
          user: mqtt username
          password: mqtt password
          port: mqtt port
          client: see tasmota documentation for details
          topic: define the device unique id for MQTT
          full topic: : full topic e.g. mystuff/%prefix%/%topic%

      For 'client', 'topic' and 'full topic'  the string '{mac}' in the value will be replaced by
      the last 6 hexadigits of the MAC address in lowercase format.



  This is a plugin to provision [TP-Link](https://www.kasasmart.com/us/products/smart-plugs) smart plugs devices. It may work with other smart home devices, but this has not been tested.
  The device cannot be secured (no user/password setting) nor is any option available for this plugin.



  This plugin is based on the protocol description and the code  from [OpenMiHome](https://github.com/OpenMiHome/mihome-binary-protocol)

  This plugin provision [Xiaomi Yeelight](https://www.yeelight.com/).

  Upon successful provisioning,  the token, used to encrypt subsequent communications, is returned.

  By default, the key will be saved in the file ~/.aioyeelight. It can then be used with [aioyeelight](ttps://github.com/frawau/aioyeelight).
  If you do not wish to persist keys, use the nopersist option.

  Note:
      The plugin accepts the option 'owner' but this does not seem to have any effect.



  Mostly each plugin knows what SSID to look for. If one of the needed SSID is found, aioiotprov will connect
  to the SSID and hand over provisioning duties to the plugin.


pkgId: 7a32a0d46e41b3c388137529d139478ead764898db68e659647afa4f5a6e170d
name: python-aiokafka
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Kafka integration with asyncio.
url: http://aiokafka.readthedocs.org
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6a7aac81-7226-4f07-bed1-7881062bf6c6
location_href: 00011125-python-aiokafka/python-aiokafka-0.8.0-1.src.rpm
checksum_type: sha256
description:
  asyncio client for Kafka
  AIOKafkaProducer
  ****************
  AIOKafkaProducer is a high-level, asynchronous message producer.
  Example of AIOKafkaProducer usage:
      from aiokafka import AIOKafkaProducer
      import asyncio
      async def send_one():
          producer = AIOKafkaProducer(bootstrap_servers='localhost:9092')
          
          await producer.start()
          try:
              
              await producer.send_and_wait("my_topic", b"Super message")
          finally:
              
              await producer.stop()
      asyncio.run(send_one())
  AIOKafkaConsumer
  ****************
  AIOKafkaConsumer is a high-level, asynchronous message consumer.
  It interacts with the assigned Kafka Group Coordinator node to allow multiple
  consumers to load balance consumption of topics (requires kafka >= 0.9.0.0).
  Example of AIOKafkaConsumer usage:
      from aiokafka import AIOKafkaConsumer
      import asyncio
      async def consume():
          consumer = AIOKafkaConsumer(
              'my_topic', 'my_other_topic',
              bootstrap_servers='localhost:9092',
              group_id="my-group")
          
          await consumer.start()
          try:
              
              async for msg in consumer:
                  print("consumed: ", msg.topic, msg.partition, msg.offset,
                        msg.key, msg.value, msg.timestamp)
          finally:
              
              await consumer.stop()
      asyncio.run(consume())


pkgId: 6c6a827908961c23c3a16dad6ff985dca168d9819a3e1479d053f2f051ea244e
name: python-aiokafka-debuginfo
arch: aarch64
version: 0.8.0
epoch: 0
release: 1
summary: Debug information for package python-aiokafka
url: http://aiokafka.readthedocs.org
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-6a7aac81-7226-4f07-bed1-7881062bf6c6
rpm_sourcerpm: python-aiokafka-0.8.0-1.src.rpm
location_href: 00011125-python-aiokafka/python-aiokafka-debuginfo-0.8.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-aiokafka.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: be466fb43dac06c287c8facdad366afca41afc301c332031e7e61d79eea30278
name: python-aiokafka-debugsource
arch: aarch64
version: 0.8.0
epoch: 0
release: 1
summary: Debug sources for package python-aiokafka
url: http://aiokafka.readthedocs.org
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-6a7aac81-7226-4f07-bed1-7881062bf6c6
rpm_sourcerpm: python-aiokafka-0.8.0-1.src.rpm
location_href: 00011125-python-aiokafka/python-aiokafka-debugsource-0.8.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-aiokafka.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: f85e394ff05a95387759afbb581962d33eee72858ef79630bb9373e4dece0802
name: python-aiolifx
arch: src
version: 0.8.9
epoch: 0
release: 1
summary: API for local communication with LIFX devices over a LAN with asyncio.
url: http://github.com/frawau/aiolifx
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fca0a0ce-291b-4eb7-bc9d-841f9e2ca439
location_href: 00002986-python-aiolifx/python-aiolifx-0.8.9-1.src.rpm
checksum_type: sha256
description:
  aiolifx is a Python 3/asyncio library to control Lifx LED lightbulbs over your LAN.

  [![PyPI version fury.io](https://badge.fury.io/py/aiolifx.svg)](https://pypi.python.org/pypi/aiolifx)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-licen)
  [![GITHUB-BADGE](https://github.com/frawau/aiolifx/workflows/black/badge.svg)](https://github.com/psf/black)
  [![Downloads](https://pepy.tech/badge/aiolifx/month)](https://pepy.tech/project/aiolifx)

  Most of it was taken from Meghan Clarkk lifxlan package (https://github.com/mclarkk)
  and adapted to Python 3 (and asyncio obviously)



  We are on PyPi so

       pip3 install aiolifx
  or
       python3 -m pip install aiolifx

  After installation, the utility

      aiolifx

  can be used to test/control devices.

  NOTE: When installing with Python 3.4, the installation produce an error message
        (syntax error). This can be safely ignored.




  Essentially, you create an object with at least 2 methods:

      - register
      - unregister

  You then start the LifxDiscovery task in asyncio. It will register any new light it finds.
  All the method communicating with the bulb can be passed a callback function to react to
  the bulb response. The callback should take 2 parameters:

      - a light object
      - the response message


  The easiest way is to look at the file in the examples directory. "Wifi" and "Uptime" use
  a callback to print the info when it is returned.


  In essence, the test program is this

      class bulbs():
      """ A simple class with a register and unregister methods
      """
          def __init__(self):
              self.bulbs=[]

          def register(self,bulb):
              self.bulbs.append(bulb)

          def unregister(self,bulb):
              idx=0
              for x in list([ y.mac_addr for y in self.bulbs]):
                  if x == bulb.mac_addr:
                      del(self.bulbs[idx])
                      break
                  idx+=1

      def readin():
      """Reading from stdin and displaying menu"""

          selection = sys.stdin.readline().strip("\n")
          DoSomething()

      MyBulbs = bulbs()
      loop = aio.get_event_loop()
      discovery = alix.LifxDiscovery(loop, MyBulbs)
      try:
          loop.add_reader(sys.stdin, readin)
          discovery.start()
          loop.run_forever()
      except:
          pass
      finally:
          discovery.cleanup()
          loop.remove_reader(sys.stdin)
          loop.close()


  Other things worth noting:

      -  Whilst LifxDiscovery uses UDP broadcast, the bulbs are
         connected with Unicast UDP

      - The socket connecting to a bulb is not closed unless the bulb is deemed to have
        gone the way of the Dodo. I've been using that for days with no problem

      - You can select to used IPv6 connection to the bulbs by passing an
        IPv6 prefix to LifxDiscovery. It's only been tried with /64 prefix.
        If you want to use a /48 prefix, add ":" (colon) at the end of the
        prefix and pray. (This means 2 colons at the end!)

      - I only have Original 1000, so I could not test with other types
        of bulbs

      - Unlike in lifxlan, set_waveform takes a dictionary with the right
        keys instead of all those parameters



  Thanks to Anders Melchiorsen and Avi Miller for their essential contributions


