# packages

pkgId: 585f23c82489ea68981b968847468777a3e2148f9a9b9b00b171a3325e8c7d87
name: python-ghp-import
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Copy your docs directly to the gh-pages branch.
url: https://github.com/c-w/ghp-import
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a6917e5b-a22a-48a0-b535-33260981b74c
location_href: 00009962-python-ghp-import/python-ghp-import-2.1.0-1.src.rpm
checksum_type: sha256
description:
  [![CI status](https://github.com/davisp/ghp-import/workflows/CI/badge.svg)](https://github.com/davisp/ghp-import/actions?query=workflow%3Aci)
  [![CircleCI](https://circleci.com/gh/c-w/ghp-import/tree/master.svg?style=svg)](https://circleci.com/gh/c-w/ghp-import/tree/master)
  [![TravisCI](https://travis-ci.org/c-w/ghp-import.svg?branch=master)](https://travis-ci.org/c-w/ghp-import)
  [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Version](https://img.shields.io/pypi/v/ghp-import.svg)](https://pypi.org/project/ghp-import/)
  As part of [gunicorn][gunicorn], [Benoit Chesneau][benoit] and [Paul Davis][davisp]
  were looking at how to host documentation. There's the obvious method of
  using [GitHub's post-receive hook][github-post] to trigger doc builds and rsync
  to a webserver, but we ended up wanting to try out github's hosting to make the
  whole interface a bit more robust.
  [GitHub Pages][gh-pages] is a pretty awesome service that GitHub provides for
  hosting project documentation. The only thing is that it requires a
  `gh-pages` branch that is the site's document root. This means that keeping
  documentation sources in the branch with code is a bit difficult. And it really
  turns into a head scratcher for things like [Sphinx][sphinx] that want to
  access documentation sources and code sources at the same time.
  Then we stumbled across an interesting looking package called
  [github-tools][github-tools] that looked almost like what we wanted. It was a tad
  complicated and more involved than we wanted but it gave us an idea. Why not
  just write a script that can copy a directory to the `gh-pages` branch of the
  repository. This saves us from even having to think about the branch and
  everything becomes magical.
  This is what `ghp-import` was written for.
  [gunicorn]: http://www.gunicorn.com/ "Gunicorn"
  [benoit]: http://github.com/benoitc "Benoît Chesneau"
  [davisp]: http://github.com/davisp "Paul J. Davis"
  [github-post]: https://help.github.com/articles/post-receive-hooks "GitHub Post-Receive Hook"
  [gh-pages]: http://pages.github.com/ "GitHub Pages"
  [sphinx]: http://sphinx.pocoo.org/ "Sphinx Documentation"
  [github-tools]: http://dinoboff.github.com/github-tools/ "github-tools"


pkgId: 7d1fa019e968f7402d68d99f25053f95d49a6da7ab9ec81b2835aec72fc94760
name: python-ginga
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: A scientific image viewer and toolkit
url: https://ejeschke.github.io/ginga/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1904daae-24f0-41b8-a86f-f56914f9b98c
location_href: 00003760-python-ginga/python-ginga-4.0.1-1.src.rpm
checksum_type: sha256
description:
  Ginga is a toolkit designed for building viewers for scientific image
  data in Python, visualizing 2D pixel data in numpy arrays.
  The Ginga toolkit centers around an image display class which supports
  zooming and panning, color and intensity mapping, a choice of several
  automatic cut levels algorithms and canvases for plotting scalable
  geometric forms.  In addition to this widget, a general purpose
  'reference' FITS viewer is provided, based on a plugin framework.

  Ginga is distributed under an open-source BSD licence. Please see the
  file LICENSE.txt in the top-level directory for details.


pkgId: 3eebb770c5c8313261b0ac30f2dc60382e68878f1295325063fc6af475a32b4d
name: python-gios
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Python wrapper for getting air quality data from GIOŚ servers.
url: https://github.com/bieniu/gios
rpm_license: Apache-2.0 License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c496c7c-9b90-44a7-b091-53ee52f23d9b
location_href: 00003762-python-gios/python-gios-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![PyPI][pypi-releases-shield]][pypi-releases]
  [![PyPI - Downloads][pypi-downloads]][pypi-statistics]
  [![Buy me a coffee][buy-me-a-coffee-shield]][buy-me-a-coffee]
  [![PayPal_Me][paypal-me-shield]][paypal-me]


  Python wrapper for getting air quality data from [GIOŚ (Główny Inspektorat Ochrony Środowiska)](http://www.gios.gov.pl/pl/stan-srodowiska/monitoring-jakosci-powietrza)


  - go to http://powietrze.gios.gov.pl/pjp/current
  - find on the map a measurement station located closest to your home
  - go to "More infotmation" link
  - look at site address, for ex. for this address https://powietrze.gios.gov.pl/pjp/current/station_details/table/10124/3/0 `station_id` is 10124


  ```python
  """Example for GIOS."""
  import asyncio
  import logging

  from aiohttp import ClientError, ClientSession

  from gios import ApiError, Gios, InvalidSensorsData, NoStationError

  GIOS_STATION_ID = 568

  logging.basicConfig(level=logging.DEBUG)


  async def main() -> None:
      """Run main function."""
      async with ClientSession() as websession:
          gios = Gios(GIOS_STATION_ID, websession)
          try:
              data = await gios.async_update()
          except (ApiError, NoStationError, InvalidSensorsData, ClientError) as error:
              print(error)
              return

      latitude = gios.latitude
      longitude = gios.longitude
      station_name = gios.station_name
      print(f"Longitude: {longitude}")
      print(f"Latitude: {latitude}")
      print(f"Station name: {station_name}")
      print(data)


  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  loop.close()
  ```
  [releases]: https://github.com/bieniu/gios/releases
  [releases-shield]: https://img.shields.io/github/release/bieniu/gios.svg?style=popout
  [pypi-releases]: https://pypi.org/project/gios/
  [pypi-statistics]: https://pepy.tech/project/gios
  [pypi-releases-shield]: https://img.shields.io/pypi/v/gios
  [pypi-downloads]: https://pepy.tech/badge/gios/month
  [buy-me-a-coffee-shield]: https://img.shields.io/static/v1.svg?label=%20&message=Buy%20me%20a%20coffee&color=6f4e37&logo=buy%20me%20a%20coffee&logoColor=white
  [buy-me-a-coffee]: https://www.buymeacoffee.com/QnLdxeaqO
  [paypal-me-shield]: https://img.shields.io/static/v1.svg?label=%20&message=PayPal.Me&logo=paypal
  [paypal-me]: https://www.paypal.me/bieniu79


pkgId: 04464ca4c2b8531605c3e007c0989f6961b914d34086533431c8152e8cab0a9d
name: python-git-remote-codecommit
arch: src
version: 1.16
epoch: 0
release: 1
summary: Git remote prefix to simplify pushing to and pulling from CodeCommit.
url: https://github.com/awslabs/git-remote-codecommit
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-099fa8b7-ba09-40ce-8367-a36968c5ca0d
location_href: 00010652-python-git-remote-codecommit/python-git-remote-codecommit-1.16-1.src.rpm
checksum_type: sha256
description:
  This package provides a simple method for pushing and pulling from `AWS
  CodeCommit <https://aws.amazon.com/codecommit/>`__. This package extends `git
  <https://git-scm.com/>`__ to support repository URLs prefixed with
  **codecommit://**. For example, if using IAM...
    % cat ~/.aws/config
    [profile demo-profile]
    region = us-east-2
    output = json
    % cat ~/.aws/credentials
    [demo-profile]
    aws_access_key_id = AKIAIOSFODNN7EXAMPLE
    aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
    % git clone codecommit://demo-profile@MyRepositoryName
  The *git-remote-codecommit* package works on Python versions:
  * 3.6.x
  * 3.7.x
  * 3.8.x
  * 3.9.x


pkgId: 3e22e32b208fbe77541a0ca5864fbb97608ac7ec7dbe200166890d0d0ded3533
name: python-git-revise
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Efficiently update, split, and rearrange git commits
url: https://github.com/mystor/git-revise
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4037f57e-71cf-461f-ae5d-fe0f77b1409f
location_href: 00003763-python-git-revise/python-git-revise-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/mystor/git-revise.svg?branch=master)](https://travis-ci.org/mystor/git-revise)
  [![PyPi](https://img.shields.io/pypi/v/git-revise.svg)](https://pypi.org/project/git-revise)
  [![Documentation Status](https://readthedocs.org/projects/git-revise/badge/?version=latest)](https://git-revise.readthedocs.io/en/latest/?badge=latest)


  `git revise` is a `git` subcommand to efficiently update, split, and rearrange
  commits. It is heavily inspired by `git rebase`, however it tries to be more
  efficient and ergonomic for patch-stack oriented workflows.

  By default, `git revise` will apply staged changes to a target commit, then
  update `HEAD` to point at the revised history. It also supports splitting
  commits and rewording commit messages.

  Unlike `git rebase`, `git revise` avoids modifying the working directory or
  the index state, performing all merges in-memory and only writing them when
  necessary. This allows it to be significantly faster on large codebases and
  avoids unnecessarily invalidating builds.



  ```sh
  $ pip install --user git-revise
  ```

  Various people have also packaged `git revise` for platform-specific package
  managers (Thanks!)



  ```sh
  $ brew install git-revise
  ```



  ```sh
  $ dnf install git-revise
  ```



  Documentation, including usage and examples, is hosted on [Read the Docs].

  [Read the Docs]: https://git-revise.readthedocs.io/en/latest


pkgId: e0de4a73443d213bd6a509201600d7451511d554efe33f7347dcc61d6fde8874
name: python-gitapi
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Python API to Git using the command-line interface
url: https://bitbucket.org/haard/gitapi
rpm_license: Do whatever you want, don't blame me
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5ddbe515-3fc3-4cad-b114-a53658828737
location_href: 00003765-python-gitapi/python-gitapi-1.0.1-1.src.rpm
checksum_type: sha256
description:
  gitapi is a pure-Python API to Git, that uses the command-line
  interface. This is a fork of https://bitbucket.org/haard/ with the
  intention of making a unified API for a subset of git and hg
  functionality possible


pkgId: 65c4fb6ed5aa220d2262465690c774e753c341ebcd0014388b0dadae6877e95b
name: python-githubgql
arch: src
version: 0.0.8.0
epoch: 0
release: 1
summary: Python library for GraphQL API interactions on Github Actions
url: https://github.com/actions-automation/githubgql
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2baa9f7e-77a7-4d4c-8adf-0775cf5602a5
location_href: 00011196-python-githubgql/python-githubgql-0.0.8.0-1.src.rpm
checksum_type: sha256
description:
  Python library for GraphQL API interactions on Github Actions.

  Basic example:

  ```python
  from githubgql import githubgql

  QUERY = """
  query {
    repository(owner: "github", name: "docs") {
      name
    }
  }
  """

  token = os.environ.get('BOT_TOKEN', None)

  result = githubgql.graphql(QUERY, token)
  ```

  More detailed examples are present in the source.

  Packaged using tutorial on
  [packaging.python.org](https://packaging.python.org/tutorials/packaging-projects/).
  Uses [gh-action-pypi-publish](https://github.com/actions-automation/githubgql)
  for automatic publishing.


pkgId: e1ca433bfe7411e1bae72b768704677574553006864753b9c93eb9d58d45f732
name: python-gitlab
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Get GitLab user Details
url: https://yoginth.ml
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de35f8d5-eae2-4d58-8c4f-24f31fe5302a
location_href: 00003768-python-gitlab/python-gitlab-1.0.2-1.src.rpm
checksum_type: sha256
description:
  > Get GitLab user Details



  ```
  $ pip install gitlab
  ```



  ```python
  import gitlab

  gitlab.get('yoginth')

  """
  {
  	'username': 'yoginth',
  	'bio': 'Open-Source Enthusiast • Developer & Toolmaker • Pythonista 🐍 • Issue Resolver • Jack 🃏 of all trades, master of none • Beating the odds • I 💜 science 🌌',
  	'location': 'Parallel Universe',
  	'twitter': 'yoginths',
  	'linkedin': '',
  	'skype': '',
  	'website_url': 'https://t.me/yoginth',
  	'id': 2580049,
  	'state': 'active',
  	'avatar_url': 'https://secure.gravatar.com/avatar/ef5eb22b653730b5d7d7c32a73ff64e7?s=80&d=identicon',
  	'web_url': 'https://gitlab.com/yoginth'
  }
  """
  ```



  There are few ways to get help:

   1. Please [post questions on Stack Overflow](https://stackoverflow.com/questions/ask). You can open issues with questions, as long you add a link to your Stack Overflow question.

   2. For bug reports and feature requests, open issues.

   3. For direct and quick help, you can [email me](mailto://yoginth@zoho.com).


  Have an idea? Found a bug? See [how to contribute][contributing].

  Thanks!



  [MIT][license]

  [LICENSE]: https://yoginth.mit-license.org/
  [contributing]: /CONTRIBUTING.md


pkgId: 8fc96e811b0f8e3e627263fdb25bc9a54bd4e6e16e949809cb53fc8b13bb5383
name: python-glad
arch: src
version: 0.1.36
epoch: 0
release: 1
summary: Multi-Language GL/GLES/EGL/GLX/WGL Loader-Generator based on the official specs.
url: https://github.com/Dav1dde/glad
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50c604b2-9415-4b22-8a81-2e2aeae7378e
location_href: 00003769-python-glad/python-glad-0.1.36-1.src.rpm
checksum_type: sha256
description:
  Glad uses the official Khronos-XML specs to generate a
  GL/GLES/EGL/GLX/WGL Loader made for your needs.
  Checkout the GitHub repository: https://github.com/Dav1dde/glad


pkgId: c6b29b4e1889fc5119b50f618724a0d708497c8a973141de8e91a0dde4333e1d
name: python-glances-api
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Python API for interacting with Glances
url: https://github.com/home-assistant-ecosystem/python-glances-api
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a41db098-2f0d-4b8d-aab3-6c812fc7e7eb
location_href: 00003771-python-glances-api/python-glances-api-0.4.1-1.src.rpm
checksum_type: sha256
description:
  A Python client for interacting with `Glances <https://nicolargo.github.io/glances/>`_.
  This module is not official, developed, supported or endorsed by Glances.


pkgId: c8d34409595c637c6b7a164b5052fd66f55467d8c393fa045520ff77628561f2
name: python-glocaltokens
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Tool to extract Google device local authentication tokens in Python
url: https://github.com/leikoilja/glocaltokens
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d489a6ab-6191-407b-82ae-468149248064
location_href: 00012654-python-glocaltokens/python-glocaltokens-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status][workflow-shield]][workflow]
  [![PyPI][pypi-shield]][pypi]
  [![Downloads][pepy-shield]][pepy]
  [![Pre-commit][pre-commit-shield]][pre-commit]
  [![GitHub Activity][commits-shield]][commits]



  Python 3 package to extract google home devices local authentication tokens from google servers.
  These local authentication tokens are needed to control Google Home devices
  (See [@rithvikvibhu](https://github.com/rithvikvibhu)'s [Google Home (2.0) API](https://rithvikvibhu.github.io/GHLocalApi/)).

  Please note:
  Once you have local google authentication tokens they only live about 1 day long.
  After that you will need to obtain new ones.
  You will probably need to run the script repeatedly storing the tokens somewhere convenient.



  Note: the package was written and tested on Python 3.

  - Install the python package

  ```
  pip install glocaltokens
  ```

  Use in your program as (see examples folder for detailed example):

  ```Python
  from glocaltokens.client import GLocalAuthenticationTokens








  client = GLocalAuthenticationTokens(
    username="<YOUR_GOOGLE_USERNAME>",
    password="<YOUR_GOOGLE_PASSWORD>"
  )


  print("[*] Master token", client.get_master_token())


  print("\n[*] Access token (lives 1 hour)", client.get_access_token())


  print("\n[*] Google devices local authentication tokens")
  google_devices = client.get_google_devices_json()




  from glocaltokens.const import GOOGLE_HOME_MODELS

  google_devices_select = client.get_google_devices_json(GOOGLE_HOME_MODELS)


  google_devices_select_2 = client.get_google_devices_json([
      f"Google Home",
      f"Google Home Mini",
      f"Google Nest Mini",
  ])
  ```



  There are some pre-defined models list in [`scanner.py`](/glocaltokens/scanner.py), feel free to
  add new lists, or add models to a list with a pull-request.



  - Google Home
  - Google Home Mini
  - Google Nest Mini
  - Lenovo Smart Clock



  Never store the user's password nor username in plain text, if storage is necessary, generate a master token and store it.
  Example approach:

  ```python
  from glocaltokens.client import GLocalAuthenticationTokens


  client = GLocalAuthenticationTokens(
    username="<YOUR_GOOGLE_USERNAME>",
    password="<YOUR_GOOGLE_PASSWORD>"
  )


  master_token = client.get_master_token()
  print("[*] Master token", master_token)

  """Now store master_token somewhere"""

  ```



  See [Contributing guidelines](CONTRIBUTING.md).
  This is an open-source project and all countribution is highly welcomed.



  Much credits go to [@rithvikvibhu](https://github.com/rithvikvibhu) for doing most of the heavy work like finding a way to
  extract master and access tokens
  (See his gist [here](https://gist.github.com/rithvikvibhu/952f83ea656c6782fbd0f1645059055d)).

  Also, thank you very much to the guys at `pychromecast` which provided the code required to scan devices in the network.

  [workflow-shield]: https://img.shields.io/github/actions/workflow/status/leikoilja/glocaltokens/linting-and-testing.yaml?branch=master
  [workflow]: https://github.com/leikoilja/glocaltokens/actions
  [pypi-shield]: https://img.shields.io/pypi/v/glocaltokens
  [pypi]: https://pypi.org/project/glocaltokens/
  [pepy-shield]: https://pepy.tech/badge/glocaltokens
  [pepy]: https://pepy.tech/project/glocaltokens
  [commits-shield]: https://img.shields.io/github/commit-activity/y/leikoilja/glocaltokens
  [commits]: https://github.com/leikoilja/glocaltokens/commits/master
  [pre-commit-shield]: https://img.shields.io/badge/pre--commit-enabled-brightgreen
  [pre-commit]: https://pre-commit.com/


pkgId: dccdc453e3cbe02fe77219bc94924f0c13b7a56a123efade965acb4fdfd89823
name: python-glom
arch: src
version: 23.3.0
epoch: 0
release: 1
summary: A declarative object transformer and formatter, for conglomerating nested data.
url: https://github.com/mahmoud/glom
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f9ef1323-ac1d-4af4-bd98-bb6355a73a6e
location_href: 00009996-python-glom/python-glom-23.3.0-1.src.rpm
checksum_type: sha256
description:
  *Restructuring data, the Python way*

  <a href="https://pypi.org/project/glom/"><img src="https://img.shields.io/pypi/v/glom.svg"></a>
  <a href="https://calver.org/"><img src="https://img.shields.io/badge/calver-YY.MM.MICRO-22bfda.svg"></a>

  <img width="30%" align="right" src="https://raw.githubusercontent.com/mahmoud/glom/master/docs/_static/comet.png">

  Real applications have real data, and real data nests. Objects inside
  of objects inside of lists of objects.

  glom is a new and powerful way to handle real-world data, featuring:

  * Path-based access for nested data structures
  * Readable, meaningful error messages
  * Declarative data transformation, using lightweight, Pythonic specifications
  * Built-in data exploration and debugging features

  All of that and more, available as a [fully-documented][rtd],
  pure-Python package, tested on Python 3.7+, as well as
  PyPy3. Installation is as easy as:

  ```
    pip install glom
  ```

  And when you install glom, you also get [the `glom` command-line
  interface][cli_rtd], letting you experiment at the console, but never limiting
  you to shell scripts:

  ```
  Usage: glom [FLAGS] [spec [target]]

  Command-line interface to the glom library, providing nested data access and data
  restructuring with the power of Python.

  Flags:

    --help / -h                     show this help message and exit
    --target-file TARGET_FILE       path to target data source (optional)
    --target-format TARGET_FORMAT   format of the source data (json or python) (defaults
                                    to 'json')
    --spec-file SPEC_FILE           path to glom spec definition (optional)
    --spec-format SPEC_FORMAT       format of the glom spec definition (json, python,
                                    python-full) (defaults to 'python')
    --indent INDENT                 number of spaces to indent the result, 0 to disable
                                    pretty-printing (defaults to 2)
    --debug                         interactively debug any errors that come up
    --inspect                       interactively explore the data

  ```

  Anything you can do at the command line readily translates to Python
  code, so you've always got a path forward when complexity starts to
  ramp up.




  ```python
  >>> data = {'a': {'b': {'c': 'd'}}}
  >>> data['a']['b']['c']
  'd'
  >>> data2 = {'a': {'b': None}}
  >>> data2['a']['b']['c']
  Traceback (most recent call last):
  ...
  TypeError: 'NoneType' object is not subscriptable
  ```


  ```python
  >>> glom(data, 'a.b.c')
  'd'
  >>> glom(data2, 'a.b.c')
  Traceback (most recent call last):
  ...
  PathAccessError: could not access 'c', index 2 in path Path('a', 'b', 'c'), got error: ...
  ```



  <img width="30%" align="right" src="https://raw.githubusercontent.com/mahmoud/glom/master/docs/_static/comet_multi.png">

  If all this seems interesting, continue exploring glom below:

  * [glom Tutorial][tutorial]
  * [Full API documentation at Read the Docs][rtd]
  * [Original announcement blog post (2018-05-09)][glom_announce]
  * [Frequently Asked Questions][faq]
  * [PyCon 2018 Lightning Talk (2018-05-11)][pycon_talk]

  All of the links above are overflowing with examples, but should you
  find anything about the docs, or glom itself, lacking, [please submit
  an issue][gh_issues]!

  [rtd]: https://glom.readthedocs.io
  [cli_rtd]: http://glom.readthedocs.io/en/latest/cli.html
  [tutorial]: https://glom.readthedocs.io/en/latest/tutorial.html
  [faq]: https://glom.readthedocs.io/en/latest/faq.html
  [glom_announce]: https://sedimental.org/glom_restructured_data.html
  [gh_issues]: https://github.com/mahmoud/glom/issues/
  [pycon_talk]: https://www.youtube.com/watch?v=bTAFl8P2DkE&t=18m07s

  In the meantime, just remember: When you've got nested data, glom it! ☄️


pkgId: ba3c8a3b1cb9fc74486c60c31e51c49257d6d51b0a4364332760180ab329b31d
name: python-glyphsLib
arch: src
version: 6.1.0
epoch: 0
release: 1
summary: A bridge from Glyphs source files (.glyphs) to UFOs
url: https://github.com/googlefonts/glyphsLib
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ee611c32-43c9-4261-928b-947fb216f1e1
location_href: 00003774-python-glyphsLib/python-glyphsLib-6.1.0-1.src.rpm
checksum_type: sha256
description:
  This Python 3.7+ library provides a bridge from Glyphs source files (.glyphs) to
  UFOs and Designspace files via `defcon <https://github.com/typesupply/defcon/>`__ and `designspaceLib <https://github.com/fonttools/fonttools>`__.
  The main methods for conversion are found in ``__init__.py``.
  Intermediate data can be accessed without actually writing UFOs, if
  needed.
  Write and return UFOs
  ^^^^^^^^^^^^^^^^^^^^^
  The following code will write UFOs and a Designspace file to disk.
      import glyphsLib
      master_dir = "master_ufos"
      ufos, designspace_path = glyphsLib.build_masters("MyFont.glyphs", master_dir)
  If you want to interpolate instances, please use fontmake instead. It uses this library under the hood when dealing with Glyphs files.
  Load UFO objects without writing
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      import glyphsLib
      ufos = glyphsLib.load_to_ufos("MyFont.glyphs")
  Read and write Glyphs data as Python objects
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      from glyphsLib import GSFont
      font = GSFont(glyphs_file)
      font.save(glyphs_file)
  The ``glyphsLib.classes`` module aims to provide an interface similar to
  Glyphs.app's `Python Scripting API <https://docu.glyphsapp.com>`__.
  Note that currently not all the classes and methods may be fully
  implemented. We try to keep up to date, but if you find something that
  is missing or does not work as expected, please open a issue.
     and what is not supported yet.
  Go back and forth between UFOs and Glyphs
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  1.  You can use the ``ufo2glyphs`` and ``glyphs2ufo`` command line scripts to
      round-trip your source files. By default, the scripts try to preserve as
      much metadata as possible.
          
          glyphs2ufo Example.glyphs
          
          ufo2glyphs Example.designspace
          
          ufo2glyphs Example-Regular.ufo Example-Bold.ufo
  2.  Without a designspace file, using for example the
      `Inria fonts by Black[Foundry] <https://github.com/BlackFoundry/InriaFonts/tree/master/masters/INRIA-SANS>`__:
          import glob
          from defcon import Font
          from glyphsLib import to_glyphs
          ufos = [Font(path) for path in glob.glob("*Italic.ufo")]
          
          ufos = sorted(ufos, key=lambda ufo: ufo.info.openTypeOS2WeightClass)
          font = to_glyphs(ufos)
          font.save("InriaSansItalic.glyphs")
      `Here is the resulting glyphs file <https://gist.githubusercontent.com/belluzj/cc3d43bf9b1cf22fde7fd4d2b97fdac4/raw/3222a2bfcf6554aa56a21b80f8fba82f1c5d7444/InriaSansItalic.glyphs>`__
  3.  With a designspace, using
      `Spectral from Production Type <https://github.com/productiontype/Spectral/tree/master/sources>`__:
          import glob
          from fontTools.designspaceLib import DesignSpaceDocument
          from glyphsLib import to_glyphs
          doc = DesignSpaceDocument()
          doc.read("spectral-build-roman.designspace")
          font = to_glyphs(doc)
          font.save("SpectralRoman.glyphs")
      `Here is the resulting glyphs file <https://gist.githubusercontent.com/belluzj/cc3d43bf9b1cf22fde7fd4d2b97fdac4/raw/3222a2bfcf6554aa56a21b80f8fba82f1c5d7444/SpectralRoman.glyphs>`__
  4.  In both programmatic cases, if you intend to go back to UFOs after modifying
      the file with Glyphs, you should use the ``minimize_ufo_diffs`` parameter to
      minimize the amount of diffs that will show up in git after the back and
      forth. To do so, the glyphsLib will add some bookkeeping values in various
      ``userData`` fields. For example, it will try to remember which GSClass came
      from groups.plist or from the feature file.
  The same option exists for people who want to do Glyphs->UFOs->Glyphs:
  ``minimize_glyphs_diffs``, which will add some bookkeeping data in UFO ``lib``.
  For example, it will keep the same UUIDs for Glyphs layers, and so will need
  to store those layer UUIDs in the UFOs.
      import glob
      import os
      from fontTools.designspaceLib import DesignSpaceDocument
      from glyphsLib import to_glyphs, to_designspace, GSFont
      doc = DesignSpaceDocument()
      doc.read("spectral-build-roman.designspace")
      font = to_glyphs(doc, minimize_ufo_diffs=True)
      doc2 = to_designspace(font, propagate_anchors=False)
      
      
      doc2.write(doc.path)
      for source in doc2.sources:
          path = os.path.join(os.path.dirname(doc.path), source.filename)
          
          source.font.save(path)
      font = GSFont("SpectralRoman.glyphs")
      doc = to_designspace(font, minimize_glyphs_diffs=True, propagate_anchors=False)
      font2 = to_glyphs(doc)
      
      font2.save(font.filepath)
  In practice there are always a few diffs on things that don't really make a
  difference, like optional things being added/removed or whitespace changes or
  things getting reordered...
  Make a release
  ^^^^^^^^^^^^^^
  Use ``git tag -a`` to make a new annotated tag, or ``git tag -s`` for a GPG-signed
  annotated tag, if you prefer.
  Name the new tag with with a leading ‘v’ followed by three ``MAJOR.MINOR.PATCH``
  digits, like in semantic versioning. Look at the existing tags for examples.
  In the tag message write some short release notes describing the changes since the
  previous tag.
  Finally, push the tag to the remote repository (e.g. assuming your upstream is
  called ``origin``):
      $ git push origin v0.4.3
  This will trigger the CI to build the distribution packages and upload them to
  the Python Package Index automatically, if all the tests pass successfully.


pkgId: 0e9d0b235ed829dd92cdf979d39e6f9784afd72cc923e2c2ce4f2f54ed3ebc89
name: python-gmpy2
arch: src
version: 2.1.5
epoch: 0
release: 1
summary: gmpy2 interface to GMP/MPIR, MPFR, and MPC for Python 2.7 and 3.5+
url: https://github.com/aleaxit/gmpy
rpm_license: LGPL-3.0+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c063775-1122-4fd0-b5ea-0d663827592a
location_href: 00003775-python-gmpy2/python-gmpy2-2.1.5-1.src.rpm
checksum_type: sha256
description:
  gmpy2 is an optimized, C-coded Python extension module that supports fast
  multiple-precision arithmetic.  gmpy2 is based on the original gmpy module.
  gmpy2 adds support for correctly rounded multiple-precision real arithmetic
  (using the MPFR library) and complex arithmetic (using the MPC library).


pkgId: c1d587604ac08257cc29a2c5ada2c8784b0fe2dae35dec191b9b00cbb4a556e9
name: python-gmqtt
arch: src
version: 0.6.12
epoch: 0
release: 1
summary: Client for MQTT protocol
url: https://github.com/wialon/gmqtt
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-56ca5870-9774-463a-a44e-b5c5a7746969
location_href: 00003776-python-gmqtt/python-gmqtt-0.6.12-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/gmqtt.svg)](https://badge.fury.io/py/gmqtt) [![Build Status](https://travis-ci.com/wialon/gmqtt.svg?branch=master)](https://travis-ci.com/wialon/gmqtt) [![codecov](https://codecov.io/gh/wialon/gmqtt/branch/master/graph/badge.svg)](https://codecov.io/gh/wialon/gmqtt)




  ![](./static/logo.png)



  The latest stable version is available in the Python Package Index (PyPi) and can be installed using
  ```bash
  pip3 install gmqtt
  ```





  Here is a very simple example that subscribes to the broker TOPIC topic and prints out the resulting messages:

  ```python
  import asyncio
  import os
  import signal
  import time

  from gmqtt import Client as MQTTClient


  import uvloop
  asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())


  STOP = asyncio.Event()


  def on_connect(client, flags, rc, properties):
      print('Connected')
      client.subscribe('TEST/#', qos=0)


  def on_message(client, topic, payload, qos, properties):
      print('RECV MSG:', payload)


  def on_disconnect(client, packet, exc=None):
      print('Disconnected')

  def on_subscribe(client, mid, qos, properties):
      print('SUBSCRIBED')

  def ask_exit(*args):
      STOP.set()

  async def main(broker_host, token):
      client = MQTTClient("client-id")

      client.on_connect = on_connect
      client.on_message = on_message
      client.on_disconnect = on_disconnect
      client.on_subscribe = on_subscribe

      client.set_auth_credentials(token, None)
      await client.connect(broker_host)

      client.publish('TEST/TIME', str(time.time()), qos=1)

      await STOP.wait()
      await client.disconnect()


  if __name__ == '__main__':
      loop = asyncio.get_event_loop()

      host = 'mqtt.flespi.io'
      token = os.environ.get('FLESPI_TOKEN')

      loop.add_signal_handler(signal.SIGINT, ask_exit)
      loop.add_signal_handler(signal.SIGTERM, ask_exit)

      loop.run_until_complete(main(host, token))
  ```


  gmqtt supports MQTT version 5.0 protocol


  Version 5.0 is used by default. If your broker does not support 5.0 protocol version and responds with proper CONNACK reason code, client will downgrade to 3.1 and reconnect automatically. Note, that some brokers just fail to parse the 5.0 format CONNECT packet, so first check manually if your broker handles this properly.
  You can also force version in connect method:
  ```python
  from gmqtt.mqtt.constants import MQTTv311
  client = MQTTClient('clientid')
  client.set_auth_credentials(token, None)
  await client.connect(broker_host, 1883, keepalive=60, version=MQTTv311)
  ```


  MQTT 5.0 protocol allows to include custom properties into packages, here is example of passing response topic property in published message:
  ```python

  TOPIC = 'testtopic/TOPIC'

  def on_connect(client, flags, rc, properties):
      client.subscribe(TOPIC, qos=1)
      print('Connected')

  def on_message(client, topic, payload, qos, properties):
      print('RECV MSG:', topic, payload.decode(), properties)

  async def main(broker_host, token):
      client = MQTTClient('asdfghjk')
      client.on_message = on_message
      client.on_connect = on_connect
      client.set_auth_credentials(token, None)
      await client.connect(broker_host, 1883, keepalive=60)
      client.publish(TOPIC, 'Message payload', response_topic='RESPONSE/TOPIC')

      await STOP.wait()
      await client.disconnect()
  ```

  Connect properties are passed to `Client` object as kwargs (later they are stored together with properties received from broker in `client.properties` field). See example below.
  * `session_expiry_interval` - `int` Session expiry interval in seconds. If the Session Expiry Interval is absent the value 0 is used. If it is set to 0, or is absent, the Session ends when the Network Connection is closed. If the Session Expiry Interval is 0xFFFFFFFF (max possible value), the Session does not expire.
  * `receive_maximum` - `int` The Client uses this value to limit the number of QoS 1 and QoS 2 publications that it is willing to process concurrently.
  * `user_property` - `tuple(str, str)` This property may be used to provide additional diagnostic or other information (key-value pairs).
  * `maximum_packet_size` - `int` The Client uses the Maximum Packet Size (in bytes) to inform the Server that it will not process packets exceeding this limit.

  Example:
  ```python
  client = gmqtt.Client("lenkaklient", receive_maximum=24000, session_expiry_interval=60, user_property=('myid', '12345'))
  ```


  This properties will be also sent in publish packet from broker, they will be passed to `on_message` callback.
  * `message_expiry_interval` - `int` If present, the value is the lifetime of the Application Message in seconds.
  * `content_type` - `unicode` UTF-8 Encoded String describing the content of the Application Message. The value of the Content Type is defined by the sending and receiving application.
  * `user_property` - `tuple(str, str)`
  * `subscription_identifier` - `int` (see subscribe properties) sent by broker
  * `topic_alias` - `int` First client publishes messages with topic string and kwarg topic_alias. After this initial message client can publish message with empty string topic and same topic_alias kwarg.

  Example:
  ```python
  def on_message(client, topic, payload, qos, properties):
      
      print('RECV MSG:', topic, payload, properties)

  client.publish('TEST/TIME', str(time.time()), qos=1, retain=True, message_expiry_interval=60, content_type='json')
  ```


  * `subscription_identifier` - `int` If the Client specified a Subscription Identifier for any of the overlapping subscriptions the Server MUST send those Subscription Identifiers in the message which is published as the result of the subscriptions.


  By default, connected MQTT client will always try to reconnect in case of lost connections. Number of reconnect attempts is unlimited.
  If you want to change this behaviour, do the following:
  ```python
  client = MQTTClient("client-id")
  client.set_config({'reconnect_retries': 10, 'reconnect_delay': 60})
  ```
  Code above will set number of reconnect attempts to 10 and delay between reconnect attempts to 1min (60s). By default `reconnect_delay=6` and  `reconnect_retries=-1` which stands for infinity.
  Note that manually calling `await client.disconnect()` will set `reconnect_retries` for 0, which will stop auto reconnect.


  You can define asynchronous on_message callback.
  Note that it must return valid PUBACK code (`0` is success code, see full list in [constants](gmqtt/mqtt/constants.py#L69))
  ```python
  async def on_message(client, topic, payload, qos, properties):
      pass
      return 0
  ```


  Check [examples directory](examples) for more use cases.


pkgId: c23b433157ff5fc26dbba5182cb89106b62ba3ab2961b96bca416d13b0fb1a62
name: python-gntp
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Growl Notification Transport Protocol for Python
url: http://github.com/kfdm/gntp/
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-81d1fcbf-7ec3-4e03-bcf3-bf59836ba4b6
location_href: 00003780-python-gntp/python-gntp-1.0.3-1.src.rpm
checksum_type: sha256
description:
  This is a Python library for working with the `Growl Notification
  Transport Protocol <http://www.growlforwindows.com/gfw/help/gntp.aspx>`_
  It should work as a dropin replacement for the older Python bindings


pkgId: b469d2d12777a90384ca4c13fb3a741eba159680155ae7809ffa684922f35085
name: python-gnupg
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: A Python wrapper for GnuPG
url: https://github.com/isislovecruft/python-gnupg
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-835b9b9c-f7ca-4c9a-9443-676cdc353abc
location_href: 00003781-python-gnupg/python-gnupg-2.3.1-1.src.rpm
checksum_type: sha256
description:
  This module allows easy access to GnuPG's key management, encryption and signature functionality from Python programs, by interacting with GnuPG through file descriptors. Input arguments are strictly checked and sanitised, and therefore this module should be safe to use in networked applications requiring direct user input. It is intended for use on Windows, MacOS X, BSD, or Linux, with Python 2.6, Python 2.7, Python 3.3, Python 3.4, or PyPy.


pkgId: b273ad836039318fa3eada26a5e37740173e741e132c5634d92b2e014b92b13c
name: python-google-api-core
arch: src
version: 2.11.0
epoch: 0
release: 1
summary: Google API client core library
url: https://github.com/googleapis/python-api-core
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0201ca88-d8ce-4557-a62e-3c00d2b3c997
location_href: 00008909-python-google-api-core/python-google-api-core-2.11.0-1.src.rpm
checksum_type: sha256
description:
  |pypi| |versions|
  This library is not meant to stand-alone. Instead it defines
  common helpers used by all Google API clients. For more information, see the
  `documentation`_.


pkgId: 79503d714ea180db1b4eab390a51c4f8cbcb1a6f9ade4b99f7404a4167c8b660
name: python-google-apitools
arch: src
version: 0.5.32
epoch: 0
release: 1
summary: client libraries for humans
url: http://github.com/google/apitools
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8d96259f-38f1-4571-a132-7481e3297371
location_href: 00009613-python-google-apitools/python-google-apitools-0.5.32-1.src.rpm
checksum_type: sha256
description:
  |pypi| |build| |coverage|
  ``google-apitools`` is a collection of utilities to make it easier to build
  client-side tools, especially those that talk to Google APIs.
  **NOTE**: This library is stable, but in maintenance mode, and not under
  active development. However, any bugs or security issues will be fixed
  promptly.


pkgId: e3f069537836f3c16f61d5e9b5fd1ad18425bcc5ad0580092e9ba610ca9ef507
name: python-google-auth
arch: src
version: 2.17.2
epoch: 0
release: 1
summary: Google Authentication Library
url: https://github.com/googleapis/google-auth-library-python
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fcaf3bb-ac50-4a1c-b179-a16753795dcb
location_href: 00008915-python-google-auth/python-google-auth-2.17.2-1.src.rpm
checksum_type: sha256
description:
  |pypi|
  This library simplifies using Google's various server-to-server authentication
  mechanisms to access Google APIs.


pkgId: a2ea3863442294d9fa9ac249493c601348347e2b6ffad9b64f1030621688f2c9
name: python-google-auth-httplib2
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Google Authentication Library: httplib2 transport
url: https://github.com/GoogleCloudPlatform/google-auth-library-python-httplib2
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4bef2758-564d-47d4-8dd4-e7d3292ff379
location_href: 00008978-python-google-auth-httplib2/python-google-auth-httplib2-0.1.0-1.src.rpm
checksum_type: sha256
description:
  |pypi|
  This library provides an `httplib2`_ transport for `google-auth`_.
      and insecure usage of TLS. Using it is highly discouraged. This
      library is intended to help existing users of ``oauth2client`` migrate to
      ``google-auth``.


pkgId: 6fac6dafdd07ec6dbba85607cb05e2171642e21f974a8fe8b939a355d19d58df
name: python-google-cloud
arch: src
version: 0.34.0
epoch: 0
release: 1
summary: API Client library for Google Cloud
url: https://github.com/GoogleCloudPlatform/google-cloud-python
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-236858ca-886d-4b21-91f5-166370fb104a
location_href: 00009323-python-google-cloud/python-google-cloud-0.34.0-1.src.rpm
checksum_type: sha256
description:
      Python idiomatic client for `Google Cloud Platform`_ services.
      WARNING: The google-cloud Python package is deprecated. On June 18, 2018,
      this package will no longer install any other packages. Please install the
      `product-specific google-cloud-* packages`__ needed for your application.
  |pypi| |circleci| |appveyor| |coverage| |versions|
  -  `Homepage`_
  -  `API Documentation`_
  -  `Read The Docs Documentation`_


pkgId: 18f512d104f356afc7ce48f8b0d79dffa95045c663ddc013cc73bdbc3ef96824
name: python-google-cloud-audit-log
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Google Cloud Audit Protos
url: https://github.com/googleapis/python-audit-log
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-91e087ff-0a12-4652-9452-e063552423a9
location_href: 00009600-python-google-cloud-audit-log/python-google-cloud-audit-log-0.2.5-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/google-cloud-audit-log.svg)](https://pypi.org/project/google-cloud-audit-log/)


  The python classes generated from the `google/cloud/audit`
  protos in the [googleapis/googleapis](https://github.com/googleapis/googleapis/tree/master/google/cloud/audit) repository.


pkgId: bd28ec9e5c068b5dc2c2a36713e38d971f2d6c807d82186b6452b2ecad3c30ba
name: python-google-cloud-dataflow
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Google Cloud Dataflow SDK for Python, based on Apache Beam
url: https://cloud.google.com/dataflow/
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d16e12ec-8fd6-43df-9022-4721a5440691
location_href: 00012933-python-google-cloud-dataflow/python-google-cloud-dataflow-2.5.0-1.src.rpm
checksum_type: sha256
description:
  Apache Beam is an open-source, unified programming model for
  describing large-scale data processing pipelines. This redistribution of
  Apache Beam is targeted for executing batch Python pipelines on
  Google Cloud Dataflow.


pkgId: 30d2ef1b86f666d65b6070ef8fc7f975a636cc58ceed89722512c8d0bc4dc448
name: python-google-cloud-runtimeconfig
arch: src
version: 0.33.2
epoch: 0
release: 1
summary: Google Cloud RuntimeConfig API client library
url: https://github.com/googleapis/python-runtimeconfig
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7720893e-c3e4-488d-aca1-a2634d153ff7
location_href: 00011389-python-google-cloud-runtimeconfig/python-google-cloud-runtimeconfig-0.33.2-1.src.rpm
checksum_type: sha256
description:
  |preview| |pypi| |versions|
  `Google Cloud Runtime Configurator API`_:
  - `Client Library Documentation`_
  - `Product Documentation`_


pkgId: ccfbc764d7270f2a37d73531fd1b1ebdf5c3961ace4bdb0649e1847dcfd76618
name: python-google-cloud-runtimeconfig-help
arch: noarch
version: 0.33.2
epoch: 0
release: 1
summary: Development documents and examples for google-cloud-runtimeconfig
url: https://github.com/googleapis/python-runtimeconfig
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7720893e-c3e4-488d-aca1-a2634d153ff7
rpm_sourcerpm: python-google-cloud-runtimeconfig-0.33.2-1.src.rpm
checksum_type: sha256
description:
  |preview| |pypi| |versions|
  `Google Cloud Runtime Configurator API`_:
  - `Client Library Documentation`_
  - `Product Documentation`_

location_href:
  00011389-python-google-cloud-runtimeconfig/python-google-cloud-runtimeconfig-help-0.33.2-1.noarch.rpm


pkgId: 589dac49321e0c26381c27b186203fd1ae34be3bbe4162ab8b657f9e4b5ed303
name: python-google-crc32c
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: A python wrapper of the C library 'Google CRC32C'
url: https://github.com/googleapis/python-crc32c
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5acb84ef-1d5e-4888-963c-25dfb25e330b
location_href: 00008995-python-google-crc32c/python-google-crc32c-1.5.0-1.src.rpm
checksum_type: sha256
description:
  ![GA](https://img.shields.io/badge/support-GA-gold.svg) [<img src="https://img.shields.io/pypi/v/google-crc32c.svg">](https://pypi.org/project/google-crc32c) ![Python Versions](https://img.shields.io/pypi/pyversions/google-crc32c)

  This package wraps the [`google/crc32c`](https://github.com/google/crc32c)
  hardware-based implementation of the CRC32C hashing algorithm. Multiple wheels
  are distributed as well as source. If a wheel is not published for the python
  version and platform you are using, you will need to compile crc32c using a
  C toolchain.



  Wheels are currently published for Python 3.7, 3.8, 3.9, 3.10, 3.11 and
  pypy-3.7 for multiple architectures. For information on building your own,
  please view [BUILDING.md](BUILDING.md).




  Wheels are published for the following platforms / architectures:

  - `manylinux2010` platform, `x86_64` and `1686` architectures
  - `manylinux2014` platform, `aarch64` architecture



  - `manylinux1` platform, `x86_64` architecture wheels will be built until
    2021-12-31, when the PyPA group drops support for the `manylinux1` image.
    See: https://github.com/pypa/manylinux/issues/994




  Wheels are published for `x86_64` and `universal2` architectures.




  Wheels are published for `win32` and `win_amd64` architectures.


pkgId: 86d5bec1979bad3431848e417f544f3a5cc4a64f9a9cb29d30281e9eb5547b79
name: python-google-crc32c-debuginfo
arch: aarch64
version: 1.5.0
epoch: 0
release: 1
summary: Debug information for package python-google-crc32c
url: https://github.com/googleapis/python-crc32c
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5acb84ef-1d5e-4888-963c-25dfb25e330b
rpm_sourcerpm: python-google-crc32c-1.5.0-1.src.rpm
location_href: 00008995-python-google-crc32c/python-google-crc32c-debuginfo-1.5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-google-crc32c.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: faf5f783a23220b3812e05939f274a8af36986a742db377c1273168a6cce1df3
name: python-google-crc32c-debugsource
arch: aarch64
version: 1.5.0
epoch: 0
release: 1
summary: Debug sources for package python-google-crc32c
url: https://github.com/googleapis/python-crc32c
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5acb84ef-1d5e-4888-963c-25dfb25e330b
rpm_sourcerpm: python-google-crc32c-1.5.0-1.src.rpm
location_href: 00008995-python-google-crc32c/python-google-crc32c-debugsource-1.5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-google-crc32c.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 58eae83d7eea282ec90120e06c5c0f6c99a723af158444ad57ef44efd3f1fda4
name: python-google-gax
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Google API Extensions
url: https://github.com/googleapis/gax-python
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7fc904dc-df38-4cf5-8cd7-95ffa7a2e2ed
location_href: 00010523-python-google-gax/python-google-gax-0.16.0-1.src.rpm
checksum_type: sha256
description:
  This project has been deprecated and will no longer be developed. It has
  been wholly replaced by `google-api-core`_.


pkgId: 755b7efaf62701c9d70e5a874a223267b8fcce6445e954074210c0d22eabdae4
name: python-google-i18n-address
arch: src
version: 2.5.2
epoch: 0
release: 1
summary: Address validation helpers for Google's i18n address database
url: https://github.com/mirumee/google-i18n-address
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-97377cab-7999-4b5b-8220-333823e45886
location_href: 00003791-python-google-i18n-address/python-google-i18n-address-2.5.2-1.src.rpm
checksum_type: sha256
description:
  |codecov.io| |Circle CI| |PyPi downloads| |requires.io| |PyPi version| |PyPi pythons| |GitHub|
  This package contains a copy of `Google's i18n
  address <https://chromium-i18n.appspot.com/ssl-address>`_ metadata repository
  that contains great data but comes with no uptime guarantees.
  Contents of this package will allow you to programatically build address
  forms that adhere to rules of a particular region or country, validate
  local addresses and format them to produce a valid address label for
  delivery.
  The package also contains a Python interface for address validation.


pkgId: 77b22c69d24acf1d192b5cdf3d6c18edfacb3e3ded32ffd93660779cdbd9236c
name: python-google-reauth
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Google Reauth Library
url: https://github.com/Google/google-reauth-python
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e429ff7b-df9a-4a9e-8aee-13f522ee8943
location_href: 00010424-python-google-reauth/python-google-reauth-0.1.1-1.src.rpm
checksum_type: sha256
description:
  |build| |pypi|
  This library provides Reauth support to Google's authentication libraries for
  Python. Reauth allows using two-factor authentication for end-user credentials.
  Other than for reference purposes, this library is of little use to non-Google
  developers.


pkgId: fc7d9a6aa002256a95b27ccab4011adb0a3c315d6b0e2c308e3c4e284125ff89
name: python-google_images_download
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: Python Script to download hundreds of images from 'Google Images'. It is a ready-to-run code!
url: https://github.com/hardikvasa/google-images-download
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c735a4b4-b329-40f0-be27-3656a8433605
location_href: 00012395-python-google-images-download/python-google_images_download-2.8.0-1.src.rpm
checksum_type: sha256
description:
  * `Documentation Homepage <https://google-images-download.readthedocs.io/en/latest/index.html>`__
  * `Installation <https://google-images-download.readthedocs.io/en/latest/installation.html>`__
  * `Input arguments <https://google-images-download.readthedocs.io/en/latest/arguments.html>`__
  * `Examples and Code Samples <https://google-images-download.readthedocs.io/en/latest/examples.html#>`__


pkgId: 84f03d96d64a04b225b37332f1ec336d18b9527d7c43b28da25d68d29c79606b
name: python-googleanalytics
arch: src
version: 0.26.0
epoch: 0
release: 1
summary: A wrapper for the Google Analytics API.
url: https://github.com/debrouwere/google-analytics/
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f9fb438a-fbfa-41fc-b0da-dcee527700da
location_href: 00012924-python-googleanalytics/python-googleanalytics-0.26.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status|
  ``google-analytics`` takes the pain out of working with the Google
  Analytics reporting APIs. It supports both the Core and the Real Time
  API. It is written in Python but there's also a full-featured
  command-line interface.
  -  **Authentication.** OAuth2 is a bit of a pain and we've made it
     easier, both for interactive use and for `server
     applications <https://github.com/debrouwere/google-analytics/blob/master/examples/server.py>`__.
     We can also save your credentials in the operating system's keychain
     if you want to.
  -  **Querying.** Easier to query per week, month or year. Query using
     metric IDs or using their full names, whichever you think is nicer.
     Work with both the Core and the Real Time APIs.
  -  **Reporting.** Generate reports from the command-line. Optionally
     describe reports and queries in `easy-to-read and easy-to-write YAML
     files <https://github.com/debrouwere/google-analytics/blob/master/examples/query.yml>`__.
     Reports in Python work better too: iterate through the entire report
     or column-per-column.
  -  **Exploration.** Traverse the account hierarchy from account to
     webproperty to profile to dimensions, both programmatically and with
     the included command-line interface.
  -  **Exports.** Clean JSON and CSV – as well as
     `Pandas <http://pandas.pydata.org/>`__ data frames – so you can
     analyze the data in anything from Excel to R.
  This package is built on top of `Google's own API client for
  Python <https://developers.google.com/api-client-library/python/start/installation>`__.


pkgId: 7e9f3e5cdfde01de9b3dd3f6a01ea1bf434bee50dbfd0376d93cef2fed0c5c74
name: python-googleapis-common-protos
arch: src
version: 1.59.0
epoch: 0
release: 1
summary: Common protobufs used in Google APIs
url: https://github.com/googleapis/python-api-common-protos
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f7f91c0-4c64-4155-8dd2-a9aeaac3a95e
location_href: 00008934-python-googleapis-common-protos/python-googleapis-common-protos-1.59.0-1.src.rpm
checksum_type: sha256
description:
  googleapis-common-protos contains the python classes generated from the common
  protos in the `googleapis/googleapis <https://github.com/googleapis/googleapis>`_ repository.


pkgId: 3985f1713dc5b05184d95971aee389f908aa82df1237ab1694e9e99b959b0969
name: python-googlemaps
arch: src
version: 4.10.0
epoch: 0
release: 1
summary: Python client library for Google Maps Platform
url: https://github.com/googlemaps/google-maps-services-python
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8fc12310-93c5-4fab-be82-cfc61541f8b7
location_href: 00009673-python-googlemaps/python-googlemaps-4.10.0-1.src.rpm
checksum_type: sha256
description:
  ![Test](https://github.com/googlemaps/google-maps-services-js/workflows/Test/badge.svg)
  ![Release](https://github.com/googlemaps/google-maps-services-js/workflows/Release/badge.svg)
  [![codecov](https://codecov.io/gh/googlemaps/google-maps-services-python/branch/master/graph/badge.svg)](https://codecov.io/gh/googlemaps/google-maps-services-python)
  [![PyPI version](https://badge.fury.io/py/googlemaps.svg)](https://badge.fury.io/py/googlemaps)
  ![PyPI - Downloads](https://img.shields.io/pypi/dd/googlemaps)
  ![GitHub contributors](https://img.shields.io/github/contributors/googlemaps/google-maps-services-python)

  Use Python? Want to geocode something? Looking for directions?
  Maybe matrices of directions? This library brings the Google Maps Platform Web
  Services to your Python application.
  The Python Client for Google Maps Services is a Python Client library for the following Google Maps
  APIs:
   - Directions API
   - Distance Matrix API
   - Elevation API
   - Geocoding API
   - Geolocation API
   - Time Zone API
   - Roads API
   - Places API
   - Maps Static API
   - Address Validation API
  Keep in mind that the same [terms and conditions](https://developers.google.com/maps/terms) apply
  to usage of the APIs when they're accessed through this library.

  This library is community supported. We're comfortable enough with the stability and features of
  the library that we want you to build real production applications on it. We will try to support,
  through Stack Overflow, the public and protected surface of the library and maintain backwards
  compatibility in the future; however, while the library is in version 0.x, we reserve the right
  to make backwards-incompatible changes. If we do remove some functionality (typically because
  better functionality exists or if the feature proved infeasible), our intention is to deprecate
  and give developers a year to update their code.
  If you find a bug, or have a feature suggestion, please log an issue. If you'd like to
  contribute, please read contribute.

   - Python 3.5 or later.
   - A Google Maps API key.

  Each Google Maps Web Service request requires an API key or client ID. API keys
  are generated in the 'Credentials' page of the 'APIs & Services' tab of [Google Cloud console](https://console.cloud.google.com/apis/credentials).
  For even more information on getting started with Google Maps Platform and generating/restricting an API key, see [Get Started with Google Maps Platform](https://developers.google.com/maps/gmp-get-started) in our docs.
  **Important:** This key should be kept secret on your server.

      $ pip install -U googlemaps
  Note that you will need requests 2.4.0 or higher if you want to specify connect/read timeouts.

  This example uses the Geocoding API and the Directions API with an API key:
  ```python
  import googlemaps
  from datetime import datetime
  gmaps = googlemaps.Client(key='Add Your Key here')

  geocode_result = gmaps.geocode('1600 Amphitheatre Parkway, Mountain View, CA')

  reverse_geocode_result = gmaps.reverse_geocode((40.714224, -73.961452))

  now = datetime.now()
  directions_result = gmaps.directions("Sydney Town Hall",
                                       "Parramatta, NSW",
                                       mode="transit",
                                       departure_time=now)

  addressvalidation_result =  gmaps.addressvalidation(['1600 Amphitheatre Pk'],
                                                      regionCode='US',
                                                      locality='Mountain View',
                                                      enableUspsCass=True)
  ```
  For more usage examples, check out [the tests](https://github.com/googlemaps/google-maps-services-python/tree/master/tests).


  Automatically retry when intermittent failures occur. That is, when any of the retriable 5xx errors
  are returned from the API.

      
      $ pip install nox
      
      $ nox
      
      $ nox -e docs
      
      $ nox -e docs && mv docs/_build/html generated_docs && git clean -Xdi && git checkout gh-pages

  [Documentation for the `google-maps-services-python` library](https://googlemaps.github.io/google-maps-services-python/docs/index.html)

  - [Get Started with Google Maps Platform](https://developers.google.com/maps/gmp-get-started)
  - [Generating/restricting an API key](https://developers.google.com/maps/gmp-get-started#api-key)
  - [Authenticating with a client ID](https://developers.google.com/maps/documentation/directions/get-api-key#client-id)

  - [Google Maps Platform web services](https://developers.google.com/maps/apis-by-platform#web_service_apis)
  - [Directions API](https://developers.google.com/maps/documentation/directions/)
  - [Distance Matrix API](https://developers.google.com/maps/documentation/distancematrix/)
  - [Elevation API](https://developers.google.com/maps/documentation/elevation/)
  - [Geocoding API](https://developers.google.com/maps/documentation/geocoding/)
  - [Geolocation API](https://developers.google.com/maps/documentation/geolocation/)
  - [Time Zone API](https://developers.google.com/maps/documentation/timezone/)
  - [Roads API](https://developers.google.com/maps/documentation/roads/)
  - [Places API](https://developers.google.com/places/)
  - [Maps Static API](https://developers.google.com/maps/documentation/maps-static/)

  - [Report an issue](https://github.com/googlemaps/google-maps-services-python/issues)
  - [Contribute](https://github.com/googlemaps/google-maps-services-python/blob/master/CONTRIB.md)
  - [StackOverflow](http://stackoverflow.com/questions/tagged/google-maps)

  All notable changes to this project will be documented in this file.


  - Add support for Maps Static API (#344)


  - Adding support for passing in `experience_id` to Client class (#338)


  - Python 2 is no longer supported
  - Removed place fields: `alt_id`, `id`, `reference`, and `scope`. Read more about this at https://developers.google.com/maps/deprecations.


  - `APIError.__str__` should always return a str (#328)


  - deprecation warning for place fields: `alt_id`, `id`, `reference`, and `scope`. Read more about this at https://developers.google.com/maps/deprecations.


  - Tests for distribution tar as part of CI
  - Support for subfields such as `geometry/location` and `geometry/viewport` in Places.


  - Added changelog to manifest


  - Switched build system to use [nox](https://nox.thea.codes/en/stable/), pytest, and codecov. Added Python 3.7 to test framework.
  - Set precision of truncated latitude and longitude floats [to 8 decimals](https://github.com/googlemaps/google-maps-services-python/pull/301) instead of 6.
  - Minimum version of requests increased.
  - Session token parameter [added](https://github.com/googlemaps/google-maps-services-python/pull/244) to `place()`.
  - Fixed issue where headers in `request_kwargs` were being overridden.

  - Automation for PyPi uploads.
  - Long description to package.
  - Added tests to manifest and tarball.

  - Removed places `places_autocomplete_session_token` which can be replaced with `uuid.uuid4().hex`.
  - Removed deprecated `places_radar`.
  **Note:** Start of changelog is 2019-08-27, [v3.0.2].
  [Unreleased]: https://github.com/googlemaps/google-maps-services-python/compare/4.2.0...HEAD
  [v4.2.0]: https://github.com/googlemaps/google-maps-services-python/compare/4.1.0...4.2.0
  [v4.1.0]: https://github.com/googlemaps/google-maps-services-python/compare/4.0.0...4.1.0
  [v4.0.0]: https://github.com/googlemaps/google-maps-services-python/compare/3.1.4...4.0.0
  [v3.1.4]: https://github.com/googlemaps/google-maps-services-python/compare/3.1.3...3.1.4
  [v3.1.3]: https://github.com/googlemaps/google-maps-services-python/compare/3.1.2...3.1.3
  [v3.1.2]: https://github.com/googlemaps/google-maps-services-python/compare/3.1.1...3.1.2
  [v3.1.1]: https://github.com/googlemaps/google-maps-services-python/compare/3.1.0...3.1.1
  [v3.1.0]: https://github.com/googlemaps/google-maps-services-python/compare/3.0.2...3.1.0
  [v3.0.2]: https://github.com/googlemaps/google-maps-services-python/compare/3.0.1...3.0.2
  [v3.0.1]: https://github.com/googlemaps/google-maps-services-python/compare/3.0.0...3.0.1
  [v3.0.0]: https://github.com/googlemaps/google-maps-services-python/compare/2.5.1...3.0.0


pkgId: fd5e3f6f874eb87bc533e4972e71a9ab0e3efa4ec687c5bd106ed0100af0ae24
name: python-googletrans
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Free Google Translate API for Python. Translates totally free of charge.
url: https://github.com/ssut/py-googletrans
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5c8e45e0-9b86-4c1f-9af2-3be109f2e8e1
location_href: 00003792-python-googletrans/python-googletrans-3.0.0-1.src.rpm
checksum_type: sha256
description:
  |GitHub license| |travis status| |Documentation Status| |PyPI version|
  |Coverage Status| |Code Climate|
  Googletrans is a **free** and **unlimited** python library that
  implemented Google Translate API. This uses the `Google Translate Ajax
  API <https://translate.google.com>`__ to make calls to such methods as
  detect and translate.
  Compatible with Python 3.6+.
  For details refer to the `API
  Documentation <https://py-googletrans.readthedocs.io/en/latest>`__.


pkgId: 07ddaeaacb04d8643e12817975f6e9c59579ae9ac7f7b5ac8fd0c963627186c2
name: python-gorilla
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Convenient approach to monkey patching
url: https://github.com/christophercrouzet/gorilla
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d500dd90-9647-4a2a-89d3-86daabe0458c
location_href: 00009545-python-gorilla/python-gorilla-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Gorilla is a Python library that provides a convenient approach to monkey
  patching.
  Monkey patching is the process of **modifying module and class attributes at
  runtime** with the purpose of replacing or extending third-party code.
  Although *not* a recommended practice, it is sometimes useful to fix or modify
  the behaviour of a piece of code from a third-party library, or to extend its
  public interface while making the additions feel like they are built-in into
  the library.
  The Python language makes monkey patching extremely easy but the advantages of
  Gorilla are multiple, not only in assuring a **consistent behaviour** on both
  Python 2 and Python 3 versions, but also in preventing common source of errors,
  and making the process both **intuitive and convenient** even when faced with
  *large* numbers of patches to create.


pkgId: 28432cc839d8d9e58ce0a10d8c16a0d0517755cf593de49a55a7bf8ce4cd2133
name: python-goslate
arch: src
version: 1.5.4
epoch: 0
release: 1
summary: Goslate: Free Google Translate API
url: https://pypi.python.org/pypi/goslate
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-af9a4b60-dcd1-47a6-b57b-5cac92b5ef88
location_href: 00009970-python-goslate/python-goslate-1.5.4-1.src.rpm
checksum_type: sha256
description:
  The basic usage is simple:
   >>> import goslate
   >>> gs = goslate.Goslate()
   >>> print(gs.translate('hello world', 'de'))
   hallo welt


pkgId: 955dc9546233d3eb8324541a6aeaf92349e3cbd019a68310443b63bfe1de5045
name: python-gower
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Python implementation of Gowers distance, pairwise between records in two data sets
url: https://github.com/wwwjk366/gower
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b56613c0-ffec-465e-913c-a06e3788339f
location_href: 00013019-python-gower/python-gower-0.1.2-1.src.rpm
checksum_type: sha256
description:
  <!-- badges: start -->
  [![Build Status](https://travis-ci.com/wwwjk366/gower.svg?branch=master)](https://travis-ci.com/wwwjk366/gower)
  [![PyPI version](https://badge.fury.io/py/gower.svg)](https://pypi.org/project/gower/)
  [![Downloads](https://pepy.tech/badge/gower/month)](https://pepy.tech/project/gower/month)
  <!-- badges: end -->



  Gower's distance calculation in Python. Gower Distance is a distance measure that can be used to calculate distance between two entity whose attribute has a mixed of categorical and numerical values. [Gower (1971) A general coefficient of similarity and some of its properties. Biometrics 27 857–874.](https://www.jstor.org/stable/2528823?seq=1)

  More details and examples can be found on my personal website here:(https://www.thinkdatascience.com/post/2019-12-16-introducing-python-package-gower/)

  Core functions are wrote by [Marcelo Beckmann](https://sourceforge.net/projects/gower-distance-4python/files/).





  ```
  pip install gower
  ```



  ```python
  import numpy as np
  import pandas as pd
  import gower

  Xd=pd.DataFrame({'age':[21,21,19, 30,21,21,19,30,None],
  'gender':['M','M','N','M','F','F','F','F',None],
  'civil_status':['MARRIED','SINGLE','SINGLE','SINGLE','MARRIED','SINGLE','WIDOW','DIVORCED',None],
  'salary':[3000.0,1200.0 ,32000.0,1800.0 ,2900.0 ,1100.0 ,10000.0,1500.0,None],
  'has_children':[1,0,1,1,1,0,0,1,None],
  'available_credit':[2200,100,22000,1100,2000,100,6000,2200,None]})
  Yd = Xd.iloc[1:3,:]
  X = np.asarray(Xd)
  Y = np.asarray(Yd)

  ```



  ```python
  gower.gower_matrix(X)
  ```




      array([[0.        , 0.3590238 , 0.6707398 , 0.31787416, 0.16872811,
              0.52622986, 0.59697855, 0.47778758,        nan],
             [0.3590238 , 0.        , 0.6964303 , 0.3138769 , 0.523629  ,
              0.16720603, 0.45600235, 0.6539635 ,        nan],
             [0.6707398 , 0.6964303 , 0.        , 0.6552807 , 0.6728013 ,
              0.6969697 , 0.740428  , 0.8151941 ,        nan],
             [0.31787416, 0.3138769 , 0.6552807 , 0.        , 0.4824794 ,
              0.48108295, 0.74818605, 0.34332284,        nan],
             [0.16872811, 0.523629  , 0.6728013 , 0.4824794 , 0.        ,
              0.35750175, 0.43237334, 0.3121036 ,        nan],
             [0.52622986, 0.16720603, 0.6969697 , 0.48108295, 0.35750175,
              0.        , 0.2898751 , 0.4878362 ,        nan],
             [0.59697855, 0.45600235, 0.740428  , 0.74818605, 0.43237334,
              0.2898751 , 0.        , 0.57476616,        nan],
             [0.47778758, 0.6539635 , 0.8151941 , 0.34332284, 0.3121036 ,
              0.4878362 , 0.57476616, 0.        ,        nan],
             [       nan,        nan,        nan,        nan,        nan,
                     nan,        nan,        nan,        nan]], dtype=float32)




  ```python
  gower.gower_topn(Xd.iloc[0:2,:], Xd.iloc[:,], n = 5)
  ```




      {'index': array([4, 3, 1, 7, 5]),
       'values': array([0.16872811, 0.31787416, 0.3590238 , 0.47778758, 0.52622986],
             dtype=float32)}


pkgId: c131496388333598b060ef0d0d6809c353ea26342d2e4762b9c232cfc1fc1550
name: python-gpaw
arch: src
version: 22.8.0
epoch: 0
release: 1
summary: GPAW: DFT and beyond within the projector-augmented wave method
url: https://wiki.fysik.dtu.dk/gpaw
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f57f5fc-b33f-4d56-b74c-30df30d34395
location_href: 00003793-python-gpaw/python-gpaw-22.8.0-1.src.rpm
checksum_type: sha256
description:
  GPAW is a density-functional theory (DFT) Python_ code based on the
  projector-augmented wave (PAW) method and the atomic simulation environment
  (ASE_). It uses plane-waves, atom-centered basis-functions or real-space
  uniform grids combined with multigrid methods.
  Webpage: http://wiki.fysik.dtu.dk/gpaw


pkgId: b0161b70efab94371ce66cd26d4c4bd507006ceea5ef680f96af3ca3ccf32642
name: python-gphoto2
arch: src
version: 2.3.4
epoch: 0
release: 1
summary: Python interface to libgphoto2
url: https://github.com/jim-easterbrook/python-gphoto2
rpm_license: GNU GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1da7656c-8882-457b-b1ca-2dc132d172c7
location_href: 00003797-python-gphoto2/python-gphoto2-2.3.4-1.src.rpm
checksum_type: sha256
description:
  python-gphoto2 is a comprehensive Python interface (or binding) to libgphoto2_.
  It is built using SWIG_ to automatically generate the interface code.
  This gives direct access to nearly all the libgphoto2 functions_, but sometimes in a rather un-Pythonic manner.
  Other Python bindings to libgphoto2_ are available:
  piggyphoto_ uses ctypes_ (included in standard Python installations) to interface to the library.
  The gphoto2 source tree includes some `Python bindings`_ which also use ctypes_.
  `gphoto2-cffi`_ uses cffi_.


pkgId: bba218b543c0ff92f39466e7f0debbd50a38e777c55293fee8a46c0a955cd06c
name: python-gprof2dot
arch: src
version: 2022.7.29
epoch: 0
release: 1
summary: Generate a dot graph from the output of several profilers.
url: https://github.com/jrfonseca/gprof2dot
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7fd0f6af-c92b-47fb-9f69-b55c52171c42
location_href: 00010215-python-gprof2dot/python-gprof2dot-2022.7.29-1.src.rpm
checksum_type: sha256
description:
  This is a Python script to convert the output from many profilers into a [dot graph](http://www.graphviz.org/doc/info/lang.html).

  It can:

    * read output from:
      * [Linux perf](http://perf.wiki.kernel.org/)
      * [Valgrind's callgrind tool](http://valgrind.org/docs/manual/cl-manual.html)
      * [oprofile](http://oprofile.sourceforge.net/)
      * [sysprof](http://www.daimi.au.dk/~sandmann/sysprof/)
      * [xperf](https://msdn.microsoft.com/en-us/windows/hardware/commercialize/test/wpt/index)
      * [VTune Amplifier XE](http://software.intel.com/en-us/intel-vtune-amplifier-xe)
      * [Very Sleepy](http://www.codersnotes.com/sleepy/)
      * [python profilers](http://docs.python.org/2/library/profile.html#profile-stats)
      * [Java's HPROF](http://docs.oracle.com/javase/7/docs/technotes/samples/hprof.html)
      * prof, [gprof](https://sourceware.org/binutils/docs/gprof/)
      * [DTrace](https://en.wikipedia.org/wiki/DTrace)
    * prune nodes and edges below a certain threshold;
    * use an heuristic to propagate time inside mutually recursive functions;
    * use color efficiently to draw attention to hot-spots;
    * work on any platform where Python and Graphviz is available, i.e, virtually anywhere.

  **If you want an interactive viewer for the graphs generated by _gprof2dot_, check [xdot.py](https://github.com/jrfonseca/xdot.py).**




  _gprof2dot_ currently fulfills my needs, and I have little or no time for its
  maintenance.  So I'm afraid that any requested features are unlikely to be
  implemented, and I might be slow processing issue reports or pull requests.

  [![Build Status](https://github.com/jrfonseca/gprof2dot/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/jrfonseca/gprof2dot/actions/workflows/build.yml)




  This is the result from the [example data](http://linuxgazette.net/100/misc/vinayak/overall-profile.txt) in the [Linux Gazette article](http://linuxgazette.net/100/vinayak.html) with the default settings:

  <!-- pngquant --speed=1 --ordered  --quality 0-85 ... -->
  ![Sample](https://raw.githubusercontent.com/jrfonseca/gprof2dot/cf98cc0b5eae9fcb896a6f92e9bc2bcb27666515/sample.png)



    * [Python](http://www.python.org/download/): known to work with version 2.7 and 3.3; it will most likely _not_ work with earlier releases.
    * [Graphviz](http://www.graphviz.org/Download.php): tested with version 2.26.3, but should work fine with other versions.



    * Download and install [Python for Windows](http://www.python.org/download/)
    * Download and install [Graphviz for Windows](http://www.graphviz.org/Download_windows.php)



  On Debian/Ubuntu run:

      apt-get install python3 graphviz

  On RedHat/Fedora run

      yum install python3 graphviz




    * [PyPI](https://pypi.python.org/pypi/gprof2dot/)

          pip install gprof2dot

    * [Standalone script](https://raw.githubusercontent.com/jrfonseca/gprof2dot/master/gprof2dot.py)

    * [Git repository](https://github.com/jrfonseca/gprof2dot)






      Usage:
              gprof2dot.py [options] [file] ...

      Options:
        -h, --help            show this help message and exit
        -o FILE, --output=FILE
                              output filename [stdout]
        -n PERCENTAGE, --node-thres=PERCENTAGE
                              eliminate nodes below this threshold [default: 0.5]
        -e PERCENTAGE, --edge-thres=PERCENTAGE
                              eliminate edges below this threshold [default: 0.1]
        -f FORMAT, --format=FORMAT
                              profile format: axe, callgrind, hprof, json, oprofile,
                              perf, prof, pstats, sleepy, sysprof or xperf [default:
                              prof]
        --total=TOTALMETHOD   preferred method of calculating total time: callratios
                              or callstacks (currently affects only perf format)
                              [default: callratios]
        -c THEME, --colormap=THEME
                              color map: color, pink, gray, bw, or print [default:
                              color]
        -s, --strip           strip function parameters, template parameters, and
                              const modifiers from demangled C++ function names
        -w, --wrap            wrap function names
        --show-samples        show function samples
        -z ROOT, --root=ROOT  prune call graph to show only descendants of specified
                              root function
        -l LEAF, --leaf=LEAF  prune call graph to show only ancestors of specified
                              leaf function
  	  --list-functions=SELECT list available functions as a help/preparation  for using the
  	                        -l and -z flags. When selected the program only produces this
  							list. SELECT is used with the same matching syntax
  							as with -z(--root) and -l(--leaf). Special cases SELECT="+"
  							gets the full list, selector starting with "%" cause dump
  							of all available information.
        --skew=THEME_SKEW     skew the colorization curve.  Values < 1.0 give more
                              variety to lower percentages.  Values > 1.0 give less
                              variety to lower percentages





      perf record -g -- /path/to/your/executable
      perf script | c++filt | gprof2dot.py -f perf | dot -Tpng -o output.png



      opcontrol --callgraph=16
      opcontrol --start
      /path/to/your/executable arg1 arg2
      opcontrol --stop
      opcontrol --dump
      opreport -cgf | gprof2dot.py -f oprofile | dot -Tpng -o output.png



  If you're not familiar with xperf then read [this excellent article](http://blogs.msdn.com/b/pigscanfly/archive/2009/08/06/stack-walking-in-xperf.aspx) first. Then do:

    * Start xperf as

          xperf -on Latency -stackwalk profile

    * Run your application.

    * Save the data.
  `
          xperf -d output.etl

    * Start the visualizer:

          xperf output.etl

    * In _Trace_ menu, select _Load Symbols_. _Configure Symbol Paths_ if necessary.

    * Select an area of interest on the _CPU sampling graph_, right-click, and select _Summary Table_.

    * In the _Columns_ menu, make sure the _Stack_ column is enabled and visible.

    * Right click on a row, choose _Export Full Table_, and save to _output.csv_.

    * Then invoke gprof2dot as

          gprof2dot.py -f xperf output.csv | dot -Tpng -o output.png



    * Collect profile data as (also can be done from GUI):

          amplxe-cl -collect hotspots -result-dir output -- your-app

    * Visualize profile data as:

          amplxe-cl -report gprof-cc -result-dir output -format text -report-output output.txt
          gprof2dot.py -f axe output.txt | dot -Tpng -o output.png

  See also [Kirill Rogozhin's blog post](http://software.intel.com/en-us/blogs/2013/04/05/making-visualized-call-graph-from-intel-vtune-amplifier-xe-results).



      /path/to/your/executable arg1 arg2
      gprof path/to/your/executable | gprof2dot.py | dot -Tpng -o output.png



      python -m profile -o output.pstats path/to/your/script arg1 arg2
      gprof2dot.py -f pstats output.pstats | dot -Tpng -o output.png



      python -m cProfile -o output.pstats path/to/your/script arg1 arg2
      gprof2dot.py -f pstats output.pstats | dot -Tpng -o output.png



      java -agentlib:hprof=cpu=samples ...
      gprof2dot.py -f hprof java.hprof.txt | dot -Tpng -o output.png

  See [Russell Power's blog post](http://rjp.io/2012/07/03/java-profiling/) for details.



      dtrace -x ustackframes=100 -n 'profile-97 /pid == 12345/ { @[ustack()] = count(); } tick-60s { exit(0); }' -o out.user_stacks
      gprof2dot.py -f dtrace out.user_stacks | dot -Tpng -o output.png

      
      
      
      iconv -f ISO-8859-1 -t UTF-8 out.user_stacks | gprof2dot.py -f dtrace



  A node in the output graph represents a function and has the following layout:

      +------------------------------+
      |        function name         |
      | total time % ( self time % ) |
      |         total calls          |
      +------------------------------+

  where:

    * _total time %_ is the percentage of the running time spent in this function and all its children;
    * _self time %_ is the percentage of the running time spent in this function alone;
    * _total calls_ is the total number of times this function was called (including recursive calls).

  An edge represents the calls between two functions and has the following layout:

                 total time %
                    calls
      parent --------------------> children

  Where:

    * _total time %_ is the percentage of the running time transfered from the children to this parent (if available);
    * _calls_ is the number of calls the parent function called the children.

  Note that in recursive cycles, the _total time %_ in the node is the same for the whole functions in the cycle, and there is no _total time %_ figure in the edges inside the cycle, since such figure would make no sense.

  The color of the nodes and edges varies according to the _total time %_ value. In the default _temperature-like_ color-map, functions where most time is spent (hot-spots) are marked as saturated red, and functions where little time is spent are marked as dark blue. Note that functions where negligible or no time is spent do not appear in the graph by default.



  The flag `--list-functions` permits listing the function entries found in the `gprof` input.
  This is intended as a tool to prepare for utilisations with the `--leaf` (`-l`)
  or `--root` (`-z`) flags.

    ~~~
    prof2dot.py -f pstats /tmp/myLog.profile  --list-functions "test_segments:*:*"

    test_segments:5:<module>,
    test_segments:206:TestSegments,
    test_segments:46:<lambda>
    ~~~

    - The selector argument is used with Unix/Bash globbing/pattern matching, in the same
      fashion as performed by the `-l` and `-z` flags.

    - Entries are formatted '\<pkg\>:\<linenum\>:\<function\>'.

    - When selector argument starts with '%', a dump of all available information is
  	performed for selected entries,   after removal of selector's leading '%'. If
  	selector is "+" or "*", the full list of functions is printed.






  By default `gprof2dot.py` generates a _partial_ call graph, excluding nodes and edges with little or no impact in the total computation time. If you want the full call graph then set a zero threshold for nodes and edges via the `-n` / `--node-thres`  and `-e` / `--edge-thres` options, as:

      gprof2dot.py -n0 -e0



  The node labels can get very wide when profiling C++ code, due to inclusion of scope, function arguments, and template arguments in demangled C++ function names.

  If you do not need function and template arguments information, then pass the `-s` / `--strip` option to strip them.

  If you want to keep all that information, or if the labels are still too wide, then you can pass the `-w` / `--wrap`, to wrap the labels. Note that because `dot` does not wrap labels automatically the label margins will not be perfectly aligned.



  Likely, the total execution time is too short, so there is not enough precision in the profile to determine where time is being spent.

  You can still force displaying the whole graph by setting a zero threshold for nodes and edges via the `-n` / `--node-thres`  and `-e` / `--edge-thres` options, as:

      gprof2dot.py -n0 -e0

  But to get meaningful results you will need to find a way to run the program for a longer time period (aggregate results from multiple runs).



  You likely have an execution time too short, causing the round-off errors to be large.

  See question above for ways to increase execution time.



  Options which are _essential_ to produce suitable results are:

    * **`-g`** : produce debugging information
    * **`-fno-omit-frame-pointer`** : use the frame pointer (frame pointer usage is disabled by default in some architectures like x86\_64 and for some optimization levels; it is impossible to walk the call stack without it)

  _If_ you're using gprof you will also need `-pg` option, but nowadays you can get much better results with other profiling tools, most of which require no special code instrumentation when compiling.

  You want the code you are profiling to be as close as possible as the code that you will
  be releasing. So you _should_ include all options that you use in your release code, typically:

    * **`-O2`** : optimizations that do not involve a space-speed tradeoff
    * **`-DNDEBUG`** : disable debugging code in the standard library (such as the assert macro)

  However many of the optimizations performed by gcc interfere with the accuracy/granularity of the profiling results.  You _should_ pass these options to disable those particular optimizations:

    * **`-fno-inline-functions`** : do not inline functions into their parents (otherwise the time spent on these functions will be attributed to the caller)
    * **`-fno-inline-functions-called-once`** : similar to above
    * **`-fno-optimize-sibling-calls`** : do not optimize sibling and tail recursive calls (otherwise tail calls may be attributed to the parent function)

  If the granularity is still too low, you _may_ pass these options to achieve finer granularity:

    * **`-fno-default-inline`** : do not make member functions inline by default merely because they are defined inside the class scope
    * **`-fno-inline`** : do not pay attention to the inline keyword
  Note however that with these last options the timings of functions called many times will be distorted due to the function call overhead. This is particularly true for typical C++ code which _expects_ that these optimizations to be done for decent performance.

  See the [full list of gcc optimization options](http://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html) for more information.



  See the [wiki](https://github.com/jrfonseca/gprof2dot/wiki) for external resources, including complementary/alternative tools.


pkgId: e09c837858366272e9c9d3f820d8a63f20f5240306e5bb8e9aac57ed6d634f2a
name: python-gpsoauth
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A python client library for Google Play Services OAuth.
url: https://github.com/simon-weber/gpsoauth
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-986e639b-ea4c-41af-8a70-de954e28c45b
location_href: 00013037-python-gpsoauth/python-gpsoauth-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/simon-weber/gpsoauth/actions/workflows/ci.yaml/badge.svg)](https://github.com/simon-weber/gpsoauth/actions/workflows/ci.yaml)
  [![PyPI version](https://badge.fury.io/py/gpsoauth.svg)](https://pypi.org/project/gpsoauth/)
  [![repominder](https://img.shields.io/badge/dynamic/json.svg?label=release&query=%24.status&maxAge=43200&uri=https%3A%2F%2Fwww.repominder.com%2Fbadge%2FeyJmdWxsX25hbWUiOiAic2ltb24td2ViZXIvZ3Bzb2F1dGgifQ%3D%3D%2F&link=https%3A%2F%2Fwww.repominder.com%2F)](https://www.repominder.com)

  **Python client library for Google Play Services OAuth.**

  `gpsoauth` allows python code to use the "master token" flow that KB Sriram described at
  <http://sbktech.blogspot.com/2014/01/inside-android-play-services-magic.html>.

  This can be useful when writing code that poses as a Google app, like
  [gmusicapi does here](https://github.com/simon-weber/gmusicapi/blob/87a802ab3a59a7fa2974fd9755d59a55275484d9/gmusicapi/session.py#L267-L278).

  Many thanks to Dima Kovalenko for reverse engineering the EncryptedPasswd signature in
  <https://web.archive.org/web/20150814054004/http://codedigging.com/blog/2014-06-09-about-encryptedpasswd/>.

  For an explanation of recent changes, see [the changelog](https://github.com/simon-weber/gpsoauth/blob/master/CHANGELOG.md).



  - C\#: <https://github.com/vemacs/GPSOAuthSharp>
  - Ruby: <https://github.com/bryanmytko/gpsoauth>
  - Java: <https://github.com/svarzee/gpsoauth-java>
  - C++: <https://github.com/dvirtz/gpsoauth-cpp> and <https://github.com/Iciclelz/gpsoauthclient>



  See [Contributing guidelines](https://github.com/simon-weber/gpsoauth/blob/master/CONTRIBUTING.md).
  This is an open-source project and all countributions are highly welcomed.


pkgId: 5ace53f913d9cfe001cd5fd87cbc5f0a14d59bf5b8c85ccaede82ade46f2e13d
name: python-gpxpy
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: GPX file parser and GPS track manipulation library
url: https://github.com/tkrajina/gpxpy
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b200a9f5-b105-416c-952b-f3f3f991e6d9
location_href: 00003800-python-gpxpy/python-gpxpy-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/tkrajina/gpxpy.svg?branch=master)](https://travis-ci.org/tkrajina/gpxpy)
  [![Coverage Status](https://coveralls.io/repos/github/tkrajina/gpxpy/badge.svg?branch=master)](https://coveralls.io/github/tkrajina/gpxpy?branch=master)



  This is a simple Python library for parsing and manipulating GPX files. GPX is an XML based format for GPS tracks.

  You can see it in action on [my online GPS track editor and organizer](http://www.trackprofiler.com).

  There is also a Golang port of gpxpy: [gpxgo](http://github.com/tkrajina/gpxgo).

  See also [srtm.py](https://github.com/tkrajina/srtm.py) if your track lacks elevation data.



  ```python
  import gpxpy
  import gpxpy.gpx




  gpx_file = open('test_files/cerknicko-jezero.gpx', 'r')

  gpx = gpxpy.parse(gpx_file)

  for track in gpx.tracks:
      for segment in track.segments:
          for point in segment.points:
              print('Point at ({0},{1}) -> {2}'.format(point.latitude, point.longitude, point.elevation))

  for waypoint in gpx.waypoints:
      print('waypoint {0} -> ({1},{2})'.format(waypoint.name, waypoint.latitude, waypoint.longitude))

  for route in gpx.routes:
      print('Route:')
      for point in route.points:
          print('Point at ({0},{1}) -> {2}'.format(point.latitude, point.longitude, point.elevation))





  print('GPX:', gpx.to_xml())




  gpx = gpxpy.gpx.GPX()


  gpx_track = gpxpy.gpx.GPXTrack()
  gpx.tracks.append(gpx_track)


  gpx_segment = gpxpy.gpx.GPXTrackSegment()
  gpx_track.segments.append(gpx_segment)


  gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(2.1234, 5.1234, elevation=1234))
  gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(2.1235, 5.1235, elevation=1235))
  gpx_segment.points.append(gpxpy.gpx.GPXTrackPoint(2.1236, 5.1236, elevation=1236))



  print('Created GPX:', gpx.to_xml())
  ```



  gpx.py can parse and generate GPX 1.0 and 1.1 files. The generated file will always be a valid XML document, but it may not be (strictly speaking) a valid GPX document. For example, if you set gpx.email to "my.email AT mail.com" the generated GPX tag won't confirm to the regex pattern. And the file won't be valid. Most applications will ignore such errors, but... Be aware of this!

  Be aware that the gpxpy object model *is not 100% equivalent* with the underlying GPX XML file schema. That's because the library object model works with both GPX 1.0 and 1.1.

  For example, GPX 1.0 specified a `speed` attribute for every track point, but that was removed in GPX 1.1. If you parse GPX 1.0 and serialize back with `gpx.to_xml()` everything will work fine. But if you have a GPX 1.1 object, changes in the `speed` attribute will be lost after `gpx.to_xml()`. If you want to force using 1.0, you can `gpx.to_xml(version="1.0")`. Another possibility is to use `extensions` to save the speed in GPX 1.1.



  gpx.py preserves GPX extensions. They are stored as [ElementTree](https://docs.python.org/2/library/xml.etree.elementtree.html#module-xml.etree.ElementTree) DOM objects. Extensions are part of GPX 1.1, and will be ignored when serializing a GPX object in a GPX 1.0 file.



  If lxml is available, then it will be used for XML parsing, otherwise minidom is used. Lxml is 2-3 times faster so, if you can choose -- use it.

  The GPX version is automatically determined when parsing by reading the version attribute in the gpx node. If this attribute is not present then the version is assumed to be 1.0. A specific version can be forced by setting the `version` parameter in the parse function. Possible values for the 'version' parameter are `1.0`, `1.1` and `None`.



  Gpxpy is a GPX parser and by using it you have access to all the data from the original GPX file. The additional methods to calculate stats have some additional heuristics to remove common GPS errors. For example, to calculate `max_speed` it removes the top `5%` of speeds and points with nonstandard distance (those are usually GPS errors).

  "Raw" max speed can be calculated with:

      moving_data = gpx.get_moving_data(raw=True)



  Branches:

  * `master` contains the code of the latest release
  * `dev` branch is where code for the next release should go.

  Send your pull request against `dev`, not `master`!

  Before sending a pull request -- check that all tests are OK.  Run all the static typing checks and unit tests with:

      $ make mypy-and-tests

  Run a single test with:

      $ python3 -m unittest test.GPXTests.test_haversine_and_nonhaversine

  Gpxpy runs only with python 3.6+. The code must have type hints and must pass all the mypy checks.



  Additional command-line tools for GPX files can be downloaded here <https://github.com/tkrajina/gpx-cmd-tools> or installed with:

  ```
  pip install gpx-cmd-tools
  ```



  GPX.py is licensed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)


pkgId: 500662bbc6553f9e9dbbf82729ad428ee77af7935024ef59ac4f57a0d6a2c6b2
name: python-gpytorch
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: An implementation of Gaussian Processes in Pytorch
url: https://gpytorch.ai
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2bc10ad9-5462-464e-b0e1-cd7ee3c21dbc
location_href: 00010909-python-gpytorch/python-gpytorch-1.9.1-1.src.rpm
checksum_type: sha256
description:
  [![Test Suite](https://github.com/cornellius-gp/gpytorch/actions/workflows/run_test_suite.yml/badge.svg)](https://github.com/cornellius-gp/gpytorch/actions/workflows/run_test_suite.yml)
  [![Documentation Status](https://readthedocs.org/projects/gpytorch/badge/?version=latest)](https://gpytorch.readthedocs.io/en/latest/?badge=latest)
  GPyTorch is a Gaussian process library implemented using PyTorch. GPyTorch is designed for creating scalable, flexible, and modular Gaussian process models with ease.
  Internally, GPyTorch differs from many existing approaches to GP inference by performing all inference operations using modern numerical linear algebra techniques like preconditioned conjugate gradients. Implementing a scalable GP method is as simple as providing a matrix multiplication routine with the kernel matrix and its derivative via our `LinearOperator` interface, or by composing many of our already existing `LinearOperators`. This allows not only for easy implementation of popular scalable GP techniques, but often also for significantly improved utilization of GPU computing compared to solvers based on the Cholesky decomposition.
  GPyTorch provides (1) significant GPU acceleration (through MVM based inference); (2) state-of-the-art implementations of the latest algorithmic advances for scalability and flexibility ([SKI/KISS-GP](http://proceedings.mlr.press/v37/wilson15.pdf), [stochastic Lanczos expansions](https://arxiv.org/abs/1711.03481), [LOVE](https://arxiv.org/pdf/1803.06058.pdf), [SKIP](https://arxiv.org/pdf/1802.08903.pdf), [stochastic variational](https://arxiv.org/pdf/1611.00336.pdf) [deep kernel learning](http://proceedings.mlr.press/v51/wilson16.pdf), ...); (3) easy integration with deep learning frameworks.

  See our numerous [**examples and tutorials**](https://gpytorch.readthedocs.io/en/latest/) on how to construct all sorts of models in GPyTorch.

  **Requirements**:
  - Python >= 3.8
  - PyTorch >= 1.11
  Install GPyTorch using pip or conda:
  ```bash
  pip install gpytorch
  conda install gpytorch -c gpytorch
  ```
  (To use packages globally but install GPyTorch as a user-only package, use `pip install --user` above.)

  To upgrade to the latest (unstable) version, run
  ```bash
  pip install --upgrade git+https://github.com/cornellius-gp/linear_operator.git
  pip install --upgrade git+https://github.com/cornellius-gp/gpytorch.git
  ```

  Note: Experimental AUR package. For most users, we recommend installation by conda or pip.
  GPyTorch is also available on the [ArchLinux User Repository](https://wiki.archlinux.org/index.php/Arch_User_Repository) (AUR).
  You can install it with an [AUR helper](https://wiki.archlinux.org/index.php/AUR_helpers), like [`yay`](https://aur.archlinux.org/packages/yay/), as follows:
  ```bash
  yay -S python-gpytorch
  ```
  To discuss any issues related to this AUR package refer to the comments section of
  [`python-gpytorch`](https://aur.archlinux.org/packages/python-gpytorch/).

  If you use GPyTorch, please cite the following papers:
  > [Gardner, Jacob R., Geoff Pleiss, David Bindel, Kilian Q. Weinberger, and Andrew Gordon Wilson. "GPyTorch: Blackbox Matrix-Matrix Gaussian Process Inference with GPU Acceleration." In Advances in Neural Information Processing Systems (2018).](https://arxiv.org/abs/1809.11165)
  ```
  @inproceedings{gardner2018gpytorch,
    title={GPyTorch: Blackbox Matrix-Matrix Gaussian Process Inference with GPU Acceleration},
    author={Gardner, Jacob R and Pleiss, Geoff and Bindel, David and Weinberger, Kilian Q and Wilson, Andrew Gordon},
    booktitle={Advances in Neural Information Processing Systems},
    year={2018}
  }
  ```

  To run the unit tests:
  ```bash
  python -m unittest
  ```
  By default, the random seeds are locked down for some of the tests.
  If you want to run the tests without locking down the seed, run
  ```bash
  UNLOCK_SEED=true python -m unittest
  ```
  If you plan on submitting a pull request, please make use of our pre-commit hooks to ensure that your commits adhere
  to the general style guidelines enforced by the repo. To do this, navigate to your local repository and run:
  ```bash
  pip install pre-commit
  pre-commit install
  ```
  From then on, this will automatically run flake8, isort, black and other tools over the files you commit each time you commit to gpytorch or a fork of it.

  GPyTorch is primarily maintained by:
  - [Jake Gardner](https://www.cis.upenn.edu/~jacobrg/index.html) (University of Pennsylvania)
  - [Geoff Pleiss](http://github.com/gpleiss) (Columbia University)
  - [Kilian Weinberger](http://kilian.cs.cornell.edu/) (Cornell University)
  - [Andrew Gordon Wilson](https://cims.nyu.edu/~andrewgw/) (New York University)
  - [Max Balandat](https://research.fb.com/people/balandat-max/) (Meta)
  We would like to thank our other contributors including (but not limited to)  David Arbour, Eytan Bakshy, David Eriksson, Jared Frank, Sam Stanton, Bram Wallace, Ke Alexander Wang, Ruihan Wu.

  Development of GPyTorch is supported by funding from
  the [Bill and Melinda Gates Foundation](https://www.gatesfoundation.org/),
  the [National Science Foundation](https://www.nsf.gov/),
  [SAP](https://www.sap.com/index.html),
  the [Simons Foundation](https://www.simonsfoundation.org),
  and the [Gatsby Charitable Trust](https://www.gatsby.org.uk).


pkgId: c1c6960556930c3d0c7be95f6cbeff5ae925ab36d148f4f66a26c5745a8b2054
name: python-gql
arch: src
version: 3.4.0
epoch: 0
release: 1
summary: GraphQL client for Python
url: https://github.com/graphql-python/gql
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0e5d8c96-78ad-4ad7-910a-3356bec5246b
location_href: 00009679-python-gql/python-gql-3.4.0-1.src.rpm
checksum_type: sha256
description:
  This is a GraphQL client for Python 3.6+.
  Plays nicely with `graphene`, `graphql-core`, `graphql-js` and any other GraphQL implementation compatible with the spec.

  GQL architecture is inspired by `React-Relay` and `Apollo-Client`.

  [![GitHub-Actions][gh-image]][gh-url]
  [![pyversion][pyversion-image]][pyversion-url]
  [![pypi][pypi-image]][pypi-url]
  [![Anaconda-Server Badge][conda-image]][conda-url]
  [![codecov][codecov-image]][codecov-url]

  [gh-image]: https://github.com/graphql-python/gql/workflows/Tests/badge.svg
  [gh-url]: https://github.com/graphql-python/gql/actions?query=workflow%3ATests
  [pyversion-image]: https://img.shields.io/pypi/pyversions/gql
  [pyversion-url]: https://pypi.org/project/gql/
  [pypi-image]: https://img.shields.io/pypi/v/gql.svg?style=flat
  [pypi-url]: https://pypi.org/project/gql/
  [conda-image]: https://img.shields.io/conda/vn/conda-forge/gql.svg
  [conda-url]: https://anaconda.org/conda-forge/gql
  [codecov-image]: https://codecov.io/gh/graphql-python/gql/branch/master/graph/badge.svg
  [codecov-url]: https://codecov.io/gh/graphql-python/gql



  The complete documentation for GQL can be found at
  [gql.readthedocs.io](https://gql.readthedocs.io).



  * Execute GraphQL queries using [different protocols](https://gql.readthedocs.io/en/latest/transports/index.html):
    * http
    * websockets:
      * apollo or graphql-ws protocol
      * Phoenix channels
      * AWS AppSync realtime protocol (experimental)
  * Possibility to [validate the queries locally](https://gql.readthedocs.io/en/latest/usage/validation.html) using a GraphQL schema provided locally or fetched from the backend using an instrospection query
  * Supports GraphQL queries, mutations and [subscriptions](https://gql.readthedocs.io/en/latest/usage/subscriptions.html)
  * Supports [sync or async usage](https://gql.readthedocs.io/en/latest/async/index.html), [allowing concurrent requests](https://gql.readthedocs.io/en/latest/advanced/async_advanced_usage.html#async-advanced-usage)
  * Supports [File uploads](https://gql.readthedocs.io/en/latest/usage/file_upload.html)
  * Supports [Custom scalars / Enums](https://gql.readthedocs.io/en/latest/usage/custom_scalars_and_enums.html)
  * [gql-cli script](https://gql.readthedocs.io/en/latest/gql-cli/intro.html) to execute GraphQL queries or download schemas from the command line
  * [DSL module](https://gql.readthedocs.io/en/latest/advanced/dsl_module.html) to compose GraphQL queries dynamically



  You can install GQL with all the optional dependencies using pip:

      pip install gql[all]

  > **NOTE**: See also [the documentation](https://gql.readthedocs.io/en/latest/intro.html#less-dependencies) to install GQL with less extra dependencies depending on the transports you would like to use or for alternative installation methods.





  ```python
  from gql import gql, Client
  from gql.transport.aiohttp import AIOHTTPTransport


  transport = AIOHTTPTransport(url="https://countries.trevorblades.com/")


  client = Client(transport=transport, fetch_schema_from_transport=True)


  query = gql(
      """
      query getContinents {
        continents {
          code
          name
        }
      }
  """
  )


  result = client.execute(query)
  print(result)
  ```

  Executing the above code should output the following result:

  ```
  $ python basic_example.py
  {'continents': [{'code': 'AF', 'name': 'Africa'}, {'code': 'AN', 'name': 'Antarctica'}, {'code': 'AS', 'name': 'Asia'}, {'code': 'EU', 'name': 'Europe'}, {'code': 'NA', 'name': 'North America'}, {'code': 'OC', 'name': 'Oceania'}, {'code': 'SA', 'name': 'South America'}]}
  ```

  > **WARNING**: Please note that this basic example won't work if you have an asyncio event loop running. In some
  > python environments (as with Jupyter which uses IPython) an asyncio event loop is created for you. In that case you
  > should use instead the [async usage example](https://gql.readthedocs.io/en/latest/async/async_usage.html#async-usage).


  See [CONTRIBUTING.md](CONTRIBUTING.md)



  [MIT License](https://github.com/graphql-python/gql/blob/master/LICENSE)


pkgId: 38f63b374a71277290e98f267fc128a2fefbe9b223d9b4dfd781489f3726b53c
name: python-grabserial
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Serial dump and timing program
url: https://github.com/straend/grabserial
rpm_license: GPL v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6be50262-b9d1-458d-95a6-bff1bedd135d
location_href: 00003802-python-grabserial/python-grabserial-2.0.4-1.src.rpm
checksum_type: sha256
description:
  https://github.com/tbird20d/grabserial

  grabserial is a small program which reads a serial port and writes the data
  to standard output. The main purpose of this tool is to collect messages
  written to the serial console from a target board running Linux, and save
  the messages on a host machine.


pkgId: f01b0e99c8103af27c1ae1adb235d27aaed266f0ec650c049d95efd50c60dfec
name: python-grako
arch: src
version: 3.99.9
epoch: 0
release: 1
url: https://bitbucket.org/neogeny/grako
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f808cd58-0ed1-4243-895b-65b21110f88f
location_href: 00003804-python-grako/python-grako-3.99.9-1.src.rpm
checksum_type: sha256
summary:
  Grako takes a grammar in a variation of EBNF as input, and outputs a memoizing PEG/Packrat parser in Python.

description:
  *At least for the people who send me mail about a new language that they're designing, the general advice is: do it to learn about how to write a compiler. Don't have any expectations that anyone will use it, unless you hook up with some sort of organization in a position to push it hard. It's a lottery, and some can buy a lot of the tickets. There are plenty of beautiful languages (more beautiful than C) that didn't catch on. But someone does win the lottery, and doing a language at least teaches you something.*
      `Dennis Ritchie`_ (1941-2011)


pkgId: 1163d89f0bf4e133fa413db95c688a721c4ac3c972ea2c713f77bcfd3f268719
name: python-grandalf
arch: src
version: 0.8
epoch: 0
release: 1
summary: Graph and drawing algorithms framework
url: https://github.com/bdcht/grandalf
rpm_license: GPLv2 | EPLv1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d159aa48-c77c-45dc-925b-e84a5d0cd1bd
location_href: 00011002-python-grandalf/python-grandalf-0.8-1.src.rpm
checksum_type: sha256
description:
  Grandalf is a python package made for experimentations with graphs drawing
  algorithms. It is written in pure python, and currently implements two layouts:
  the Sugiyama hierarchical layout and the force-driven or energy minimization approach.
  While not as fast or featured as *graphviz* or other libraries like *OGDF* (C++),
  it provides a way to walk and draw graphs
  no larger than thousands of nodes, while keeping the source code simple enough
  to tweak and hack any part of it for experimental purpose.
  With a total of about 1500 lines of python, the code involved in
  drawing the Sugiyama (dot) layout fits in less than 600 lines.
  The energy minimization approach is comprised of only 250 lines!

  Grandalf does only 2 not-so-simple things:

  - computing the nodes (x,y) coordinates
    (based on provided nodes dimensions, and a chosen layout)
  - routing the edges with lines or nurbs

  It doesn't depend on any GTK/Qt/whatever graphics toolkit.
  This means that it will help you find *where* to
  draw things like nodes and edges, but it's up to you to actually draw things with
  your favorite toolkit.


pkgId: 0900cf9236d1ba984aa1a1204d1db1a8db16d82557ac19ffa4488dab03a3b306
name: python-grapheme
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Unicode grapheme helpers
url: https://github.com/alvinlindstam/grapheme
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-44bf3ef9-1e03-4f4c-bfc0-0aa4c7b2c123
location_href: 00013207-python-grapheme/python-grapheme-0.6.0-1.src.rpm
checksum_type: sha256
description:
  A Python package for working with user perceived characters. More specifically,
  string manipulation and calculation functions for working with grapheme cluster
  groups (graphemes) as defined by the `Unicode Standard Annex #29 <http://unicode.org/reports/tr29/>`_.
  `documentation <https://grapheme.readthedocs.io/>`_
      pip install grapheme
  The currently supported version of Unicode: 13.0.0.


pkgId: 08c65a10e882d6ad1ba17b054fa9a5d0addadb26194bd0ea50e450f3f3556233
name: python-graphene
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: GraphQL Framework for Python
url: https://github.com/graphql-python/graphene
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7b37273c-e043-4254-8d0d-1c11236c0276
location_href: 00003807-python-graphene/python-graphene-3.2.1-1.src.rpm
checksum_type: sha256
description:
  `���� Join the community on
  Slack <https://join.slack.com/t/graphenetools/shared_invite/enQtOTE2MDQ1NTg4MDM1LTA4Nzk0MGU0NGEwNzUxZGNjNDQ4ZjAwNDJjMjY0OGE1ZDgxZTg4YjM2ZTc4MjE2ZTAzZjE2ZThhZTQzZTkyMmM>`__
  **We are looking for contributors**! Please check the
  `ROADMAP <https://github.com/graphql-python/graphene/blob/master/ROADMAP.md>`__
  to see how you can help ������


pkgId: f56dd972df54e101332a62108bfbc2c1b6935d883d970cb7c61f781efdb7f34d
name: python-graphframes
arch: src
version: 0.6
epoch: 0
release: 1
summary: GraphFrames: DataFrame-based Graphs
url: https://github.com/graphframes/graphframes
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7332bf2d-347a-46b0-8fa3-ff815f0ff394
location_href: 00009729-python-graphframes/python-graphframes-0.6-1.src.rpm
checksum_type: sha256
description:
  This is a package for DataFrame-based graphs on top of Apache Spark. Users can write highly expressive queries by leveraging the DataFrame API, combined with a new API for motif finding. The user also benefits from DataFrame performance optimizations within the Spark SQL engine.


pkgId: ca54573b6bc65346520c165782cfd85f433cc76b69aed61b449c37c79d1ec41f
name: python-graphql-core
arch: src
version: 3.2.3
epoch: 0
release: 1
url: https://github.com/graphql-python/graphql-core
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03f132ee-b32f-4940-8dd7-855f1757b9af
location_href: 00003810-python-graphql-core/python-graphql-core-3.2.3-1.src.rpm
checksum_type: sha256
summary:
  GraphQL implementation for Python, a port of GraphQL.js, the JavaScript reference implementation for GraphQL.

description:
  GraphQL-core 3 is a Python 3.6+ port of [GraphQL.js](https://github.com/graphql/graphql-js),
  the JavaScript reference implementation for [GraphQL](https://graphql.org/),
  a query language for APIs created by Facebook.

  [![PyPI version](https://badge.fury.io/py/graphql-core.svg)](https://badge.fury.io/py/graphql-core)
  [![Documentation Status](https://readthedocs.org/projects/graphql-core-3/badge/)](https://graphql-core-3.readthedocs.io)
  ![Test Status](https://github.com/graphql-python/graphql-core/actions/workflows/test.yml/badge.svg)
  ![Lint Status](https://github.com/graphql-python/graphql-core/actions/workflows/lint.yml/badge.svg)
  [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  The current version 3.2.3 of GraphQL-core is up-to-date with GraphQL.js version 16.6.0.

  An extensive test suite with over 2300 unit tests and 100% coverage comprises a
  replication of the complete test suite of GraphQL.js, making sure this port is
  reliable and compatible with GraphQL.js.

  Note that for various reasons, GraphQL-core does not use SemVer like GraphQL.js. Increases in the major version of GraphQL.js are reflected in the minor version of GraphQL-core instead. This means there can be breaking changes in the API when the minor version changes, and only patch releases are fully backward compatible. Therefore, we recommend something like `=~ 3.2.0` as version specifier when including GraphQL-core as a dependency.




  A more detailed documentation for GraphQL-core 3 can be found at
  [graphql-core-3.readthedocs.io](https://graphql-core-3.readthedocs.io/).

  The documentation for GraphQL.js can be found at [graphql.org/graphql-js/](https://graphql.org/graphql-js/).

  The documentation for GraphQL itself can be found at [graphql.org](https://graphql.org/).

  There will be also [blog articles](https://cito.github.io/tags/graphql/) with more usage
  examples.




  A general overview of GraphQL is available in the
  [README](https://github.com/graphql/graphql-spec/blob/main/README.md) for the
  [Specification for GraphQL](https://github.com/graphql/graphql-spec). That overview
  describes a simple set of GraphQL examples that exist as [tests](tests) in this
  repository. A good way to get started with this repository is to walk through that
  README and the corresponding tests in parallel.




  GraphQL-core 3 can be installed from PyPI using the built-in pip command:

      python -m pip install graphql-core

  You can also use [poetry](https://github.com/python-poetry/poetry) for installation in a
  virtual environment:

      poetry install




  GraphQL-core provides two important capabilities: building a type schema and
  serving queries against that type schema.

  First, build a GraphQL type schema which maps to your codebase:

  ```python
  from graphql import (
      GraphQLSchema, GraphQLObjectType, GraphQLField, GraphQLString)

  schema = GraphQLSchema(
      query=GraphQLObjectType(
          name='RootQueryType',
          fields={
              'hello': GraphQLField(
                  GraphQLString,
                  resolve=lambda obj, info: 'world')
          }))
  ```

  This defines a simple schema, with one type and one field, that resolves to a fixed
  value. The `resolve` function can return a value, a co-routine object or a list of
  these. It takes two positional arguments; the first one provides the root or the
  resolved parent field, the second one provides a `GraphQLResolveInfo` object which
  contains information about the execution state of the query, including a `context`
  attribute holding per-request state such as authentication information or database
  session. Any GraphQL arguments are passed to the `resolve` functions as individual
  keyword arguments.

  Note that the signature of the resolver functions is a bit different in GraphQL.js,
  where the context is passed separately and arguments are passed as a single object.
  Also note that GraphQL fields must be passed as a `GraphQLField` object explicitly.
  Similarly, GraphQL arguments must be passed as `GraphQLArgument` objects.

  A more complex example is included in the top-level [tests](tests) directory.

  Then, serve the result of a query against that type schema.

  ```python
  from graphql import graphql_sync

  source = '{ hello }'

  print(graphql_sync(schema, source))
  ```

  This runs a query fetching the one field defined, and then prints the result:

  ```python
  ExecutionResult(data={'hello': 'world'}, errors=None)
  ```

  The `graphql_sync` function will first ensure the query is syntactically and
  semantically valid before executing it, reporting errors otherwise.

  ```python
  from graphql import graphql_sync

  source = '{ BoyHowdy }'

  print(graphql_sync(schema, source))
  ```

  Because we queried a non-existing field, we will get the following result:

  ```python
  ExecutionResult(data=None, errors=[GraphQLError(
      "Cannot query field 'BoyHowdy' on type 'RootQueryType'.",
      locations=[SourceLocation(line=1, column=3)])])
  ```

  The `graphql_sync` function assumes that all resolvers return values synchronously. By
  using coroutines as resolvers, you can also create results in an asynchronous fashion
  with the `graphql` function.

  ```python
  import asyncio
  from graphql import (
      graphql, GraphQLSchema, GraphQLObjectType, GraphQLField, GraphQLString)


  async def resolve_hello(obj, info):
      await asyncio.sleep(3)
      return 'world'

  schema = GraphQLSchema(
      query=GraphQLObjectType(
          name='RootQueryType',
          fields={
              'hello': GraphQLField(
                  GraphQLString,
                  resolve=resolve_hello)
          }))


  async def main():
      query = '{ hello }'
      print('Fetching the result...')
      result = await graphql(schema, query)
      print(result)


  asyncio.run(main())
  ```




  GraphQL-core tries to reproduce the code of the reference implementation GraphQL.js
  in Python as closely as possible and to stay up-to-date with the latest development of
  GraphQL.js.

  GraphQL-core 3 (formerly known as GraphQL-core-next) has been created as a modern
  alternative to [GraphQL-core 2](https://github.com/graphql-python/graphql-core-legacy),
  a prior work by Syrus Akbary, based on an older version of GraphQL.js and also
  targeting older Python versions. Some parts of GraphQL-core 3 have been inspired by
  GraphQL-core 2 or directly taken over with only slight modifications, but most of the
  code has been re-implemented from scratch, replicating the latest code in GraphQL.js
  very closely and adding type hints for Python.

  Design goals for the GraphQL-core 3 library were:

  * to be a simple, cruft-free, state-of-the-art GraphQL implementation for current
    Python versions
  * to be very close to the GraphQL.js reference implementation, while still providing
    a Pythonic API and code style
  * to make extensive use of Python type hints, similar to how GraphQL.js used Flow
    (and is now using TypeScript)
  * to use [black](https://github.com/ambv/black) to achieve a consistent code style
    while saving time and mental energy for more important matters
  * to replicate the complete Mocha-based test suite of GraphQL.js
    using [pytest](https://docs.pytest.org/)
    with [pytest-describe](https://pypi.org/project/pytest-describe/)

  Some restrictions (mostly in line with the design goals):

  * requires Python 3.6 or newer
  * does not support some already deprecated methods and options of GraphQL.js
  * supports asynchronous operations only via async.io
    (does not support the additional executors in GraphQL-core)




  * [Graphene](http://graphene-python.org/) is a more high-level framework for building
    GraphQL APIs in Python, and there is already a whole ecosystem of libraries, server
    integrations and tools built on top of Graphene. Most of this Graphene ecosystem has
    also been created by Syrus Akbary, who meanwhile has handed over the maintenance
    and future development to members of the GraphQL-Python community.

    The current version 2 of Graphene is using Graphql-core 2 as core library for much of
    the heavy lifting. Note that Graphene 2 is not compatible with GraphQL-core 3.
    The  new version 3 of Graphene will use GraphQL-core 3 instead of GraphQL-core 2.

  * [Ariadne](https://github.com/mirumee/ariadne) is a Python library for implementing
    GraphQL servers using schema-first approach created by Mirumee Software.

    Ariadne is already using GraphQL-core 3 as its GraphQL implementation.

  * [Strawberry](https://github.com/strawberry-graphql/strawberry), created by Patrick
    Arminio, is a new GraphQL library for Python 3, inspired by dataclasses,
    that is also using GraphQL-core 3 as underpinning.




  Changes are tracked as
  [GitHub releases](https://github.com/graphql-python/graphql-core/releases).




  The GraphQL-core 3 library
  * has been created and is maintained by Christoph Zwerschke
  * uses ideas and code from GraphQL-core 2, a prior work by Syrus Akbary
  * is a Python port of GraphQL.js which has been developed by Lee Byron and others
    at Facebook, Inc. and is now maintained
    by the [GraphQL foundation](https://gql.foundation/join/)

  Please watch the recording of Lee Byron's short keynote on the
  [history of GraphQL](https://www.youtube.com/watch?v=VjHWkBr3tjI)
  at the open source leadership summit 2019 to better understand
  how and why GraphQL was created at Facebook and then became open sourced
  and ported to many different programming languages.




  GraphQL-core 3 is
  [MIT-licensed](./LICENSE),
  just like GraphQL.js.


pkgId: bd250fdee4d730eea051248f2979bfced1c427a3ddd5127be9ac38bab8558c38
name: python-graphql-relay
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Relay library for graphql-core
url: https://github.com/graphql-python/graphql-relay-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bfb11125-c1b7-4783-89f5-bfccbfe4d99d
location_href: 00003811-python-graphql-relay/python-graphql-relay-3.2.0-1.src.rpm
checksum_type: sha256
description:
  GraphQL-relay-py is the [Relay](https://relay.dev/) library for
  [GraphQL-core](https://github.com/graphql-python/graphql-core).

  It allows the easy creation of Relay-compliant servers using GraphQL-core.

  GraphQL-Relay-Py is a Python port of
  [graphql-relay-js](https://github.com/graphql/graphql-relay-js),
  while GraphQL-Core is a Python port of
  [GraphQL.js](https://github.com/graphql/graphql-js),
  the reference implementation of GraphQL for JavaScript.

  Since version 3, GraphQL-Relay-Py and GraphQL-Core support Python 3.6 and above only.
  For older versions of Python, you can use version 2 of these libraries.

  [![PyPI version](https://badge.fury.io/py/graphql-relay.svg)](https://badge.fury.io/py/graphql-relay)
  ![Test Status](https://github.com/graphql-python/graphql-relay-py/actions/workflows/test.yml/badge.svg)
  ![Lint Status](https://github.com/graphql-python/graphql-relay-py/actions/workflows/lint.yml/badge.svg)
  [![Dependency Updates](https://pyup.io/repos/github/graphql-python/graphql-relay-py/shield.svg)](https://pyup.io/repos/github/graphql-python/graphql-relay-py/)
  [![Python 3 Status](https://pyup.io/repos/github/graphql-python/graphql-relay-py/python-3-shield.svg)](https://pyup.io/repos/github/graphql-python/graphql-relay-py/)
  [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  A basic understanding of GraphQL and of the GraphQL Python implementation is needed
  to provide context for this library.

  An overview of GraphQL in general is available in the
  [README](https://github.com/graphql-python/graphql-core/blob/master/README.md) for the
  [Specification for GraphQL](https://github.com/graphql-python/graphql-core).

  This library is designed to work with the
  the [GraphQL-Core](https://github.com/graphql-python/graphql-core)
  Python reference implementation of a GraphQL server.

  An overview of the functionality that a Relay-compliant GraphQL server should provide
  is in the [GraphQL Relay Specification](https://facebook.github.io/relay/docs/graphql-relay-specification.html)
  on the [Relay website](https://facebook.github.io/relay/).
  That overview describes a simple set of examples that exist
  as [tests](tests) in this repository.
  A good way to get started with this repository is to walk through that documentation
  and the corresponding tests in this library together.



  Install Relay Library for GraphQL Python

  ```sh
  pip install graphql-core
  pip install graphql-relay
  ```

  When building a schema for [GraphQL](https://github.com/graphql-python/graphql-core),
  the provided library functions can be used to simplify the creation of Relay patterns.

  All the functions that are explained in the following sections must be
  imported from the top level of the `graphql_relay` package, like this:
  ```python
  from graphql_relay import connection_definitions
  ```



  Helper functions are provided for both building the GraphQL types
  for connections and for implementing the `resolve` method for fields
  returning those types.

   - `connection_args` returns the arguments that fields should provide when
  they return a connection type that supports bidirectional pagination.
   - `forward_connection_args` returns the arguments that fields should provide when
  they return a connection type that only supports forward pagination.
   - `backward_connection_args` returns the arguments that fields should provide when
  they return a connection type that only supports backward pagination.
   - `connection_definitions` returns a `connection_type` and its associated
  `edgeType`, given a name and a node type.
   - `connection_from_array` is a helper method that takes an array and the
  arguments from `connection_args`, does pagination and filtering, and returns
  an object in the shape expected by a `connection_type`'s `resolve` function.
   - `cursor_for_object_in_connection` is a helper method that takes an array and a
  member object, and returns a cursor for use in the mutation payload.
   - `offset_to_cursor` takes the index of a member object in an array
   and returns an opaque cursor for use in the mutation payload.
   - `cursor_to_offset` takes an opaque cursor (created with `offset_to_cursor`)
  and returns the corresponding array index.

  An example usage of these methods from the [test schema](tests/star_wars_schema.py):

  ```python
  ship_edge, ship_connection = connection_definitions(ship_type, "Ship")

  faction_type = GraphQLObjectType(
      name="Faction",
      description="A faction in the Star Wars saga",
      fields=lambda: {
          "id": global_id_field("Faction"),
          "name": GraphQLField(GraphQLString, description="The name of the faction."),
          "ships": GraphQLField(
              ship_connection,
              description="The ships used by the faction.",
              args=connection_args,
              resolve=lambda faction, _info, **args: connection_from_array(
                  [get_ship(ship) for ship in faction.ships], args
              ),
          ),
      },
      interfaces=[node_interface],
  )
  ```

  This shows adding a `ships` field to the `Faction` object that is a connection.
  It uses `connection_definitions(ship_type, "Ship")` to create the connection
  type, adds `connection_args` as arguments on this function, and then implements
  the resolver function by passing the array of ships and the arguments to
  `connection_from_array`.



  Helper functions are provided for both building the GraphQL types
  for nodes and for implementing global IDs around local IDs.

   - `node_definitions` returns the `Node` interface that objects can implement,
      and returns the `node` root field to include on the query type.
      To implement this, it takes a function to resolve an ID to an object,
      and to determine the type of a given object.
   - `to_global_id` takes a type name and an ID specific to that type name,
      and returns a "global ID" that is unique among all types.
   - `from_global_id` takes the "global ID" created by `to_global_id`, and
      returns the type name and ID used to create it.
   - `global_id_field` creates the configuration for an `id` field on a node.
   - `plural_identifying_root_field` creates a field that accepts a list of
      non-ID identifiers (like a username) and maps then to their corresponding
      objects.

  An example usage of these methods from the [test schema](tests/star_wars_schema.py):

  ```python
  def get_node(global_id, _info):
      type_, id_ = from_global_id(global_id)
      if type_ == "Faction":
          return get_faction(id_)
      if type_ == "Ship":
          return get_ship(id_)
      return None  # pragma: no cover

  def get_node_type(obj, _info, _type):
      if isinstance(obj, Faction):
          return faction_type.name
      return ship_type.name

  node_interface, node_field = node_definitions(get_node, get_node_type)[:2]

  faction_type = GraphQLObjectType(
      name="Faction",
      description="A faction in the Star Wars saga",
      fields=lambda: {
          "id": global_id_field("Faction"),
          "name": GraphQLField(GraphQLString, description="The name of the faction."),
          "ships": GraphQLField(
              ship_connection,
              description="The ships used by the faction.",
              args=connection_args,
              resolve=lambda faction, _info, **args: connection_from_array(
                  [get_ship(ship) for ship in faction.ships], args
              ),
          ),
      },
      interfaces=[node_interface],
  )

  query_type = GraphQLObjectType(
      name="Query",
      fields=lambda: {
          "rebels": GraphQLField(faction_type, resolve=lambda _obj, _info: get_rebels()),
          "empire": GraphQLField(faction_type, resolve=lambda _obj, _info: get_empire()),
          "node": node_field,
      },
  )
  ```

  This uses `node_definitions` to construct the `Node` interface and the `node`
  field; it uses `from_global_id` to resolve the IDs passed in the implementation
  of the function mapping ID to object. It then uses the `global_id_field` method to
  create the `id` field on `Faction`, which also ensures implements the
  `node_interface`. Finally, it adds the `node` field to the query type, using the
  `node_field` returned by `node_definitions`.



  A helper function is provided for building mutations with
  single inputs and client mutation IDs.

   - `mutation_with_client_mutation_id` takes a name, input fields, output fields,
  and a mutation method to map from the input fields to the output fields,
  performing the mutation along the way. It then creates and returns a field
  configuration that can be used as a top-level field on the mutation type.

  An example usage of these methods from the [test schema](tests/star_wars_schema.py):

  ```python
  class IntroduceShipMutation:

      def __init__(self, shipId, factionId, clientMutationId=None):
          self.shipId = shipId
          self.factionId = factionId
          self.clientMutationId = clientMutationId

  def mutate_and_get_payload(_info, shipName, factionId, **_input):
      new_ship = create_ship(shipName, factionId)
      return IntroduceShipMutation(shipId=new_ship.id, factionId=factionId)

  ship_mutation = mutation_with_client_mutation_id(
      "IntroduceShip",
      input_fields={
          "shipName": GraphQLInputField(GraphQLNonNull(GraphQLString)),
          "factionId": GraphQLInputField(GraphQLNonNull(GraphQLID)),
      },
      output_fields={
          "ship": GraphQLField(
              ship_type, resolve=lambda payload, _info: get_ship(payload.shipId)
          ),
          "faction": GraphQLField(
              faction_type, resolve=lambda payload, _info: get_faction(payload.factionId)
          ),
      },
      mutate_and_get_payload=mutate_and_get_payload,
  )

  mutation_type = GraphQLObjectType(
      "Mutation", fields=lambda: {"introduceShip": ship_mutation}
  )
  ```

  This code creates a mutation named `IntroduceShip`, which takes a faction
  ID and a ship name as input. It outputs the `Faction` and the `Ship` in
  question. `mutate_and_get_payload` then gets each input field as keyword
  parameter, performs the mutation by constructing the new ship, then returns
  an object that will be resolved by the output fields.

  Our mutation type then creates the `introduceShip` field using the return
  value of `mutation_with_client_mutation_id`.



  After cloning this repository from GitHub,
  we recommend using [Poetry](https://poetry.eustace.io/)
  to create a test environment. With poetry installed,
  you do this with the following command:

  ```sh
  poetry install
  ```

  You can then run the complete test suite like this:

  ```sh
  poetry run pytest
  ```

  In order to run only a part of the tests with increased verbosity,
  you can add pytest options, like this:

  ```sh
  poetry run pytest tests/node -vv
  ```

  In order to check the code style with flake8, use this:

  ```sh
  poetry run flake8
  ```

  Use the `tox` command to run the test suite with different
  Python versions and perform all additional source code checks.
  You can also restrict tox to an individual environment, like this:

  ```sh
  poetry run tox -e py39
  ```


pkgId: fd49c98bd13e9140bec70a665b746e4cda0063d7636d61b76107a9ebb8f324e8
name: python-graphql-server
arch: src
version: 3.0.0b5
epoch: 0
release: 1
summary: GraphQL Server tools for powering your server
url: https://github.com/graphql-python/graphql-server
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-17b5ee02-df74-4647-a3fb-066a40e4408f
location_href: 00003812-python-graphql-server/python-graphql-server-3.0.0b5-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/graphql-python/graphql-server/master/docs/_static/graphql-server-logo.svg" height="128px">

  [![PyPI version](https://badge.fury.io/py/graphql-server.svg)](https://badge.fury.io/py/graphql-server)
  [![Coverage Status](https://codecov.io/gh/graphql-python/graphql-server/branch/master/graph/badge.svg)](https://codecov.io/gh/graphql-python/graphql-server)

  GraphQL-Server is a base library that serves as a helper
  for building GraphQL servers or integrations into existing web frameworks using
  [GraphQL-Core](https://github.com/graphql-python/graphql-core).



  | Server integration          | Docs                                                                                    |
  | --------------------------- | --------------------------------------------------------------------------------------- |
  | Flask                       | [flask](https://github.com/graphql-python/graphql-server/blob/master/docs/flask.md)     |
  | Sanic                       | [sanic](https://github.com/graphql-python/graphql-server/blob/master/docs/sanic.md)     |
  | AIOHTTP                     | [aiohttp](https://github.com/graphql-python/graphql-server/blob/master/docs/aiohttp.md) |
  | WebOb (Pyramid, TurboGears) | [webob](https://github.com/graphql-python/graphql-server/blob/master/docs/webob.md)     |



  | Server integration | Package                                                                                                 |
  | ------------------ | ------------------------------------------------------------------------------------------------------- |
  | WSGI               | [wsgi-graphql](https://github.com/moritzmhmk/wsgi-graphql)                                              |
  | Responder          | [responder.ext.graphql](https://github.com/kennethreitz/responder/blob/master/responder/ext/graphql.py) |



  | Server integration | Package                                                               |
  | ------------------ | --------------------------------------------------------------------- |
  | Django             | [graphene-django](https://github.com/graphql-python/graphene-django/) |



  The `graphql_server` package provides these public helper functions:

  - `run_http_query`
  - `encode_execution_results`
  - `load_json_body`
  - `json_encode`
  - `json_encode_pretty`

  **NOTE:** the `json_encode_pretty` is kept as backward compatibility change as it uses `json_encode` with `pretty` parameter set to `True`.

  All functions in the package are annotated with type hints and docstrings,
  and you can build HTML documentation from these using `bin/build_docs`.

  You can also use one of the existing integrations listed above as
  blueprint to build your own integration or GraphQL server implementations.

  Please let us know when you have built something new, so we can list it here.



  See [CONTRIBUTING.md](https://github.com/graphql-python/graphql-server/blob/master/CONTRIBUTING.md)


pkgId: 405b197bfee96daa94bc9e57d6a30852c628ed66912faf3e212167cbf97c484b
name: python-graphql-server-core
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: GraphQL Server tools for powering your server
url: https://github.com/graphql-python/graphql-server-core
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-657750d3-be8b-4d44-ae53-7e2864b5d245
location_href: 00010295-python-graphql-server-core/python-graphql-server-core-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/graphql-server-core.svg)](https://badge.fury.io/py/graphql-server-core)
  [![Build Status](https://travis-ci.org/graphql-python/graphql-server-core.svg?branch=master)](https://travis-ci.org/graphql-python/graphql-server-core)
  [![Coverage Status](https://codecov.io/gh/graphql-python/graphql-server-core/branch/master/graph/badge.svg)](https://codecov.io/gh/graphql-python/graphql-server-core)

  GraphQL-Server-Core is a base library that serves as a helper
  for building GraphQL servers or integrations into existing web frameworks using
  [GraphQL-Core](https://github.com/graphql-python/graphql-core).



  | Server integration | Package |
  |---|---|
  | Flask | [flask-graphql](https://github.com/graphql-python/flask-graphql/) |
  | Sanic |[sanic-graphql](https://github.com/graphql-python/sanic-graphql/) |
  | AIOHTTP | [aiohttp-graphql](https://github.com/graphql-python/aiohttp-graphql) |
  | WebOb (Pyramid, TurboGears) |  [webob-graphql](https://github.com/graphql-python/webob-graphql/) |
  | WSGI | [wsgi-graphql](https://github.com/moritzmhmk/wsgi-graphql) |
  | Responder | [responder.ext.graphql](https://github.com/kennethreitz/responder/blob/master/responder/ext/graphql.py) |



  | Server integration | Package |
  |---|---|
  | Django | [graphene-django](https://github.com/graphql-python/graphene-django/) |



  The `graphql_server` package provides these public helper functions:

   * `run_http_query`
   * `encode_execution_results`
   * `load_json_body`
   * `json_encode`
   * `json_encode_pretty`

  All functions in the package are annotated with type hints and docstrings,
  and you can build HTML documentation from these using `bin/build_docs`.

  You can also use one of the existing integrations listed above as
  blueprint to build your own integration or GraphQL server implementations.

  Please let us know when you have built something new, so we can list it here.


  See [CONTRIBUTING.md](CONTRIBUTING.md)


pkgId: 0e7466c267d28753e9ee17c32f8a5598224c3714a9b13ac1159dad8dfcc42afb
name: python-graphqlclient
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Simple GraphQL client for Python 2.7+
url: https://github.com/prismagraphql/python-graphql-client
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a3ae4477-9951-4cbe-8f4a-ad229dd692de
location_href: 00011933-python-graphqlclient/python-graphqlclient-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Simple GraphQL client for Python 2.7+



  ```sh
  pip install graphqlclient
  ```




  ```py
  from graphqlclient import GraphQLClient

  client = GraphQLClient('http://graphql-swapi.parseapp.com/')

  result = client.execute('''
  {
    allFilms {
      films {
        title
      }
    }
  }
  ''')

  print(result)
  ```



  Authorization tokens can be added to the request using the client's `inject_token` method:

  ```py
  client.inject_token('very-long-and-secure-token')
  ```

  which defaults to http header name `Authorization`.
  An alternative http header name for the token can be set by passing in the alternative header name, e.g. for `x-api-key`:

  ```py
  client.inject_token('very-long-and-secure-token','x-api-key')
  ```



  [MIT License](http://opensource.org/licenses/MIT)


pkgId: 6cb1b937b966c28d4752b7fbc87a42cd4b4020a4ced028122d8864906b5f7481
name: python-graphviz
arch: src
version: 0.20.1
epoch: 0
release: 1
summary: Simple Python interface for Graphviz
url: https://github.com/xflr6/graphviz
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f2fc8ce4-f14a-4080-8fb5-8e742aa7090b
location_href: 00003816-python-graphviz/python-graphviz-0.20.1-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |License| |Supported Python| |Wheel| |Downloads|
  |Build| |Codecov| |Readthedocs-stable| |Readthedocs-latest|
  |Binder-stable|
  This package facilitates the creation and rendering of graph descriptions in
  the DOT_ language of the Graphviz_ graph drawing software (`upstream repo`_)
  from Python.
  Create a graph object, assemble the graph by adding nodes and edges, and
  retrieve its DOT source code string. Save the source code to a file and render
  it with the Graphviz installation of your system.
  Use the ``view`` option/method to directly inspect the resulting (PDF, PNG,
  SVG, etc.) file with its default application. Graphs can also be rendered
  and displayed within `Jupyter notebooks`_ (formerly known as
  `IPython notebooks`_,
  `example <notebook_>`_, `nbviewer <notebook-nbviewer_>`_)
  as well as the `Jupyter QtConsole`_.


pkgId: 2e61fdf2f31102888a089cf4c99fbd9af1917b54516a88e8a5e3dff1173a5436
name: python-graphyte
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: Python 3 compatible library to send data to a Graphite metrics server (Carbon)
url: https://github.com/benhoyt/graphyte
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd7f127a-0ae8-4c6f-a308-16581d55b607
location_href: 00011883-python-graphyte/python-graphyte-1.7.1-1.src.rpm
checksum_type: sha256
description:
  graphyte is a small Python library that sends data to a Graphite metrics
  server (Carbon). We wrote it because the existing `graphitesend`_ library
  didn’t support Python 3, and it also required gevent for asyncronous use.
  graphyte is tested on Python 3.5+ as well as Python 2.7, and uses the
  standard library’s ``threading`` module for asynchronous use.
  The library is `on the Python Package Index (PyPI)`_, so to install it, fire up
  a command prompt, activate your virtualenv if you’re using one, and type:
      pip install graphyte
  Using graphyte is simple – just call ``init()`` to initialize the default
  sender and then ``send()`` to send a message. For example, to send
  ``system.sync.foo.bar 42 {timestamp}\n`` to graphite.example.com:2003
  synchronously:
      import graphyte
      graphyte.init('graphite.example.com', prefix='system.sync')
      graphyte.send('foo.bar', 42)
  If you want to send asynchronously on a background thread (for example, in a
  web server context), just specify a send interval. For example, this will
  setup a background thread to send every 10 seconds:
      graphyte.init('graphite.example.com', prefix='system.async', interval=10)
      graphyte.send('foo.bar', 42)
  If you want to send tagged metrics, the usage is as follows:
      graphite.send('foo.bar', 42, tags={'ding': 'dong'})
  For more advanced usage, for example if you want to send to multiple servers
  or if you want to subclass ``Sender``, you can instantiate instances of
  ``Sender`` directly. For example, to instantiate two senders sending to
  different   servers (one synchronous, one using a background thread with send
  interval 10   seconds), use something like the following:
      sender1 = graphyte.Sender('graphite1.example.com', prefix='system.one')
      sender2 = graphyte.Sender('graphite2.example.com', prefix='system.two', interval=10)
      sender1.send('foo.bar1', 42)
      sender2.send('foo.bar2', 43)
  If you want to send via UDP instead of TCP, just add   ``protocol='udp'`` to
  the ``init()`` or ``Sender()`` call.
  Or, to customize how messages are logged or sent to the socket, subclass
  ``Sender`` and override ``send_message`` (or even ``send_socket`` if you
  want to override logging and exception handling):
      class CustomSender(graphyte.Sender):
          def send_message(self, message):
              print('Sending bytes in some custom way: {!r}'.format(message))
  By default, exceptions that occur when sending a message are logged. If you
  want to raise and propagate exceptions instead, instantiate ``Sender`` with
  ``raise_send_errors=True``. It's an error to set ``raise_send_errors`` when
  ``interval`` is specified.
  Socket sending errors are logged using the Python logging system (using
  logger name “graphyte”). If the sender is initialized with
  ``log_sends=True``, all sends are logged at the INFO level.
  You can also use graphyte to send metrics directly from the command line:
      python -m graphyte foo.bar 42
  There are command line arguments to specify the server and port and other
  configuration. Type ``python -m graphyte --help`` for help.
  Read the code in `graphyte.py`_ for more details – it’s pretty small!
  graphyte was written by `Ben Hoyt`_ and is licensed with a
  permissive MIT license (see `LICENSE.txt`_).
  **Related work:** `delphid`_ has a fork of graphyte which supports the statsd
  protocol. See the changes on `delphid's branch`_.


pkgId: 3f6d27f276fcffbce477f260282013c1cc69162b7cabfde7e213c81d32ae8c96
name: python-graypy
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Python logging handlers that send messages in the Graylog Extended Log Format (GELF).
url: https://github.com/severb/graypy
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-64a9f7d6-e5c4-4aaa-a3b7-54457de4bbce
location_href: 00011132-python-graypy/python-graypy-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Python logging handlers that send log messages in the
  Graylog Extended Log Format (GELF_).
  graypy supports sending GELF logs to both Graylog2 and Graylog3 servers.


pkgId: 87ea40e9722cfee72b2541a506905322191d6cc84d1eb91135fe8ab03c9cfaab
name: python-greenlet
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Lightweight in-process concurrent programming
url: https://greenlet.readthedocs.io/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f1474b1-e613-4330-95f4-faf5ed250fd9
location_href: 00003817-python-greenlet/python-greenlet-2.0.2-1.src.rpm
checksum_type: sha256
description:
  There are several libraries that use Greenlet as a more flexible
  alternative to Python's built in coroutine support:
   - `Concurrence`_
   - `Eventlet`_
   - `Gevent`_


pkgId: 25291cd1691fa466956c582e39966a8ceda34b876ae1de00252dbefb814e1582
name: python-grpc-google-iam-v1
arch: src
version: 0.12.6
epoch: 0
release: 1
summary: IAM API client library
url: https://github.com/googleapis/python-grpc-google-iam-v1
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90469f9c-8601-4945-bcc9-f5b7444865a7
location_href: 00009174-python-grpc-google-iam-v1/python-grpc-google-iam-v1-0.12.6-1.src.rpm
checksum_type: sha256
description:
  |preview| |pypi| |versions|
  `IAM API`_:
  - `Client Library Documentation`_
  - `Product Documentation`_
  Installation
  ~~~~~~~~~~~~
  Install this library in a `virtualenv`_ using pip. `virtualenv`_ is a tool to
  create isolated Python environments. The basic problem it addresses is one of
  dependencies and versions, and indirectly permissions.
  With `virtualenv`_, it's possible to install this library without needing system
  install permissions, and without clashing with the installed system
  dependencies.
  Supported Python Versions
  ^^^^^^^^^^^^^^^^^^^^^^^^^
  Python >= 3.7
  Mac/Linux
  ^^^^^^^^^
      pip install virtualenv
      virtualenv <your-env>
      source <your-env>/bin/activate
      <your-env>/bin/pip install grpc-google-iam-v1
  Windows
  ^^^^^^^
      pip install virtualenv
      virtualenv <your-env>
      <your-env>\Scripts\activate
      <your-env>\Scripts\pip.exe install grpc-google-iam-v1
  Next Steps
  ~~~~~~~~~~
  -  Read the `Client Library Documentation`_ for IAM
     API to see other available methods on the client.
  -  Read the `IAM API Product documentation`_ to learn
     more about the product and see How-to Guides.
  -  View this `README`_ to see the full list of Cloud
     APIs that we cover.


pkgId: d4243af109e2874d713df47a2f490263a0c00b263a1560e5b2b69b92c92f28c7
name: python-grpc-google-logging-v2
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: GRPC library for the google-logging-v2 service
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e967eeff-7b8b-4544-a8ba-e365f1546afe
location_href: 00011366-python-grpc-google-logging-v2/python-grpc-google-logging-v2-0.11.1-1.src.rpm
checksum_type: sha256
description:
  gRPC library for google-logging-v2

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

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


pkgId: e29e61f97db57af2a2c19684e3afe72b33eff6610066f2a9686f20cd44313129
name: python-grpc-stubs
arch: src
version: 1.53.0.1
epoch: 0
release: 1
summary: Mypy stubs for gRPC
url: https://github.com/shabbyrobe/grpc-stubs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-06096832-9076-4d60-be4a-2d03338fde2d
location_href: 00010740-python-grpc-stubs/python-grpc-stubs-1.53.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a PEP-561-compliant stub-only package which provides type information of
  [gRPC](https://grpc.io>).
  Install using pip:
      pip install grpc-stubs
  Tests (courtesy of [pytest-mypy-plugins](https://github.com/typeddjango/pytest-mypy-plugins>):
      pip install -r requirements-dev.txt
      ./tools.sh test

  grpc-stubs is tested with 3.7 or later, but ideally it should support Python 3.6 as
  grpc still supports this. Python 3.6 had to be disabled in the tests due to
  various cascading fiascos and a lack of time to contend with them. Feel free
  to submit a PR if you'd like to see it returned, or open issues. Ensure that
  you supply an MRE as per the contributing guidelines below.


  Unfortunately, due to the fussy nature of `grpc` and its dependencies, and the huge amount of time
  required to construct a context in which to verify and debug issues, starting from 2022-04-16, fairly strict issue and
  pull request templates have been added.
  Minimum Reproducible Examples are now a hard requirement for pull requests that touch the typing surface,
  and a soft requirement for issues. PRs without a functioning MRE transfer the burden entirely from the
  contributor to the maintainer, and I simply don't have time to do the deep-dives required to build out MREs
  from scratch when issues inevitably crop up. PRs without a trivially executable MRE will be closed without further
  consideration; of course you are always welcome to reopen once you have added a verified MRE!

  This project uses a slightly old version of https://github.com/TypedDjango/pytest-mypy-plugins for testing.
  All new contributions will be required to include at least one, but probably multiple tests. See
  `typesafety/test_*.yml`.

  PRs containing auto-generated stubs have had to be reverted several times due to issues. Starting
  from 2022-04-16, autogenerated stubs from `mypy-protobuf` will not be accepted without extensive
  tests, and will not be accepted with edit warnings left in. It's ok to use this tool to seed stubs,
  but not to refresh stubs - once contributed to this repo, the stubs should be presumed to have been
  written by hand.

  There are several areas where `grpc-stubs` could use some TLC. If you'd like to help with any
  of this, please reach out!

  It's unlikely I'll be returning to grpc full-time for the foreseeable future, and my knowledge of the
  minutiae fades with each passing year. If anyone wishes to assume maintainership of this project ongoing,
  please reach out.

  - https://github.com/TypedDjango
  - https://github.com/typeddjango/pytest-mypy-plugins
  - https://github.com/typeddjango/awesome-python-stubs


pkgId: af2de837df23f10770db1decb606508b49ee7c85d900688846e0e039b1c52488
name: python-grpcio-debuginfo
arch: aarch64
version: 1.53.0
epoch: 0
release: 1
summary: Debug information for package python-grpcio
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3fbd4df5-1c3a-499e-a1d3-ec64c24c7868
rpm_sourcerpm: python-grpcio-1.53.0-1.src.rpm
location_href: 00008944-python-grpcio/python-grpcio-debuginfo-1.53.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-grpcio.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 4392db5b93b9d295443c07e6a3be59a8d58837c29633cc37b68675bc70091d3a
name: python-grpcio-debugsource
arch: aarch64
version: 1.53.0
epoch: 0
release: 1
summary: Debug sources for package python-grpcio
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3fbd4df5-1c3a-499e-a1d3-ec64c24c7868
rpm_sourcerpm: python-grpcio-1.53.0-1.src.rpm
location_href: 00008944-python-grpcio/python-grpcio-debugsource-1.53.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-grpcio.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 407aabc8e250a1e1cca8d4aed42f20778262b356c0ef5fe89033cd4ca5d45d3c
name: python-grpcio-tools-debuginfo
arch: aarch64
version: 1.53.0
epoch: 0
release: 1
summary: Debug information for package python-grpcio-tools
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5400ddbc-0e27-4a6e-8e33-0eab8b9d5e61
rpm_sourcerpm: python-grpcio-tools-1.53.0-1.src.rpm
location_href: 00009211-python-grpcio-tools/python-grpcio-tools-debuginfo-1.53.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-grpcio-tools.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: dfcf0ed246893778e32a298667b73cd6ad7f21e5fd2f744ffa8b9d3b275b454e
name: python-grpcio-tools-debugsource
arch: aarch64
version: 1.53.0
epoch: 0
release: 1
summary: Debug sources for package python-grpcio-tools
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5400ddbc-0e27-4a6e-8e33-0eab8b9d5e61
rpm_sourcerpm: python-grpcio-tools-1.53.0-1.src.rpm
location_href: 00009211-python-grpcio-tools/python-grpcio-tools-debugsource-1.53.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-grpcio-tools.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: fd6649ea6a4f4ec02ccd2ed08ca8a9fe66fb3c81695a67160f3d3f3f03730c75
name: python-grpclib
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Pure-Python gRPC implementation for asyncio
url: https://github.com/vmagamedov/grpclib
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6098bc5e-a9c8-461b-8b38-c2941ad17302
location_href: 00011550-python-grpclib/python-grpclib-0.4.3-1.src.rpm
checksum_type: sha256
description:
  |project|_ |documentation|_ |version|_ |tag|_ |license|_
  This project is based on `hyper-h2`_ and **requires Python >= 3.7**.
  Example
  ~~~~~~~
  See `examples`_ directory in the project's repository for all available
  examples.


pkgId: 4acb3a3670959f2b8ca7eca86227cf0b600a9c5629e4b2d29da0c16ddcb925ba
name: python-gsd
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: General simulation data file format.
url: https://gsd.readthedocs.io
rpm_license: BSD - 2 clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95658293-9ec6-4bec-8f4a-c01c7056241f
location_href: 00003821-python-gsd/python-gsd-2.8.0-1.src.rpm
checksum_type: sha256
description:
  The **GSD** file format is the native file format for [HOOMD-blue](https://glotzerlab.engin.umich.edu/hoomd-blue/).
  **GSD** files store trajectories of the **HOOMD-blue** system state in a binary file with efficient random access to
  frames. **GSD** allows all particle and topology properties to vary from one frame to the next. Use the **GSD** Python
  API to specify the initial condition for a **HOOMD-blue** simulation or analyze trajectory output with a script. Read a
  **GSD** trajectory with a visualization tool to explore the behavior of the simulation.



  * [GSD documentation](http://gsd.readthedocs.io): Tutorials, Python API, C API, usage information, and format
    specification.
  * [Installation Guide](INSTALLING.rst): Instructions for installing and compiling **GSD**.
  * [HOOMD-blue](https://glotzerlab.engin.umich.edu/hoomd-blue/): Simulation engine that reads and writes **GSD** files.
  * [hoomd-users Google Group](https://groups.google.com/d/forum/hoomd-users):
    Ask questions to the **HOOMD-blue** community.
  * [freud](https://freud.readthedocs.io): A powerful set of tools for analyzing trajectories.
  * [OVITO](https://www.ovito.org/): The Open Visualization Tool works with **GSD** files.
  * [gsd-vmd plugin](https://github.com/mphoward/gsd-vmd): VMD plugin to support **GSD** files.



  Create a hoomd gsd file.
  ```python
  >>> s = gsd.hoomd.Frame()
  >>> s.particles.N = 4
  >>> s.particles.types = ['A', 'B']
  >>> s.particles.typeid = [0,0,1,1]
  >>> s.particles.position = [[0,0,0],[1,1,1], [-1,-1,-1], [1,-1,-1]]
  >>> s.configuration.box = [3, 3, 3, 0, 0, 0]
  >>> traj = gsd.hoomd.open(name='test.gsd', mode='wb')
  >>> traj.append(s)
  ```

  Append frames to a gsd file:
  ```python
  >>> def create_frame(i):
  ...     s = gsd.hoomd.Frame();
  ...     s.configuration.step = i;
  ...     s.particles.N = 4+i;
  ...     s.particles.position = numpy.random.random(size=(4+i,3))
  ...     return s;
  >>> with gsd.hoomd.open('test.gsd', 'ab') as t:
  ...     t.extend( (create_frame(i) for i in range(10)) )
  ...     print(len(t))
  11
  ```

  Randomly index frames:
  ```python
  >>> with gsd.hoomd.open('test.gsd', 'rb') as t:
  ...     frame = t[5]
  ...     print(frame.configuration.step)
  4
  ...     print(frame.particles.N)
  8
  ...     print(frame.particles.position)
  [[ 0.56993282  0.42243481  0.5502916 ]
   [ 0.36892486  0.38167036  0.27310368]
   [ 0.04739023  0.13603486  0.196539  ]
   [ 0.120232    0.91591144  0.99463677]
   [ 0.79806316  0.16991436  0.15228257]
   [ 0.13724308  0.14253527  0.02505   ]
   [ 0.39287439  0.82519054  0.01613089]
   [ 0.23150323  0.95167434  0.7715748 ]]
  ```

  Slice frames:
  ```python
  >>> with gsd.hoomd.open('test.gsd', 'rb') as t:
  ...     for s in t[5:-2]:
  ...         print(s.configuration.step, end=' ')
  4 5 6 7
  ```



  ```python
  with gsd.fl.open(name='file.gsd', mode='wb') as f:
      f.write_chunk(name='position', data=numpy.array([[1,2,3],[4,5,6]], dtype=numpy.float32));
      f.write_chunk(name='angle', data=numpy.array([0, 1], dtype=numpy.float32));
      f.write_chunk(name='box', data=numpy.array([10, 10, 10], dtype=numpy.float32));
      f.end_frame()
  ```

  ```python
  with gsd.fl.open(name='file.gsd', mode='rb') as f:
      for i in range(1,f.nframes):
          position = f.read_chunk(frame=i, name='position');
          do_something(position);
  ```


pkgId: b828c9fa755618a506018815214a25451e9e6a4a7e2eb732d827696c7315b70d
name: python-gsheets
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Pythonic wrapper for the Google Sheets API
url: https://github.com/xflr6/gsheets
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b04be2d8-5f4b-458c-b74c-037810e09e36
location_href: 00010872-python-gsheets/python-gsheets-0.6.1-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |License| |Supported Python| |Wheel|
  |Build| |Codecov| |Readthedocs-stable| |Readthedocs-latest|
  ``gsheets`` is a small wrapper around the `Google Sheets API`_ (v4) to provide
  more convenient access to `Google Sheets`_ from Python scripts.
  `Turn on the API`_, download an OAuth client ID as JSON file, and create a
  ``Sheets`` object from it. Use its index access (``__getitem__``) to retrieve
  SpreadSheet objects by their id, or use ``.get()`` with a sheet URL.
  Iterate over the ``Sheets`` object for all spreadsheets, or fetch spreadsheets
  by title with the ``.find()`` and ``.findall()`` methods.
  SpreadSheet objects are collections of WorkSheets, which provide access to the
  cell values via spreadsheet coordinates/slices (e.g. ``ws['A1']``) and
  zero-based cell position (e.g. ``ws.at(0, 1)``).
  Save WorkSheets (or all from a SpreadSheet) as CSV files with the
  ``.to_csv()``-method. Create ``pandas.DataFrames`` from worksheet with the
  ``.to_frame()``-method.


pkgId: e563a328cc81f657559ca7432ab87f8f17c5e3cb6617a15c4050eee892765da9
name: python-gspread
arch: src
version: 5.8.0
epoch: 0
release: 1
summary: Google Spreadsheets Python API
url: https://github.com/burnash/gspread
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dd4a2561-74ad-4288-9c9e-f9692a644156
location_href: 00009172-python-gspread/python-gspread-5.8.0-1.src.rpm
checksum_type: sha256
description:
  * Google Sheets API v4.
  * Open a spreadsheet by title, key or url.
  * Read, write, and format cell ranges.
  * Sharing and access control.
  * Batching updates.


pkgId: a80b81b45756332ebe6a4880c975abd66dda997579870e89d90f253003238950
name: python-gspread-dataframe
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Read/write gspread worksheets using pandas DataFrames
url: https://github.com/robin900/gspread-dataframe
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d582793c-04a1-420e-bd88-4b7b08d3728d
location_href: 00009593-python-gspread-dataframe/python-gspread-dataframe-3.3.0-1.src.rpm
checksum_type: sha256
description:
  This package allows easy data flow between a worksheet in a Google spreadsheet
  and a Pandas DataFrame. Any worksheet you can obtain using the ``gspread`` package
  can be retrieved as a DataFrame with ``get_as_dataframe``; DataFrame objects can
  be written to a worksheet using ``set_with_dataframe``:
      import pandas as pd
      from gspread_dataframe import get_as_dataframe, set_with_dataframe
      worksheet = some_worksheet_obtained_from_gspread_client
      df = pd.DataFrame.from_records([{'a': i, 'b': i * 2} for i in range(100)])
      set_with_dataframe(worksheet, df)
      df2 = get_as_dataframe(worksheet)
  The ``get_as_dataframe`` function supports the keyword arguments
  that are supported by your Pandas version's text parsing readers,
  such as ``pandas.read_csv``. Consult `your Pandas documentation for a full list of options <https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html>`__. Since the ``'python'`` engine in Pandas is used for parsing,
  only options supported by that engine are acceptable:
      import pandas as pd
      from gspread_dataframe import get_as_dataframe
      worksheet = some_worksheet_obtained_from_gspread_client
      df = get_as_dataframe(worksheet, parse_dates=True, usecols=[0,2], skiprows=1, header=None)
  Formatting Google worksheets for DataFrames
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  If you install the ``gspread-formatting`` package, you can additionally format a Google worksheet to suit the
  DataFrame data you've just written. See the `package documentation for details <https://github.com/robin900/gspread-formatting#formatting-a-worksheet-using-a-pandas-dataframe>`__, but here's a short example using the default formatter:
      import pandas as pd
      from gspread_dataframe import get_as_dataframe, set_with_dataframe
      from gspread_formatting.dataframe import format_with_dataframe
      worksheet = some_worksheet_obtained_from_gspread_client
      df = pd.DataFrame.from_records([{'a': i, 'b': i * 2} for i in range(100)])
      set_with_dataframe(worksheet, df)
      format_with_dataframe(worksheet, df, include_column_header=True)


pkgId: e3907e091359c62995e49df277dd65256cbb23ab0c6e74c1efee42c54b1dcab6
name: python-gspread-pandas
arch: src
version: 3.2.2
epoch: 0
release: 1
url: https://github.com/aiguofer/gspread-pandas
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-343da40f-63ee-4dfb-a980-7b6b896ca5a6
location_href: 00010556-python-gspread-pandas/python-gspread-pandas-3.2.2-1.src.rpm
checksum_type: sha256
summary:
  A package to easily open an instance of a Google spreadsheet and interact with worksheets through Pandas DataFrames.


pkgId: 9dd5b277173a68029abdc413ad870dddb87c602f9672502a6162f08fb55ddfe4
name: python-gsq
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: G Square Conditional Independence Test
url: https://github.com/keiichishima/gsq/
rpm_license: GNU General Public License v2 or later (GPLv2+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-24eb2b15-d723-4648-947c-4c5cd09ebbcf
location_href: 00009623-python-gsq/python-gsq-0.1.6-1.src.rpm
checksum_type: sha256
description:
  This package contains conditional independence test functions using
  the G-square test.



  The code fragments included in this package are logically copied and
  pasted from [the pcalg package for R]
  (http://cran.r-project.org/web/packages/pcalg/index.html) developed by
  Markus Kalisch, Alain Hauser, Martin Maechler, Diego Colombo, Doris
  Entner, Patrik Hoyer, Antti Hyttinen, and Jonas Peters.



  The source code is available at https://github.com/keiichishima/gsq



  Please submit bug reports or patches through the GitHub interface.



  - Joost H. van der Linden, https://github.com/joosthvanderlinden
  - Satoru Kobayashi, https://github.com/cpflat



  Keiichi SHIMA
  / IIJ Innovation Institute Inc.
  / WIDE project


pkgId: 9682635724f472c5e7f9b9680cf1ae0ab7ef27909da5baea4f254edaca6dbce3
name: python-guessit
arch: src
version: 3.7.1
epoch: 0
release: 1
summary: GuessIt - a library for guessing information from video filenames.
url: https://guessit-io.github.io/guessit
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bae520a5-e5dc-4d30-babc-c06cbcdb0614
location_href: 00003826-python-guessit/python-guessit-3.7.1-1.src.rpm
checksum_type: sha256
description:
  This project is hosted on [GitHub](https://github.com/guessit-io/guessit). Feel free to open an issue if you think you have found a bug or something is missing in guessit.
  GuessIt relies on [Rebulk](https://github.com/Toilal/rebulk) project for pattern and rules registration.


pkgId: 65c00f3a407bfc0f42f63a486856dafaa0b061f90970647ebc7a65e19a86c3a1
name: python-guizero
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Python module to allow learners to easily create GUIs
url: https://github.com/lawsie/guizero
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7bf1c6f8-afb9-4ff1-a590-8285a3de9f77
location_href: 00003827-python-guizero/python-guizero-1.4.0-1.src.rpm
checksum_type: sha256
description:
  guizero is designed to allow new learners to quickly and easily create GUIs for their programs.

  There is comprehensive documentation at [lawsie.github.io/guizero](https://lawsie.github.io/guizero/)



  If you can download and unzip a file, you can [install guizero](https://lawsie.github.io/guizero/#easy-install) - **no special permissions or administrator rights are required**.

  If you have administrator rights and are connected to the internet, you can use [pip to quickly install guizero]((https://lawsie.github.io/guizero/#install-using-pip).

  guizero only requires `tkinter` to be installed, which is included with a standard Python installation on all platforms except Linux.
  A python module to allow learners to easily create GUIs. guizero is designed to be used by new learners.



  guizero is simple to use, taking away much of the complexity of creating simple GUIs.

  ```python
  from guizero import App, Text
  app = App(title="Hello world")
  message = Text(app, text="Welcome to the Hello world app!")
  app.display()
  ```


pkgId: 06e2b01eb707b7fd9e6d6e243254dd8da43057675f15f06da766a052ab47c2f1
name: python-gunicorn
arch: src
version: 20.1.0
epoch: 0
release: 1
summary: WSGI HTTP Server for UNIX
url: https://gunicorn.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0da84337-ea1e-4f42-91ba-3b7d7e2e8bb1
location_href: 00008965-python-gunicorn/python-gunicorn-20.1.0-1.src.rpm
checksum_type: sha256
description:
  Gunicorn 'Green Unicorn' is a Python WSGI HTTP Server for UNIX. It's a pre-fork
  worker model ported from Ruby's Unicorn_ project. The Gunicorn server is broadly
  compatible with various web frameworks, simply implemented, light on server
  resource usage, and fairly speedy.
  Feel free to join us in `#gunicorn`_ on Freenode_.


pkgId: 984e20a6e6662460bd6dc954454fe6b1b3f1168a7674632bb93c20dcc5ca6f1c
name: python-guppy3
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: Guppy 3 -- Guppy-PE ported to Python 3
url: https://github.com/zhuyifei1999/guppy3/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fa5683c2-b49d-4c6b-adbf-d1c238708183
location_href: 00010965-python-guppy3/python-guppy3-3.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/travis/com/zhuyifei1999/guppy3?label=tests)](https://travis-ci.com/zhuyifei1999/guppy3) [![Codecov](https://img.shields.io/codecov/c/github/zhuyifei1999/guppy3)](https://codecov.io/gh/zhuyifei1999/guppy3) [![PyPI version](https://img.shields.io/pypi/v/guppy3)](https://pypi.org/project/guppy3/) [![Repology - Repositories](https://img.shields.io/repology/repositories/python:guppy3)](https://repology.org/project/python:guppy3/versions)
  [![PyPI - Implementation](https://img.shields.io/pypi/implementation/guppy3)](https://pypi.org/project/guppy3/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/guppy3)](https://pypi.org/project/guppy3/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/guppy3)](https://pypistats.org/packages/guppy3) [![PyPI - License](https://img.shields.io/pypi/l/guppy3)](https://github.com/zhuyifei1999/guppy3/blob/master/LICENSE)

  A Python Programming Environment & Heap analysis toolset.

  This package contains the following subpackages:
  * etc - Support modules. Contains especially the Glue protocol module.
  * gsl - The Guppy Specification Language implementation. This can be used
    to create documents and tests from a common source.
  * heapy - The heap analysis toolset. It can be used to find information about
    the objects in the heap and display the information in various ways.
  * sets - Bitsets and 'nodesets' implemented in C.

  Guppy 3 is a fork of Guppy-PE, created by Sverker Nilsson for Python 2.



  You should have Python 3.6, 3.7, 3.8, or 3.9. This package is CPython only;
  PyPy and other Python implementations are not supported. Python 2 support
  can be obtained from [guppy-pe](http://guppy-pe.sourceforge.net/) by
  Sverker Nilsson, from which this package is forked.

  To use the graphical browser, Tkinter is needed.
  To use the remote monitor, threading must be available.



  Install with pip by:

  ```
  pip install guppy3
  ```

  Install with conda by:
  ```
  conda install -c conda-forge guppy3
  ```



  The following example shows

  1. How to create the session context: `h=hpy()`
  2. How to show the reachable objects in the heap: `h.heap()`
  4. How to show the shortest paths from the root to the single largest object: `h.heap().byid[0].sp`
  3. How to create and show a set of objects: `h.iso(1,[],{})`

  ```python
  >>> from guppy import hpy; h=hpy()
  >>> h.heap()
  Partition of a set of 30976 objects. Total size = 3544220 bytes.
   Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
       0   8292  27   739022  21    739022  21 str
       1   7834  25   625624  18   1364646  39 tuple
       2   2079   7   300624   8   1665270  47 types.CodeType
       3    400   1   297088   8   1962358  55 type
       4   4168  13   279278   8   2241636  63 bytes
       5   1869   6   269136   8   2510772  71 function
       6    400   1   228464   6   2739236  77 dict of type
       7     79   0   139704   4   2878940  81 dict of module
       8   1061   3    93368   3   2972308  84 types.WrapperDescriptorType
       9    172   1    81712   2   3054020  86 dict (no owner)
  <89 more rows. Type e.g. '_.more' to view.>
  >>> h.heap().byid[0].sp
   0: h.Root.i0_modules['os'].__dict__
  >>> h.iso(1,[],{})
  Partition of a set of 3 objects. Total size = 348 bytes.
   Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
       0      1  33      248  71       248  71 dict (no owner)
       1      1  33       72  21       320  92 list
       2      1  33       28   8       348 100 int
  >>>
  ```

  People have written awesome posts on how to use this toolset, including:
  * [How to use guppy/heapy for tracking down memory usage](https://smira.ru/wp-content/uploads/2011/08/heapy.html)
  * [Debugging Django memory leak with TrackRefs and Guppy](https://opensourcehacker.com/2008/03/07/debugging-django-memory-leak-with-trackrefs-and-guppy/)
  * [Diagnosing Memory "Leaks" in Python](https://chase-seibert.github.io/blog/2013/08/03/diagnosing-memory-leaks-python.html)
  * [Digging into python memory issues in ckan with heapy](https://leastsignificant.blogspot.com/2015/06/digging-into-python-memory-issues-in.html)

  Formal and API documentation are [also available](https://zhuyifei1999.github.io/guppy3/).



  Issues and pull requests are welcome. You may also ask for help on using this
  toolset; however, in such cases, we will only provide guidance, and not profile
  your code for you.

  Please make sure to update tests as appropriate.



  To test if the heapy build and installation was ok, you can do:

  ```python
  >>> from guppy import hpy
  >>> hpy().test()
  Testing sets
  Test #0
  Test #1
  Test #2
  ...
  ```

  There will be several more tests. Some tests may take a while.



  Copyright (C) 2005-2013 Sverker Nilsson, S. Nilsson Computer System AB
  Copyright (C) 2019-2021 YiFei Zhu

  The right is granted to copy, use, modify and redistribute this code
  according to the rules in what is commonly referred to as an MIT
  license.

  *** USE AT YOUR OWN RISK AND BE AWARE THAT THIS IS AN EARLY RELEASE ***


pkgId: 7f64950898dd01e731add4c0543282e8cb2af380ac5131cbe2243c411ba45384
name: python-guppy3-debuginfo
arch: aarch64
version: 3.1.2
epoch: 0
release: 1
summary: Debug information for package python-guppy3
url: https://github.com/zhuyifei1999/guppy3/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fa5683c2-b49d-4c6b-adbf-d1c238708183
rpm_sourcerpm: python-guppy3-3.1.2-1.src.rpm
location_href: 00010965-python-guppy3/python-guppy3-debuginfo-3.1.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-guppy3.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 72fe2a65d740a9d14bc0de909a306731d139255091052a1cffaa854103c8a605
name: python-guppy3-debugsource
arch: aarch64
version: 3.1.2
epoch: 0
release: 1
summary: Debug sources for package python-guppy3
url: https://github.com/zhuyifei1999/guppy3/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fa5683c2-b49d-4c6b-adbf-d1c238708183
rpm_sourcerpm: python-guppy3-3.1.2-1.src.rpm
location_href: 00010965-python-guppy3/python-guppy3-debugsource-3.1.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-guppy3.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 4a4c6611da055d32d192f153a6c35d5eeb4b70303acb76715d001baab0ef63d9
name: python-gwebsockets
arch: src
version: 0.7
epoch: 0
release: 1
summary: GLib based websockets server
url: http://github.com/sugarlabs/gwebsockets
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e7429c1-c956-431c-adb4-06206d6afc31
location_href: 00003828-python-gwebsockets/python-gwebsockets-0.7-1.src.rpm
checksum_type: sha256
description:
  A websocket server written in python. It uses GIO for network communication
  and hence it easily integrates with the GLib mainloop.


pkgId: 55ee9732bf310ff82cdf04e8cb8d2e9a2bf8680e6d181a415b27a1f4bcda8dbf
name: python-gym
arch: src
version: 0.26.2
epoch: 0
release: 1
summary: Gym: A universal API for reinforcement learning environments
url: https://www.gymlibrary.dev/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f9310235-43bb-4aff-b48b-3094080b5b6d
location_href: 00009625-python-gym/python-gym-0.26.2-1.src.rpm
checksum_type: sha256
description:
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://pre-commit.com/) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


pkgId: d79699f931bacedfce09212efeebb812a577f09501bfea6e43aca46813d2c580
name: python-h11
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: A pure-Python, bring-your-own-I/O implementation of HTTP/1.1
url: https://github.com/python-hyper/h11
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-492b8e99-03d1-464b-8f89-524d5c4ac7fd
location_href: 00003830-python-h11/python-h11-0.14.0-1.src.rpm
checksum_type: sha256
description:
  This is a little HTTP/1.1 library written from scratch in Python,
  heavily inspired by `hyper-h2 <https://hyper-h2.readthedocs.io/>`_.
  It's a "bring-your-own-I/O" library; h11 contains no IO code
  whatsoever. This means you can hook h11 up to your favorite network
  API, and that could be anything you want: synchronous, threaded,
  asynchronous, or your own implementation of `RFC 6214
  <https://tools.ietf.org/html/rfc6214>`_ -- h11 won't judge you.
  (Compare this to the current state of the art, where every time a `new
  network API <https://trio.readthedocs.io/>`_ comes along then someone
  gets to start over reimplementing the entire HTTP protocol from
  scratch.) Cory Benfield made an `excellent blog post describing the
  benefits of this approach
  <https://lukasa.co.uk/2015/10/The_New_Hyper/>`_, or if you like video
  then here's his `PyCon 2016 talk on the same theme
  <https://www.youtube.com/watch?v=7cC3_jGwl_U>`_.
  This also means that h11 is not immediately useful out of the box:
  it's a toolkit for building programs that speak HTTP, not something
  that could directly replace ``requests`` or ``twisted.web`` or
  whatever. But h11 makes it much easier to implement something like
  ``requests`` or ``twisted.web``.
  At a high level, working with h11 goes like this:
  1) First, create an ``h11.Connection`` object to track the state of a
     single HTTP/1.1 connection.
  2) When you read data off the network, pass it to
     ``conn.receive_data(...)``; you'll get back a list of objects
     representing high-level HTTP "events".
  3) When you want to send a high-level HTTP event, create the
     corresponding "event" object and pass it to ``conn.send(...)``;
     this will give you back some bytes that you can then push out
     through the network.
  For example, a client might instantiate and then send a
  ``h11.Request`` object, then zero or more ``h11.Data`` objects for the
  request body (e.g., if this is a POST), and then a
  ``h11.EndOfMessage`` to indicate the end of the message. Then the
  server would then send back a ``h11.Response``, some ``h11.Data``, and
  its own ``h11.EndOfMessage``. If either side violates the protocol,
  you'll get a ``h11.ProtocolError`` exception.
  h11 is suitable for implementing both servers and clients, and has a
  pleasantly symmetric API: the events you send as a client are exactly
  the ones that you receive as a server and vice-versa.
  `Here's an example of a tiny HTTP client
  <https://github.com/python-hyper/h11/blob/master/examples/basic-client.py>`_
  It also has `a fine manual <https://h11.readthedocs.io/>`_.


pkgId: 59255d95dccda236f829388404137fa2f37991d453c05ad6268960bbd0282a26
name: python-h2o
arch: src
version: 3.40.0.3
epoch: 0
release: 1
summary: H2O, Fast Scalable Machine Learning, for python
url: https://github.com/h2oai/h2o-3.git
rpm_license: Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3ca57a60-aac6-4305-91aa-dcf5e9ccf048
location_href: 00010006-python-h2o/python-h2o-3.40.0.3-1.src.rpm
checksum_type: sha256
description:
  H2O makes Hadoop do math! H2O scales statistics, machine learning and math over BigData. H2O is extensible and users can build blocks using simple math legos in the core. H2O keeps familiar interfaces like python, R, Excel & JSON so that BigData enthusiasts & experts can explore, munge, model and score datasets using a range of simple to advanced algorithms. Data collection is easy. Decision making is hard. H2O makes it fast and easy to derive insights from your data through faster and better predictive modeling. H2O has a vision of online scoring and modeling in a single platform.


pkgId: 62a0e2468d9e2b172e4463339c39089a50077776ba3efc943c83ba13971ab624
name: python-h5io
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Python Objects Onto HDF5
url: http://h5io.github.io
rpm_license: BSD (3-clause)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-65072351-cb53-495b-a4f5-c1baa2d489e3
location_href: 00003832-python-h5io/python-h5io-0.1.7-1.src.rpm
checksum_type: sha256
description:
  h5io is a package designed to facilitate saving some standard Python
  objects into the forward-compatible HDF5 format. It is a higher-level
  package than ``h5py``.
  Get the latest code
  ^^^^^^^^^^^^^^^^^^^
  To get the latest code using git, simply type::
      git clone git://github.com/h5io/h5io.git
  If you don't have git installed, you can download a zip or tarball
  of the latest code: https://github.com/h5io/h5io/archives/master
  Install h5io
  ^^^^^^^^^^^^
  As any Python packages, to install h5io, go in the source code directory
  and do::
      python setup.py install
  or if you don't have admin access to your python setup (permission denied
  when install) use::
      python setup.py install --user
  You can also install the latest release version with pip::
      pip install h5io --upgrade
  or for the latest development version (the most up to date)::
      pip install -e git+https://github.com/h5io/h5io#egg=h5io-dev --user
  Dependencies
  ^^^^^^^^^^^^
  The required dependencies to build the software are ``h5py`` and ``numpy``.
  ``scipy`` is required for sparse matrix IO support.
  Licensing
  ^^^^^^^^^
  h5io is **BSD-licenced** (3 clause):
      This software is OSI Certified Open Source Software.
      OSI Certified is a certification mark of the Open Source Initiative.
      Copyright (c) 2011, authors of h5io
      All rights reserved.
      Redistribution and use in source and binary forms, with or without
      modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright notice,
        this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright notice,
        this list of conditions and the following disclaimer in the documentation
        and/or other materials provided with the distribution.
      * Neither the names of h5io authors nor the names of any
        contributors may be used to endorse or promote products derived from
        this software without specific prior written permission.
      **This software is provided by the copyright holders and contributors
      "as is" and any express or implied warranties, including, but not
      limited to, the implied warranties of merchantability and fitness for
      a particular purpose are disclaimed. In no event shall the copyright
      owner or contributors be liable for any direct, indirect, incidental,
      special, exemplary, or consequential damages (including, but not
      limited to, procurement of substitute goods or services; loss of use,
      data, or profits; or business interruption) however caused and on any
      theory of liability, whether in contract, strict liability, or tort
      (including negligence or otherwise) arising in any way out of the use
      of this software, even if advised of the possibility of such
      damage.**


pkgId: 93f0306e337bbd55e60f4ba5b2fc3460417150dbfaa52f41abd8325b925ea874
name: python-h5netcdf
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: netCDF4 via h5py
url: https://h5netcdf.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90442ca3-05ed-4659-bf78-3f7b56b8f20d
location_href: 00012731-python-h5netcdf/python-h5netcdf-1.1.0-1.src.rpm
checksum_type: sha256
description:
  A Python interface for the `netCDF4`_ file-format that reads and writes local or
  remote HDF5 files directly via `h5py`_ or `h5pyd`_, without relying on the Unidata
  netCDF library.


pkgId: ac9c03638cfa19109c6aebddb06c6a11b118e9a86a22492bc2b650604daf7c49
name: python-hachoir
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Package of Hachoir parsers used to open binary files
url: http://hachoir.readthedocs.io/
rpm_license: GNU GPL v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1f2f6f9-792c-4505-8087-c61a8bd544bd
location_href: 00010043-python-hachoir/python-hachoir-3.2.0-1.src.rpm
checksum_type: sha256
description:
  *******
  Hachoir
  *******

  .. image:: https://img.shields.io/pypi/v/hachoir.svg
     :alt: Latest release on the Python Cheeseshop (PyPI)
     :target: https://pypi.python.org/pypi/hachoir

  .. image:: https://github.com/vstinner/hachoir/actions/workflows/build.yml/badge.svg
     :alt: Build status of hachoir on GitHub Actions
     :target: https://github.com/vstinner/hachoir/actions

  .. image:: http://unmaintained.tech/badge.svg
     :target: http://unmaintained.tech/
     :alt: No Maintenance Intended

  Hachoir is a Python library to view and edit a binary stream field by field.
  In other words, Hachoir allows you to "browse" any binary stream just like you
  browse directories and files.

  A file is splitted in a tree of fields, where the smallest field is just one
  bit. Examples of fields types: integers, strings, bits, padding types, floats,
  etc. Hachoir is the French word for a meat grinder (meat mincer), which is used
  by butchers to divide meat into long tubes; Hachoir is used by computer
  butchers to divide binary files into fields.

  * `Hachoir website <http://hachoir.readthedocs.io/>`_ (source code, bugs)
  * `Hachoir on GitHub (Source code, bug tracker) <https://github.com/vstinner/hachoir>`_
  * License: GNU GPL v2

  Command line tools using Hachoir parsers:

  * hachoir-grep: find a text pattern in a binary file
  * hachoir-metadata: get metadata from binary files
  * hachoir-strip: modify a file to remove metadata
  * hachoir-urwid: display the content of a binary file in text mode

  Installation instructions: http://hachoir.readthedocs.io/en/latest/install.html

  Hachoir is written for Python 3.6 or newer.


pkgId: e3f7b03d204fce5c16da22c8e870fd71663352b2b15852a4833066234bb889aa
name: python-hacking
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: OpenStack Hacking Guideline Enforcement
url: https://docs.openstack.org/hacking/latest/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc7e3339-9403-4072-9abc-3e7e2815b3e8
location_href: 00003836-python-hacking/python-hacking-5.0.0-1.src.rpm
checksum_type: sha256
description:
  hacking is a set of flake8 plugins that test and enforce the
  `OpenStack StyleGuide <https://docs.openstack.org/hacking/latest/user/hacking.html#styleguide>`_
  Hacking pins its dependencies, as a new release of some dependency can break
  hacking based gating jobs. This is because new versions of dependencies can
  introduce new rules, or make existing rules stricter.


pkgId: 0cee357bc474909f0f43416518e89ff49bf2e4054a392a011fd2101a7f88870c
name: python-hanziconv
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Hanzi Converter for Traditional and Simplified Chinese
url: https://github.com/berniey/hanziconv
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fa8eb07-b199-4b6c-abc1-ce3dcbc134e1
location_href: 00012634-python-hanziconv/python-hanziconv-0.3.2-1.src.rpm
checksum_type: sha256
description:
  This tool converts between simplified and traditional Chinese Characters.
  It consists of two parts:
    - a command line tool: ``hanzi-convert``
    - a python library: ``hanziconv``
  This module supports both Python 2 and 3


pkgId: ba6103ad2751beda4c8ae7892a2156f92bc80a378848a63073a9960b28939a92
name: python-happybase
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A developer-friendly Python library to interact with Apache HBase
url: https://github.com/wbolster/happybase
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f2f78a5a-06db-43e1-86b7-bf54ff882632
location_href: 00011653-python-happybase/python-happybase-1.2.0-1.src.rpm
checksum_type: sha256
description:
  **HappyBase** is a developer-friendly Python_ library to interact with Apache
  HBase_.
  * `Documentation <https://happybase.readthedocs.io/>`_ (Read the Docs)
  * `Downloads <http://pypi.python.org/pypi/happybase/>`_ (PyPI)
  * `Source code <https://github.com/wbolster/happybase>`_ (Github)
     you can generate the HTML documentation by running "make doc" and browsing
     to doc/build/html/index.html to see the result.


pkgId: ea91db396563469b4c7378708de0cd565053a43d88a1bc94e4fec46d3864156c
name: python-hdfs
arch: src
version: 2.7.0
epoch: 0
release: 1
summary: HdfsCLI: API and command line interface for HDFS.
url: https://hdfscli.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f7cf5aa-01be-4c9a-8c70-2f6dfe9f0a25
location_href: 00003842-python-hdfs/python-hdfs-2.7.0-1.src.rpm
checksum_type: sha256
description:
  API and command line interface for HDFS.

  ```
  $ hdfscli --alias=dev

  Welcome to the interactive HDFS python shell.
  The HDFS client is available as `CLIENT`.

  In [1]: CLIENT.list('models/')
  Out[1]: ['1.json', '2.json']

  In [2]: CLIENT.status('models/2.json')
  Out[2]: {
    'accessTime': 1439743128690,
    'blockSize': 134217728,
    'childrenNum': 0,
    'fileId': 16389,
    'group': 'supergroup',
    'length': 48,
    'modificationTime': 1439743129392,
    'owner': 'drwho',
    'pathSuffix': '',
    'permission': '755',
    'replication': 1,
    'storagePolicy': 0,
    'type': 'FILE'
  }

  In [3]: with CLIENT.read('models/2.json', encoding='utf-8') as reader:
    ...:     from json import load
    ...:     model = load(reader)
    ...:
  ```



  * Python (2 and 3) bindings for the [WebHDFS][] (and [HttpFS][]) API,
    supporting both secure and insecure clusters.
  * Command line interface to transfer files and start an interactive client
    shell, with aliases for convenient namenode URL caching.
  * Additional functionality through optional extensions:

    + `avro`, to [read and write Avro files directly from HDFS][].
    + `dataframe`, to [load and save Pandas dataframes][].
    + `kerberos`, to [support Kerberos authenticated clusters][].

  See the [documentation][] to learn more.



  ```sh
  $ pip install hdfs
  ```

  Then hop on over to the [quickstart][] guide. A [Conda
  feedstock](https://github.com/conda-forge/python-hdfs-feedstock) is also
  available.



  HdfsCLI is tested against both [WebHDFS][] and [HttpFS][]. There are two ways
  of running tests (see `scripts/` for helpers to set up a test HDFS cluster):

  ```sh
  $ HDFSCLI_TEST_URL=http://localhost:50070 nosetests # Using a namenode's URL.
  $ HDFSCLI_TEST_ALIAS=dev nosetests # Using an alias.
  ```



  We'd love to hear what you think on the [issues][] page. Pull requests are also
  most welcome!

  [HttpFS]: http://hadoop.apache.org/docs/current/hadoop-hdfs-httpfs/
  [WebHDFS]: http://hadoop.apache.org/docs/current/hadoop-project-dist/hadoop-hdfs/WebHDFS.html
  [read and write Avro files directly from HDFS]: https://hdfscli.readthedocs.io/en/latest/api.html#module-hdfs.ext.avro
  [load and save Pandas dataframes]: https://hdfscli.readthedocs.io/en/latest/api.html#module-hdfs.ext.dataframe
  [support Kerberos authenticated clusters]: https://hdfscli.readthedocs.io/en/latest/api.html#module-hdfs.ext.kerberos
  [documentation]: https://hdfscli.readthedocs.io/
  [quickstart]: https://hdfscli.readthedocs.io/en/latest/quickstart.html
  [issues]: https://github.com/mtth/hdfs/issues


pkgId: 2d80138cbe415e0af55022cc8f5aa870194441776e1c49c7b98fed10c503a7df
name: python-hdfs3
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Python wrappers for libhdfs3, a native HDFS client
url: http://github.com/dask/hdfs3/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d7c2ffd-aec7-4bfc-abcc-48ef5d71b23d
location_href: 00011300-python-hdfs3/python-hdfs3-0.3.1-1.src.rpm
checksum_type: sha256
description:
  |Build Status|
  This project is not undergoing development
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  Pyarrow's JNI `hdfs interface`_ is mature and stable. It also has fewer problems
  with configuration and various security settings, and does not require the complex
  build process of libhdfs3. Therefore, all users who have trouble with hdfs3 are
  recommended to try pyarrow.
  Old README
  ~~~~~~~~~~
  hdfs3 is a lightweight Python wrapper for libhdfs3_, a native C/C++ library to interact with the Hadoop File System (HDFS).
  View the documentation_ for hdfs3.


pkgId: d1d1be7341d06d6bfbef38bb41014fd50f35aca58494116ef0ee409e2a2b9854
name: python-hellosign-python-sdk
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: A Python wrapper for the HelloSign API (http://www.hellosign.com/api)
url: https://github.com/hellosign/hellosign-python-sdk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95d85831-6f8e-4089-9fb2-6de75c61a8c9
location_href: 00012541-python-hellosign-python-sdk/python-hellosign-python-sdk-4.0.0-1.src.rpm
checksum_type: sha256
description:
  A Python wrapper for the [HelloSign API](http://www.hellosign.com/api)

  Install using `easy_install`:
  ````sh
  easy_install hellosign-python-sdk
  ````
  Install using `pip`:
  ````sh
  pip install hellosign-python-sdk
  ````
  Install from code:
  ````sh
  git clone https://github.com/HelloSign/hellosign-python-sdk.git
  cd hellosign-python-sdk
  python setup.py install
  ````

  In your application, import `HSClient`:
  ````python
  from hellosign_sdk import HSClient
  ````
  Then create a HSClient object and pass authentication information to initialize it:
  ````python

  client = HSClient(email_address="api_user@example.com", password="your_password")

  client = HSClient(api_key="your_api_key")

  client = HSClient(access_token="your_api_access_token")
  ````
  Note: In case you initialize the HSClient with all the above credentials, the priority order is as follow: access_token, api_key, then email and password.

  For more information about the wrapper, its methods and parameters visit our detailed API documentation on  [readthedocs](http://hellosign-python-sdk.readthedocs.org/en/v3/py-modindex.html).


  ````python
  account = client.get_account_info()
  ````
  The account information is also stored in `client.account`. For example, to print the `email_address` of your account:
  ````python
  print client.account.email_address
  ````

  ````python
  client.account.callback_url = "https://www.example.com/callback"
  client.update_account_info()
  ````

  ````python
  new_account = client.create_account("new_user@example.com")
  ````


  ````python
  signature_request = client.get_signature_request("fa5c8a0b0f492d768749333ad6fcc214c111e967")
  print signature_request.requester_email_address
  print signature_request.signature_request_id
  ````

  ````python
  signature_request_list = client.get_signature_request_list(page=1)

  for signature_request in signature_request_list:
      print signature_request.signatures[0].signer_name
  ````

  ````python
  files = ["NDA.pdf", "AppendixA.pdf"]
  signers = [
      {"name": "Jack", "email_address": "jack@example.com"},
      {"name": "Jill", "email_address": "jill@example.com"}
  ]
  cc_email_addresses = ["lawyer@hellosign.com", "lawyer@example.com"]

  signature_request = client.send_signature_request(
                                  test_mode=True,
                                  files=None,
                                  file_urls=["http://www.example.com/download/sample.pdf"],
                                  title="NDA with Acme Co.",
                                  subject="The NDA we talked about",
                                  message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                                  signing_redirect_url=None,
                                  signers=signers,
                                  cc_email_addresses=cc_email_addresses)

  signature_request = client.send_signature_request(
                                  test_mode=True,
                                  files=files,
                                  file_urls=None,
                                  title="NDA with Acme Co.",
                                  subject="The NDA we talked about",
                                  message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                                  signing_redirect_url=None,
                                  signers=signers,
                                  cc_email_addresses=cc_email_addresses)
  ````

  ````python
  signers = [
      {"name": "Jack", "email_address": "jack@example.com"},
      {"name": "Jill", "email_address": "jill@example.com"}
  ]
  cc_email_addresses = ["lawyer@hellosign.com", "lawyer@example.com"]
  ccs = [
      { "email_address": "lawyer@hellosign.com", "role_name": "Lawyer 1" },
      { "email_address": "lawyer@example.com", "role_name": "Lawyer 2" }
  ]
  custom_fields = [
      { "Field 1": "Value 1" },
      { "Field 2": "Value 2" }
  ]

  signature_request = client.send_signature_request_with_template(
                                          test_mode=True,
                                          template_id="fa5c8a0b0f492d768749333ad6fcc214c111e967",
                                          title="NDA with Acme Co.",
                                          subject="The NDA we talked about",
                                          message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                                          signing_redirect_url=None,
                                          signers=signers,
                                          ccs=ccs,
                                          custom_fields=custom_fields)
  ````


  ````python
  signers = [
      {"name": "Jack", "email_address": "jack@example.com"},
      {"name": "Jill", "email_address": "jill@example.com"}
  ]
  signature_request = client.send_signature_request_embedded(
                                  test_mode=True,
                                  client_id="YOUR CLIENT ID",
                                  files=["path/to/NDA.pdf"],
                                  title="NDA with Acme Co.",
                                  subject="The NDA we talked about",
                                  message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                                  signing_redirect_url=None
                                  signers=signers,
                                  cc_email_addresses=None,
                                  form_fields_per_document=None)

  for signature in signature_request.signatures:
      embedded_obj = client.get_embedded_object(signature.signature_id)
      sign_url = embedded_obj.sign_url
  ````
  More information about the asscociated front-end code can be found [here](https://www.hellosign.com/api/embeddedSigningWalkthrough#ClientSide)

  ````python

  draft = client.create_embedded_unclaimed_draft(
                      test_mode=True,
                      client_id="YOUR CLIENT ID",
                      requester_email_address="requester@example.com",
                      files=["path/to/NDA.pdf"],
                      draft_type="signature_request",
                      subject="The NDA we talked about",
                      message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                      is_for_embedded_signing=False)
  claim_url = draft.claim_url
  ````
  More information about the associated front-end code can be found [here](https://app.hellosign.com/api/embeddedRequestingWalkthrough#EmbeddedRequestingClientSide)
  Once the user edits the draft in the embedded iFrame and sends the signature request your app callback will receive a `signature_request_sent` event containing a `SignatureRequest` object. If we had used `is_for_embedded_signing=True`, we would want to get the signature ids out of the `SignatureRequest` from that event and fetch the signature urls at this point. In your event callback handler, you will need to do something like this:
  ````python
  client = HSClient(api_key='your_api_key')
  event_data = json.loads(request.POST.get('json'))
  if event_data['event']['event_type'] == 'signature_request_sent':
      sig_req = event_data['signature_request']
      for sig in sig_req['signature_request']['signatures']:
          embedded_obj = client.get_embedded_object(sig['signature_id'])
          sign_url = embedded_obj.sign_url
          
  ````

  You can run the test suite by executing the following commands after you cloned the repo:
  Note that it requires to have a HelloSign account, with at least one template and one api app.
  **WARNING:** We advise against running the tests against your personal account as they perform destructive actions.
  ```
  cd hellosign_sdk
  cp tests/test_helper.sample.py tests/test_helper.py
  HELLOSIGN_API_KEY='YOUR API KEY'
  HELLOSIGN_API_CLIENT_ID='YOUR APP CLIENT ID'
  HELLOSIGN_API_CLIENT_SECRET='YOUR APP CLIENT SECRET'
  nosetests --with-coverage --cover-package=hellosign_sdk --include=hellosign_sdk/tests/unit_tests/* --include=hellosign_sdk/tests/functional_tests/*
  ```


  We do not allow app callbacks (event or OAuth) to be set to localhost. However it is still possible to test callbacks against a local server. Tunneling services such as [ngrok](http://ngrok.com) can help you set this up.

  ```
  The MIT License (MIT)
  Copyright (C) 2015 hellosign.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.
  ```


pkgId: c3fd564be85f1046f8a4055871f315176868ab755dabc3a2c1dd778ad3d24f14
name: python-helpdev
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: HelpDev - Extracts information about the Python environment easily.
url: https://gitlab.com/dpizetta/helpdev
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f852f348-9491-4f41-9d0e-dcc213ab917e
location_href: 00003847-python-helpdev/python-helpdev-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Helping users and developers to get information about the environment to
  report bugs or even test your system without spending a day on it. It can
  get information about hardware, OS, paths, Python distribution and packages,
  including Qt-things. Operates in Linux, Windows and Mac. Working on
  Python 2.7+ and Python 3.4+.
  If you want to get information at runtime of your application, you need
  to call using the same environment (and process) in which your application
  is running. This module can be imported and integrated into your application,
  providing a report about the current environment.
  Some information can be depedent or independent of your Python environment,
  and some others can be dependent your running application. So, there are some
  acronymn used to refer to them:
  - PEI: Python environment independent;
  - PED: Python environment DEPENDENT;
  - PEAD: Python environment and application DEPENDENT.
  **Caution:**
  - This script is not supposed to get personal information using the option
    ``--all``, but you must check the information before using the output.
  - Using the option ``--all-for-sure`` it is added information about paths and
    variables that can show personal information. So, be sure when using this
    option when publishing in the web.
  - I'm not responsible for bad use or problems with the information given by
    this script, but if pointed in the Issues, I can help fixing it.
  Installing, updating and uninstalling

  To install and/or update, do ::
      $ pip install -U helpdev
  To remove ::
      $ pip uninstall helpdev
  Running

  You just need to run in the terminal the line(s) below.
  To get a minimalist output ::
      $ helpdev
  To filter a set of packages to get info, which lists all that starts with
  sphinx, qtpy and pyqt5 ::
      $ helpdev --packages="sphinx.*,qtpy,PYQT5"
  To get a complete output without personal information ::
      $ helpdev --all
  To get a complete output WITH PERSONAL INFORMATION ::
      $ helpdev --all-for-sure
  To get some help information ::
      $ helpdev --help
  Examples from v0.6


pkgId: f15f18c8c45b1bd72cb262d5ab4553655c1d280ad49d04f278787618b6c7ec1c
name: python-heroku3
arch: src
version: 5.2.0
epoch: 0
release: 1
summary: Heroku API Wrapper.
url: https://github.com/martyzz1/heroku3.py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b441733-8235-47b6-91dc-0f86d1acf2eb
location_href: 00009576-python-heroku3/python-heroku3-5.2.0-1.src.rpm
checksum_type: sha256
description:
  This is the updated Python wrapper for the Heroku `API V3. <https://devcenter.heroku.com/articles/platform-api-reference>`_
  The Heroku REST API allows Heroku users to manage their accounts, applications, addons, and
  other aspects related to Heroku. It allows you to easily utilize the Heroku
  platform from your applications.


pkgId: 1c0bcab21d1ed13fda58030539babfd63c434c4ba7b797a8d5e1475abf401b91
name: python-hexbytes
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: hexbytes: Python `bytes` subclass that decodes hex, with a readable console output
url: https://github.com/ethereum/hexbytes
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-da041bcf-22ac-4b5e-bbec-bdb13deb764c
location_href: 00010585-python-hexbytes/python-hexbytes-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Join the chat at https://gitter.im/ethereum/web3.py](https://badges.gitter.im/ethereum/web3.py.svg)](https://gitter.im/ethereum/web3.py?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Build Status](https://circleci.com/gh/ethereum/hexbytes.svg?style=shield)](https://circleci.com/gh/ethereum/hexbytes)
  [![PyPI version](https://badge.fury.io/py/hexbytes.svg)](https://badge.fury.io/py/hexbytes)
  [![Python versions](https://img.shields.io/pypi/pyversions/hexbytes.svg)](https://pypi.python.org/pypi/hexbytes)
  [![Docs build](https://readthedocs.org/projects/hexbytes/badge/?version=latest)](http://hexbytes.readthedocs.io/en/latest/?badge=latest)


  Python `bytes` subclass that decodes hex, with a readable console output

  Read more in the [documentation on ReadTheDocs](https://hexbytes.readthedocs.io/). [View the change log](https://hexbytes.readthedocs.io/en/latest/release_notes.html).



  ```sh
  pip install hexbytes
  ```

  ```py

  >>> HexBytes(b"\x03\x08wf\xbfh\xe7\x86q\xd1\xeaCj\xe0\x87\xdat\xa1'a\xda\xc0 \x01\x1a\x9e\xdd\xc4\x90\x0b\xf1;")
  HexBytes('0x03087766bf68e78671d1ea436ae087da74a12761dac020011a9eddc4900bf13b')


  >>> hb = HexBytes('03087766BF68E78671D1EA436AE087DA74A12761DAC020011A9EDDC4900BF13B')
  HexBytes('0x03087766bf68e78671d1ea436ae087da74a12761dac020011a9eddc4900bf13b')


  >>> hb[0]
  3


  >>> len(hb)
  32


  >>> bytes(hb)
  b"\x03\x08wf\xbfh\xe7\x86q\xd1\xeaCj\xe0\x87\xdat\xa1'a\xda\xc0 \x01\x1a\x9e\xdd\xc4\x90\x0b\xf1;"
  ```



  If you would like to hack on hexbytes, please check out the [Snake Charmers
  Tactical Manual](https://github.com/ethereum/snake-charmers-tactical-manual)
  for information on how we do:

  - Testing
  - Pull Requests
  - Code Style
  - Documentation



  You can set up your dev environment with:

  ```sh
  git clone git@github.com:carver/hexbytes.git
  cd hexbytes
  virtualenv -p python3 venv
  . venv/bin/activate
  pip install -e .[dev]
  ```



  During development, you might like to have tests run on every file save.

  Show flake8 errors on file change:

  ```sh

  when-changed -v -s -r -1 hexbytes/ tests/ -c "clear; flake8 hexbytes tests && echo 'flake8 success' || echo 'error'"
  ```

  Run multi-process tests in one command, but without color:

  ```sh

  pytest --numprocesses=4 --looponfail --maxfail=1

  pytest -n 4 -f --maxfail=1
  ```

  Run in one thread, with color and desktop notifications:

  ```sh
  cd venv
  ptw --onfail "notify-send -t 5000 'Test failure ⚠⚠⚠⚠⚠' 'python 3 test on hexbytes failed'" ../tests ../hexbytes
  ```



  For Debian-like systems:
  ```
  apt install pandoc
  ```

  To release a new version:

  ```sh
  make release bump=$$VERSION_PART_TO_BUMP$$
  ```



  The version format for this repo is `{major}.{minor}.{patch}` for stable, and
  `{major}.{minor}.{patch}-{stage}.{devnum}` for unstable (`stage` can be alpha or beta).

  To issue the next version in line, specify which part to bump,
  like `make release bump=minor` or `make release bump=devnum`. This is typically done from the
  master branch, except when releasing a beta (in which case the beta is released from master,
  and the previous stable branch is released from said branch).

  If you are in a beta version, `make release bump=stage` will switch to a stable.

  To issue an unstable version when the current version is stable, specify the
  new version explicitly, like `make release bump="--new-version 4.0.0-alpha.1 devnum"`


pkgId: b941939f2373b9ec839ccba88bb8fad6d0b77cce2714ab40a56c30adce999fd0
name: python-hexdump
arch: src
version: 3.3
epoch: 0
release: 1
summary: dump binary data to hex format and restore from there
url: https://bitbucket.org/techtonik/hexdump/
rpm_license: Public Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f2b888c3-2733-4312-873d-2763d46d8497
location_href: 00003848-python-hexdump/python-hexdump-3.3-1.src.rpm
checksum_type: sha256
description:
  There are three ways to execute hexdump.py from command line::
     $ python hexdump.py
     $ python hexdump-3.2.zip
     
     $ python -m hexdump
  Dump binary data in hex form::
     $ python -m hexdump binary.dat
     0000000000: 00 00 00 5B 68 65 78 64  75 6D 70 5D 00 00 00 00  ...[hexdump]....
     0000000010: 00 11 22 33 44 55 66 77  88 99 AA BB CC DD EE FF  .."3DUfw........
  Restore binary from a saved hex dump::
     $ python -m hexdump --restore hexdump.txt > binary.dat


pkgId: c166775e8cadc97e0b823a233d84fe3c83138b189ea29aaf1983a8aef34f3316
name: python-hgapi
arch: src
version: 1.7.4
epoch: 0
release: 1
summary: Python API to Mercurial using the command-line interface
url: https://bitbucket.org/haard/hgapi
rpm_license: Do whatever you want, don't blame me
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a1b981e-5ea1-4d39-b662-f81461271ed5
location_href: 00003849-python-hgapi/python-hgapi-1.7.4-1.src.rpm
checksum_type: sha256
description:
  hgapi is a pure-Python API to Mercurial, that uses the command-line
  interface instead of the internal Mercurial API. The rationale for
  this is twofold: the internal API is unstable, and it is GPL.

  hgapi works for any version of Mercurial, including  < 1.9, and will
  instantly reflect any changes to the repository. It also has a really
  permissive license (do whatever you want, don't blame me).

  For example of code that uses this API, take a look at
  https://bitbucket.org/haard/autohook which now uses hgapi
  exclusively.


pkgId: 262f0d2cce8f952a1af5fa83faed8fab70b98d7565cb316a0bd248f02ca1b611
name: python-hgdistver
arch: src
version: 0.25
epoch: 0
release: 1
summary: obsoleted by setuptools_scm
url: http://bitbucket.org/RonnyPfannschmidt/hgdistver/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd45765e-7a9a-4048-90d9-9b05169bd6a7
location_href: 00003850-python-hgdistver/python-hgdistver-0.25-1.src.rpm
checksum_type: sha256
description:
  hgdistver
  ~~~~~~~~~

  .. warning::

    this module is superseeded by setuptools_scm

  This module is a simple drop-in to support setup.py
  in mercurial and git based projects.

  Alternatively it can be a setup time requirement.

  It extracts the last Tag as well as the distance to it in commits
  from the scm, and uses these to calculate a version number

  By default, it will increment the last component of the Version by one
  and append .dev{distance}
  in case the last component is .dev, the version will be unchanged

  Tis requires always using all components in tags (i.e. 2.0.0 instead of 2.0)
  to avoid misstakenly releasing higher version
  (i.e. 2.1.devX instead of 2.0.1.devX)




  It uses 4 strategies to archive its task:

  1. try to directly ask hg for the tag/distance
  2. try to infer it from the `.hg_archival.txt` file
  3. try to read the exact version the cache file if it exists
  4. try to read the exact version from the 'PKG-INFO' file
     as generated by `setup.py sdists` (this is a nasty abuse)

  The most simple usage is::

      from setuptools import setup
      from hgdistver import get_version
      setup(
          ...,
          version=get_version(),
          ...,
      )

  `get_version` takes the optional argument `cachefile`,
  which causes it to store the version info in a python script instead
  of abusing PKG-INFO from a sdist.


  The setup requirement usage is::

      from setuptools import setup
      setup(
          ...,
          get_version_from_hg=True,
          setup_requires=['hgdistver'],
          ...,
      )

  The requirement uses the setup argument cache_hg_version_to instead of cachefile.


pkgId: cf22afeea95f59d79b4fa47ce116a3132524f0d9dd506abee6966cb180c85359
name: python-hglib
arch: src
version: 2.6.2
epoch: 0
release: 1
summary: Mercurial Python library
url: https://bitbucket.org/515k4/hglib/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3e0be75-5df1-4098-b268-1b02d66e2df1
location_href: 00003851-python-hglib/python-hglib-2.6.2-1.src.rpm
checksum_type: sha256
description:
  The hglib is fork of of [hglib](https://www.mercurial-scm.org/wiki/PythonHglib), which is library with a fast, convenient interface to Mercurial. It uses Mercurial's command server for communication with hg.

  Only difference for now is just name of the package and updated tests.



  ```python
  import hglib

  client = hglib.open(path)
  log = client.log(revrange="tip")
  print(log)
  ```



  * Python 2.7 or 3.5



  MIT



  Michal Siska <michal.515k4@gmail.com>


pkgId: fc7e7d1716a9fb1f7a653f65feda6cdf7537288c8464c067f9e1ab2fafd4179a
name: python-hijri-converter
arch: src
version: 2.2.4
epoch: 0
release: 1
summary: Accurate Hijri-Gregorian dates converter based on the Umm al-Qura calendar
url: https://github.com/mhalshehri/hijri-converter
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e97fd06e-8547-45c1-bbdd-42b5e9d5b6dd
location_href: 00009380-python-hijri-converter/python-hijri-converter-2.2.4-1.src.rpm
checksum_type: sha256
description:
  <!-- start description -->

  A Python package to convert accurately between Hijri and Gregorian dates using
  the Umm al-Qura calendar.

  <!-- end description -->

  [![Build Status](https://img.shields.io/github/workflow/status/mhalshehri/hijri-converter/Release)][build]
  [![Coverage Status](https://img.shields.io/badge/coverage-100%25-success)][coverage]
  [![Code Quality](https://img.shields.io/codefactor/grade/github/mhalshehri/hijri-converter/main?&label=codefactor)][quality]
  [![Docs Status](https://img.shields.io/readthedocs/hijri-converter/stable)][docs]
  [![PyPI Downloads](https://img.shields.io/pypi/dm/hijri-converter?color=blue)][downloads]
  [![PyPI Version](https://img.shields.io/pypi/v/hijri-converter)][pypi-version]
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/hijri-converter)][conda-version]
  [![Package License](https://img.shields.io/github/license/mhalshehri/hijri-converter)][license]

  [build]:
    https://github.com/mhalshehri/hijri-converter/actions/workflows/release.yml
  [coverage]:
    https://github.com/mhalshehri/hijri-converter/actions/workflows/release.yml
  [quality]:
    https://www.codefactor.io/repository/github/mhalshehri/hijri-converter/overview/main
  [docs]: https://hijri-converter.readthedocs.io
  [downloads]: https://pypistats.org/packages/hijri-converter
  [pypi-version]: https://pypi.python.org/pypi/hijri-converter
  [conda-version]: https://anaconda.org/conda-forge/hijri-converter
  [license]: https://github.com/mhalshehri/hijri-converter/blob/main/LICENSE

  <!-- start summary -->



  - Accurate and verified date conversion.
  - Optimized code performance compared to similar packages.
  - Intuitive, clean, and easy-to-use interface.
  - Most of the methods and formats are similar to those of standard library.
  - Multilingual representation of weekday names, months, and calendar era
    notations.
  - Easily extendable to support other natural languages.
  - Rich comparison between dates.
  - Validation of input dates.
  - Works on Python 3.6+ with zero dependencies.
  - Thoroughly tested with 100% test coverage.



  - The date range supported by converter is limited to the period from the
    beginning of 1343 AH (1 August 1924 CE) to the end of 1500 AH (16 November
    2077 CE).
  - The conversion is not intended for religious purposes where sighting of the
    lunar crescent at the beginning of Hijri month is still preferred.



  To install using `pip`, run:

  ```shell
  pip install hijri-converter
  ```

  To install using `conda`, run:

  ```shell
  conda install -c conda-forge hijri-converter
  ```



  ```python
  from hijri_converter import Hijri, Gregorian



  g = Hijri(1403, 2, 17).to_gregorian()


  h = Gregorian(1982, 12, 2).to_hijri()
  ```

  <!-- end summary -->



  Please see <https://hijri-converter.readthedocs.io> for full documentation of
  this package, including background, benchmarking, usage examples and API
  reference.



  This project is licensed under the terms of the MIT license.



  - [R.H. van Gent](http://www.staff.science.uu.nl/~gent0113) &mdash; inspiration,
    scientific guidance and resources.
  - [@AZalshehri7](https://github.com/AZalshehri7) &mdash; support in dates review
    and conversion accuracy verification.


pkgId: 18d50fac29542c01c59768f913686b898ddb5e03d69cd8a902ccee86a2be16ac
name: python-hikvision
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Provides a python interface to interact with a hikvision camera
url: https://github.com/fbradyirl/hikvision
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5574ff0f-ef1b-4046-8122-f8ad26b8250c
location_href: 00003853-python-hikvision/python-hikvision-2.0.4-1.src.rpm
checksum_type: sha256
description:
  ```python
  git clone --recursive git@github.com:fbradyirl/hikvision.git
  cd hikvision

  pip install -r requirements.txt
  pip install -e .
  ```

  Variables:
  ```python
  import hikvision.api





  hik_camera = hikvision.api.CreateDevice('192.168.2.5', username='admin', password='12345')
  hik_camera.enable_motion_detection()
  hik_camera.disable_motion_detection()
  hik_camera.is_motion_detection_enabled()
  ```
  * `host` (*Required) : This is the IP address of your Hikvision camera. Example: 192.168.1.32
  * `username` (*Required) : Your Hikvision camera username
  * `password` (*Required) : Your Hikvision camera username


pkgId: f14077acf88ed65d918327f38604ce417507e749af9a14989b1d7a52f7367efa
name: python-hiredis
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: Python wrapper for hiredis
url: https://github.com/redis/hiredis-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-172b8da9-81c1-48ac-8b21-96d56f5d9cbf
location_href: 00009358-python-hiredis/python-hiredis-2.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/redis/hiredis-py/actions/workflows/integration.yaml/badge.svg)](https://github.com/redis/hiredis-py/actions/workflows/integration.yaml)
  [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)

  Python extension that wraps protocol parsing code in [hiredis][hiredis].
  It primarily speeds up parsing of multi bulk replies.

  [hiredis]: http://github.com/redis/hiredis



  hiredis-py is available on [PyPI](https://pypi.org/project/hiredis/), and can be installed via:

  ```bash
  pip install hiredis
  ```


  Building this repository requires a recursive checkout of submodules, and building hiredis. The following example shows how to clone, compile, and run tests. Please note - you will need the gcc installed.

  ```bash
  git clone --recursse-submodules https://github.com/redis/hiredis-py
  python setup.py build_ext --inplace
  pytest
  ```



  hiredis-py requires **Python 3.7+**.

  Make sure Python development headers are available when installing hiredis-py.
  On Ubuntu/Debian systems, install them with `apt-get install python3-dev`.



  The `hiredis` module contains the `Reader` class. This class is responsible for
  parsing replies from the stream of data that is read from a Redis connection.
  It does not contain functionality to handle I/O.



  The `Reader` class has two methods that are used when parsing replies from a
  stream of data. `Reader.feed` takes a string argument that is appended to the
  internal buffer. `Reader.gets` reads this buffer and returns a reply when the
  buffer contains a full reply. If a single call to `feed` contains multiple
  replies, `gets` should be called multiple times to extract all replies.

  Example:

  ```python
  >>> reader = hiredis.Reader()
  >>> reader.feed("$5\r\nhello\r\n")
  >>> reader.gets()
  b'hello'
  ```

  When the buffer does not contain a full reply, `gets` returns `False`.
  This means extra data is needed and `feed` should be called again before calling
  `gets` again. Alternatively you could provide custom sentinel object via parameter,
  which is useful for RESP3 protocol where native boolean types are supported:

  Example:

  ```python
  >>> reader.feed("*2\r\n$5\r\nhello\r\n")
  >>> reader.gets()
  False
  >>> reader.feed("$5\r\nworld\r\n")
  >>> reader.gets()
  [b'hello', b'world']
  >>> reader = hiredis.Reader(notEnoughData=Ellipsis)
  >>> reader.gets()
  Ellipsis
  ```



  `hiredis.Reader` is able to decode bulk data to any encoding Python supports.
  To do so, specify the encoding you want to use for decoding replies when
  initializing it:

  ```python
  >>> reader = hiredis.Reader(encoding="utf-8", errors="strict")
  >>> reader.feed(b"$3\r\n\xe2\x98\x83\r\n")
  >>> reader.gets()
  '☃'
  ```

  Decoding of bulk data will be attempted using the specified encoding and
  error handler. If the error handler is `'strict'` (the default), a
  `UnicodeDecodeError` is raised when data cannot be dedcoded. This is identical
  to Python's default behavior. Other valid values to `errors` include
  `'replace'`, `'ignore'`, and `'backslashreplace'`. More information on the
  behavior of these error handlers can be found
  [here](https://docs.python.org/3/howto/unicode.html#the-string-type).


  When the specified encoding cannot be found, a `LookupError` will be raised
  when calling `gets` for the first reply with bulk data.



  When a protocol error occurs (because of multiple threads using the same
  socket, or some other condition that causes a corrupt stream), the error
  `hiredis.ProtocolError` is raised. Because the buffer is read in a lazy
  fashion, it will only be raised when `gets` is called and the first reply in
  the buffer contains an error. There is no way to recover from a faulty protocol
  state, so when this happens, the I/O code feeding data to `Reader` should
  probably reconnect.

  Redis can reply with error replies (`-ERR ...`). For these replies, the custom
  error class `hiredis.ReplyError` is returned, **but not raised**.

  When other error types should be used (so existing code doesn't have to change
  its `except` clauses), `Reader` can be initialized with the `protocolError` and
  `replyError` keywords. These keywords should contain a *class* that is a
  subclass of `Exception`. When not provided, `Reader` will use the default
  error types.



  The repository contains a benchmarking script in the `benchmark` directory,
  which uses [gevent](http://gevent.org/) to have non-blocking I/O and redis-py
  to handle connections. These benchmarks are done with a patched version of
  redis-py that uses hiredis-py when it is available.

  All benchmarks are done with 10 concurrent connections.

  * SET key value + GET key
    * redis-py: 11.76 Kops
    * redis-py *with* hiredis-py: 13.40 Kops
    * improvement: **1.1x**

  List entries in the following tests are 5 bytes.

  * LRANGE list 0 **9**:
    * redis-py: 4.78 Kops
    * redis-py *with* hiredis-py: 12.94 Kops
    * improvement: **2.7x**
  * LRANGE list 0 **99**:
    * redis-py: 0.73 Kops
    * redis-py *with* hiredis-py: 11.90 Kops
    * improvement: **16.3x**
  * LRANGE list 0 **999**:
    * redis-py: 0.07 Kops
    * redis-py *with* hiredis-py: 5.83 Kops
    * improvement: **83.2x**

  Throughput improvement for simple SET/GET is minimal, but the larger multi bulk replies
  get, the larger the performance improvement is.



  This code is released under the BSD license, after the license of hiredis.


pkgId: 1fd54be8aac767733c4fb7b74ec22b3354dde98c9c1c369fd447f2ac9bec3f18
name: python-hiredis-debuginfo
arch: aarch64
version: 2.2.2
epoch: 0
release: 1
summary: Debug information for package python-hiredis
url: https://github.com/redis/hiredis-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-172b8da9-81c1-48ac-8b21-96d56f5d9cbf
rpm_sourcerpm: python-hiredis-2.2.2-1.src.rpm
location_href: 00009358-python-hiredis/python-hiredis-debuginfo-2.2.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-hiredis.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 8092d85ebfb21ea6a7e4a92943a65085d5e9c89bc585eaa12c09af70c0056670
name: python-hiredis-debugsource
arch: aarch64
version: 2.2.2
epoch: 0
release: 1
summary: Debug sources for package python-hiredis
url: https://github.com/redis/hiredis-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-172b8da9-81c1-48ac-8b21-96d56f5d9cbf
rpm_sourcerpm: python-hiredis-2.2.2-1.src.rpm
location_href: 00009358-python-hiredis/python-hiredis-debugsource-2.2.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-hiredis.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: edc0482ef2965a32b4c4f61d975999f697acb3f15ec82d0dc48af1f8ddf11bc2
name: python-hjson
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Hjson, a user interface for JSON.
url: http://github.com/hjson/hjson-py
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-599fef2f-f143-4331-94ab-d1d351e2b46c
location_href: 00010617-python-hjson/python-hjson-3.1.0-1.src.rpm
checksum_type: sha256
description:
  `Hjson`_, a user interface for JSON
  Hjson works with Python 2.5+ and Python 3.3+ (based on `simplejson`_)


pkgId: 0875fda75b7c762fd60f7e52903538239bd814965dabb3c599799e71fb477dc1
name: python-hkdf
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: HMAC-based Extract-and-Expand Key Derivation Function (HKDF)
url: https://github.com/casebeer/python-hkdf
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-837d30cf-6a07-4ad7-9b50-e87e2c7a6e84
location_href: 00003854-python-hkdf/python-hkdf-0.0.3-1.src.rpm
checksum_type: sha256
description:
  This module implements the HMAC Key Derivation function, defined at
      http://tools.ietf.org/html/draft-krawczyk-hkdf-01
  There are two interfaces: a functional interface, with separate extract
  and expand functions as defined in the draft RFC, and a wrapper class for
  these functions.


pkgId: 7df7e7b07d63044ca4b887df681be4ca537328d3c4afad171843d089826a45c8
name: python-hl7
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Python library parsing HL7 v2.x messages
url: http://python-hl7.readthedocs.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f00c3cc-6e74-4531-9172-5747e3145a74
location_href: 00003855-python-hl7/python-hl7-0.4.5-1.src.rpm
checksum_type: sha256
description:
  python-hl7 is a simple library for parsing messages of Health Level 7
  (HL7) version 2.x into Python objects.

  * Documentation: http://python-hl7.readthedocs.org
  * Source Code: http://github.com/johnpaulett/python-hl7


pkgId: c9a6a66aa30c74b222409589696dd83aa2fc148a12e01f2ace6df24156bdff24
name: python-hmsclient
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A package interact with the Hive metastore via the Thrift protocol
url: https://github.com/gglanzani/hmsclient
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f270c63-36fa-4338-b96d-b81ce157d19a
location_href: 00011029-python-hmsclient/python-hmsclient-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This project aims to be an up to date Python client to interact with the Hive metastore
  using the Thrift protocol.


pkgId: 722e93a6c33dec428b99ebb3a0a939b0562c512db854d58045d8e029425b412e
name: python-hole
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Python API for interacting with *hole.
url: https://github.com/home-assistant-ecosystem/python-hole
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8fa450b6-3426-42fc-aaf7-16de230ea2a4
location_href: 00003857-python-hole/python-hole-0.8.0-1.src.rpm
checksum_type: sha256
description:
  Python API for interacting with a xyz-hole instance. You know the thing that is
  blocking Ads by manipulating your DNS requests and run on your single board
  computer or on other hardware with different operating systems.
  This module is consuming the details provided by the endpoint ``api.php`` only
  for now.
  If you wonder why the weird name and that the usage of xzy-hole instead of the
  real name, please contact the trademark holder. They were unhappy with original
  name of the module and came up with very funny ideas which were not feasible
  or match the existing naming standards. Also, it should remind us that a
  community is a vital part of every Open Source project.
  This module is not supported or endorsed by that particular trademark holder.
  The development happens independently, they are not providing resources and
  the module may no longer work if they breaking their API endpoint.


pkgId: 1ad21848fa8a468023821d0ca37625b6f627f325b671d25e66f6a0e88fe424bd
name: python-hologram
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: JSON schema generation from dataclasses
url: https://github.com/fishtown-analytics/hologram
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61ec6f66-3c08-46d2-9ffb-e6b3b6d327f1
location_href: 00009641-python-hologram/python-hologram-0.0.16-1.src.rpm
checksum_type: sha256
description:
  Hologram is a lightweight library to generate Draft 7 compatible JSON Schemas from python 3.7 dataclasses. Python 3.6 is supported through the [dataclasses backport](https://github.com/ericvsmith/dataclasses). It is forked from [dataclasses-jsonschema](https://github.com/s-knibbs/dataclasses-jsonschema) created by [s-knibbs](https://github.com/s-knibbs).


pkgId: 2cf4b1853d95b0e0ed88791365237cbd589900acd38b7a4c2f9f1d39e5635416
name: python-homeconnect
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Python client for the BSH Home Connect REST API
url: https://github.com/DavidMStraub/homeconnect
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6d293bf-d883-4aab-975f-d58d35ea1d7b
location_href: 00003859-python-homeconnect/python-homeconnect-0.7.2-1.src.rpm
checksum_type: sha256
description:
  Simple Python client for the BSH Home Connect REST API implementing OAuth 2 authentication, REST calls, and SSE event stream parsing.



  To use this library, you have to sign up to the [Home Connect Developer Portal](https://developer.home-connect.com/) and register a new application
  to get a client ID, client secret, and redirect URI.

  ```python
  from homeconnect import HomeConnect
  hc = HomeConnect(my_clientid, my_clientsecret, my_redirecturi)

  print(hc.get_authurl())

  hc.get_token(auth_result)

  hc.get_appliances()
  ```



  The package and its author are not affiliated with BSH or Home Connect. Use at your own risk.



  The package is released under the MIT license.


pkgId: 892aef2de6145a5fadd754178eb8c4636c1acbc4932659f5dc72a0d2c4072ed7
name: python-hs-dbus-signature
arch: src
version: 0.7
epoch: 0
release: 1
summary: dbus signature hypothesis strategy generator
url: https://github.com/stratis-storage/hs-dbus-signature
rpm_license: MPL v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c62654fa-3a3e-40e2-ad4b-674c1e1277bd
location_href: 00003862-python-hs-dbus-signature/python-hs-dbus-signature-0.7-1.src.rpm
checksum_type: sha256
description:
  This package contains a Hypothesis strategy for generating DBus signatures.
  An informal specification of DBus signatures is available at:
  https://dbus.freedesktop.org/doc/dbus-specification.html.
  The strategy is intended to be both sound and complete. That is, it should
  never generate an invalid DBus signature and it should be capable, modulo
  size constraints, of generating any valid DBus signature.


pkgId: 67c7772cad4971631662d70d0115cf1a5b7a650962aab7792f42fcf5fa236967
name: python-hstspreload
arch: src
version: 2023.1.1
epoch: 0
release: 1
summary: Chromium HSTS Preload list as a Python package
url: https://github.com/sethmlarson/hstspreload
rpm_license: BSD-3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6196e3f5-5606-442b-a582-104e16b12117
location_href: 00003863-python-hstspreload/python-hstspreload-2023.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/hstspreload)](https://pypi.org/project/hstspreload)
  [![Downloads](https://pepy.tech/badge/hstspreload)](https://pepy.tech/project/hstspreload)
  ![CI](https://img.shields.io/github/workflow/status/sethmlarson/hstspreload/CI/master)

  Chromium HSTS Preload list as a Python package.

  Install via `python -m pip install hstspreload`

  See https://hstspreload.org for more information regarding the list itself.



  The package provides a single function: `in_hsts_preload()` which takes an
  IDNA-encoded host and returns either `True` or `False` regarding whether
  that host should be only accessed via HTTPS.



  This package is built entirely by an automated script running once a month.
  If you need a release sooner of the package please reach out and I'll trigger a release manually.

  This script gathers the HSTS Preload list by monitoring
  [this file in the Chromium repository](https://chromium.googlesource.com/chromium/src/+/main/net/http/transport_security_state_static.json). Changes to the HSTS Preload list can be seen in the history of that file.



  BSD-3


pkgId: 3cea3a709d9d5f31370a085197a51f1a1745d6106ab07bf1b6bb70fca6b27052
name: python-html-telegraph-poster
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Posts your html to telegra.ph blogging service
url: https://github.com/mercuree/html-telegraph-poster
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-89d0f378-03d8-42e5-95dc-d33ed16d61cc
location_href: 00010972-python-html-telegraph-poster/python-html-telegraph-poster-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![build](https://github.com/mercuree/html-telegraph-poster/actions/workflows/python-package.yml/badge.svg)](https://github.com/mercuree/html-telegraph-poster/actions/workflows/python-package.yml)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/html-telegraph-poster?master)](https://pypi.org/project/html-telegraph-poster/)



  Simple python function to post plain html text to https://telegra.ph/.
  Telegra.ph allows `<a>, <blockquote>, <br>, <em>, <figure>, <h3>, <h4>, <img>, <p>, <strong>, ` elements.
  It also supports embedded youtube and vimeo iframe tags.

  About telegram telegra.ph service https://telegram.org/blog/instant-view


  * lxml
  * requests
  * requests_toolbelt


  ```Shell
  pip install html-telegraph-poster
  ```


  ```python
  >>> from html_telegraph_poster import TelegraphPoster
  >>> t = TelegraphPoster(use_api=True)
  >>> t.create_api_token('Elon Musk', 'Elon', 'https://www.spacex.com/') # second and third params are optional
  {'access_token': '9f3bab568f*************', 'auth_url': 'https://edit.telegra.ph/auth/HFYo***********', 'author_name': 'Elon', 'short_name': 'Elon Musk', 'author_url': 'https://www.spacex.com/'}
  >>> t.post(title='Just another funny joke', author='by me', text='<blockquote>Really hard way</blockquote>')
  {'path': 'Just-another-funny-joke-06-05-4', 'url': 'http://telegra.ph/Just-another-funny-joke-06-05-4'}
  ```

  ```python
  >>> t = TelegraphPoster(use_api=True, telegraph_api_url='https://api.graph.org')
  ```

  ```python
  >>> t.edit(text=t.text + '<p>some text at the end</p>')
  {'path': 'Just-another-funny-joke-06-05-4', 'url': 'http://telegra.ph/Just-another-funny-joke-06-05-4'}
  ```

  ```python
  >>> t.edit(text="<p>new text</p>", path='/Another-one-page-06-05')
  {'path': 'Another-one-page-06-05', 'url': 'http://telegra.ph/Another-one-page-06-05'}
  ```


  Actually it's a good idea to generate access token and put it inside environment variables.
  This command will generate .env file or append  TELEGRAPH_ACCESS_TOKEN at the end of it.
  Note: script will not set environment variable. You can use [python-dotenv](https://github.com/theskumar/python-dotenv),
  set it manually or hardcode it when call `TelegraphPoster(access_token='access_token_string')`
  ```Shell
  python -m html_telegraph_poster.create_account "Elon Musk" "Elon" "https://www.spacex.com/"
  ```


  ```python

  from html_telegraph_poster.upload_images import upload_image


  upload_image("file_path.jpg")


  upload_image("http://example.com/img.png")


  upload_image("http://example.com/img.png", get_timeout=(5, 5), upload_timeout=(5, 5))

  ```

  Utils module provides ability to make some pre-process steps before document is passed to the converter.

  ```python
  from html_telegraph_poster.utils import DocumentPreprocessor

  dp = DocumentPreprocessor(html_string)
  dp.upload_all_images()
  dp.get_processed_html() # this should return html string with uploaded and replaced image urls
  ```
  Optionally you can pass base_url if the document contains images with relative paths
  ```python
  dp.upload_all_images(base_url='https://example.com')
  dp.get_processed_html()
  ```


pkgId: f82f5132698833f275ef4abf48bb8ea7c5bac6598f6c433c5040141cdf1870e2
name: python-html2text
arch: src
version: 2020.1.16
epoch: 0
release: 1
summary: Turn HTML into equivalent Markdown-structured text.
url: https://github.com/Alir3z4/html2text/
rpm_license: GNU GPL 3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d1506b6-b266-4ff4-bde0-24808e21a990
location_href: 00003864-python-html2text/python-html2text-2020.1.16-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://secure.travis-ci.org/Alir3z4/html2text.png)](https://travis-ci.org/Alir3z4/html2text)
  [![Coverage Status](https://coveralls.io/repos/Alir3z4/html2text/badge.png)](https://coveralls.io/r/Alir3z4/html2text)
  [![Downloads](http://badge.kloud51.com/pypi/d/html2text.png)](https://pypi.org/project/html2text/)
  [![Version](http://badge.kloud51.com/pypi/v/html2text.png)](https://pypi.org/project/html2text/)
  [![Wheel?](http://badge.kloud51.com/pypi/wheel/html2text.png)](https://pypi.org/project/html2text/)
  [![Format](http://badge.kloud51.com/pypi/format/html2text.png)](https://pypi.org/project/html2text/)
  [![License](http://badge.kloud51.com/pypi/license/html2text.png)](https://pypi.org/project/html2text/)


  html2text is a Python script that converts a page of HTML into clean, easy-to-read plain ASCII text. Better yet, that ASCII also happens to be valid Markdown (a text-to-HTML format).


  Usage: `html2text [filename [encoding]]`

  | Option                                                 | Description
  |--------------------------------------------------------|---------------------------------------------------
  | `--version`                                            | Show program's version number and exit
  | `-h`, `--help`                                         | Show this help message and exit
  | `--ignore-links`                                       | Don't include any formatting for links
  |`--escape-all`                                          | Escape all special characters.  Output is less readable, but avoids corner case formatting issues.
  | `--reference-links`                                    | Use reference links instead of links to create markdown
  | `--mark-code`                                          | Mark preformatted and code blocks with [code]...[/code]

  For a complete list of options see the [docs](https://github.com/Alir3z4/html2text/blob/master/docs/usage.md)


  Or you can use it from within `Python`:

  ```
  >>> import html2text
  >>>
  >>> print(html2text.html2text("<p><strong>Zed's</strong> dead baby, <em>Zed's</em> dead.</p>"))
  **Zed's** dead baby, _Zed's_ dead.

  ```


  Or with some configuration options:
  ```
  >>> import html2text
  >>>
  >>> h = html2text.HTML2Text()
  >>> # Ignore converting links from HTML
  >>> h.ignore_links = True
  >>> print h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!")
  Hello, world!

  >>> print(h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!"))

  Hello, world!

  >>> # Don't Ignore links anymore, I like links
  >>> h.ignore_links = False
  >>> print(h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!"))
  Hello, [world](https://www.google.com/earth/)!

  ```

  *Originally written by Aaron Swartz. This code is distributed under the GPLv3.*




  `html2text` is available on pypi
  https://pypi.org/project/html2text/

  ```
  $ pip install html2text
  ```




      tox

  To see the coverage results:

      coverage html

  then open the `./htmlcov/index.html` file in your browser.



  Documentation lives [here](https://github.com/Alir3z4/html2text/blob/master/docs/usage.md)


pkgId: e2161a468683b8a4afcb6b09baa8f91c76a117056b41d374a12333d8c8a0fe10
name: python-html5lib
arch: src
version: 1.1
epoch: 0
release: 1
summary: HTML parser based on the WHATWG HTML specification
url: https://github.com/html5lib/html5lib-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b5919f8b-a58a-44c2-bcb5-d3430326a52a
location_href: 00009126-python-html5lib/python-html5lib-1.1-1.src.rpm
checksum_type: sha256
description:
  html5lib is a pure-python library for parsing HTML. It is designed to
  conform to the WHATWG HTML specification, as is implemented by all major
  web browsers.


pkgId: a99aa5ed05aad2f40301f2fa489e549b75a66ba624d1ea92f5b46f4139efcbaf
name: python-htmlmin
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: An HTML Minifier
url: https://htmlmin.readthedocs.io/en/latest/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76404c78-1093-4ae9-81f8-26a46cb91bcf
location_href: 00003866-python-htmlmin/python-htmlmin-0.1.12-1.src.rpm
checksum_type: sha256
description:
  A configurable HTML Minifier with safety features.

  .. image:: https://travis-ci.org/mankyd/htmlmin.png?branch=master
     :target: http://travis-ci.org/mankyd/htmlmin

  Documentation: https://htmlmin.readthedocs.io/en/latest/


pkgId: 7878169e22d0c378e5666ffbf392f5abead2ac82926b5307d4d06d3b56c9181f
name: python-htpasswd
arch: src
version: 2.3
epoch: 0
release: 1
summary: Library to work with htpasswd user (basic authorization) and group files.
url: https://github.com/thesharp/htpasswd
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8bf58183-71a1-4ed8-9344-e5cb3411345e
location_href: 00010430-python-htpasswd/python-htpasswd-2.3-1.src.rpm
checksum_type: sha256
description:
  **htpasswd** is a library for working with htpasswd user (only basic authorization) and group files. It supports CRYPT and MD5 encryption methods. To actually use MD5 encryption method you *MUST* have an ``openssl`` binary installed into system ``$PATH``.


  - Python 2.7 or 3.3 or 3.4
  - [orderedmultidict](http://pypi.python.org/pypi/orderedmultidict/0.7) >= 0.7
  - [future](https://pypi.python.org/pypi/future)
  - [nose](http://pypi.python.org/pypi/nose/) >= 1.1.2 (for tests)


      import htpasswd

      with htpasswd.Basic("/path/to/user.db") as userdb:
          try:
              userdb.add("bob", "password")
          except htpasswd.basic.UserExists, e:
              print e
          try:
              userdb.change_password("alice", "newpassword")
          except htpasswd.basic.UserNotExists, e:
              print e

      with htpasswd.Group("/path/to/group.db") as groupdb:
          try:
              groupdb.add_user("bob", "admins")
          except htpasswd.group.UserAlreadyInAGroup, e:
              print e
          try:
              groupdb.delete_user("alice", "managers")
          except htpasswd.group.UserNotInAGroup, e:
              print e

  To use MD5 encryotion, add ``mode="md5"`` to the constructor:

      with htpasswd.Basic("/path/to/user.db", mode="md5") as userdb




  - ``__contains__(user)``
  - ``users``
  - ``add(user, password)``
  - ``pop(user)``
  - ``change_password(user, password)``
  - ``_encrypt_password(password)``


  - ``__contains__(group)``
  - ``groups``
  - ``is_user_in(user, group)``
  - ``add_user(user, group)``
  - ``delete_user(user,  group)``




  Raised by ``Basic.add`` if user already exists.


  Raised by ``Basic.delete`` and ``Basic.change_password`` if there is no such user.


  Raised by ``Group.delete_user`` if there is no such group.


  Raised by ``Group.add_user`` if user is already in a group.


  Raised by ``Group.delete_user`` if user isn't in a group.


  Raised by _encrypt_password if mode is not 'crypt' or 'md5'.


pkgId: f20aae57b9fe73f868ea2e9774c218b1a1544f4f9a2ab3f0705c21f391b4a3ef
name: python-httpcore
arch: src
version: 0.16.3
epoch: 0
release: 1
summary: A minimal low-level HTTP client.
url: https://github.com/encode/httpcore
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e87cea1-2951-4b1e-8f36-1c673b6fd8ff
location_href: 00003870-python-httpcore/python-httpcore-0.16.3-1.src.rpm
checksum_type: sha256
description:
  [![Test Suite](https://github.com/encode/httpcore/workflows/Test%20Suite/badge.svg)](https://github.com/encode/httpcore/actions)
  [![Package version](https://badge.fury.io/py/httpcore.svg)](https://pypi.org/project/httpcore/)

  > *Do one thing, and do it well.*

  The HTTP Core package provides a minimal low-level HTTP client, which does
  one thing only. Sending HTTP requests.

  It does not provide any high level model abstractions over the API,
  does not handle redirects, multipart uploads, building authentication headers,
  transparent HTTP caching, URL parsing, session cookie handling,
  content or charset decoding, handling JSON, environment based configuration
  defaults, or any of that Jazz.

  Some things HTTP Core does do:

  * Sending HTTP requests.
  * Thread-safe / task-safe connection pooling.
  * HTTP(S) proxy & SOCKS proxy support.
  * Supports HTTP/1.1 and HTTP/2.
  * Provides both sync and async interfaces.
  * Async backend support for `asyncio` and `trio`.



  Python 3.7+



  For HTTP/1.1 only support, install with:

  ```shell
  $ pip install httpcore
  ```

  For HTTP/1.1 and HTTP/2 support, install with:

  ```shell
  $ pip install httpcore[http2]
  ```

  For SOCKS proxy support, install with:

  ```shell
  $ pip install httpcore[socks]
  ```



  Send an HTTP request:

  ```python
  import httpcore

  response = httpcore.request("GET", "https://www.example.com/")

  print(response)

  print(response.status)

  print(response.headers)

  print(response.content)

  ```

  The top-level `httpcore.request()` function is provided for convenience. In practice whenever you're working with `httpcore` you'll want to use the connection pooling functionality that it provides.

  ```python
  import httpcore

  http = httpcore.ConnectionPool()
  response = http.request("GET", "https://www.example.com/")
  ```

  Once you're ready to get going, [head over to the documentation](https://www.encode.io/httpcore/).



  You *probably* don't want to be using HTTP Core directly. It might make sense if
  you're writing something like a proxy service in Python, and you just want
  something at the lowest possible level, but more typically you'll want to use
  a higher level client library, such as `httpx`.

  The motivation for `httpcore` is:

  * To provide a reusable low-level client library, that other packages can then build on top of.
  * To provide a *really clear interface split* between the networking code and client logic,
    so that each is easier to understand and reason about in isolation.




  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).



  - Allow `ws` and `wss` schemes. Allows us to properly support websocket upgrade connections. (#625)
  - Forwarding HTTP proxies use a connection-per-remote-host. Required by some proxy implementations. (#637)
  - Don't raise `RuntimeError` when closing a connection pool with active connections. Removes some error cases when cancellations are used. (#631)
  - Lazy import `anyio`, so that it's no longer a hard dependancy, and isn't imported if unused. (#639)



  - Revert 'Fix async cancellation behaviour', which introduced race conditions. (#627)
  - Raise `RuntimeError` if attempting to us UNIX domain sockets on Windows. (#619)



  - Fix HTTP/1.1 interim informational responses, such as "100 Continue". (#605)



  - Support HTTP/1.1 informational responses. (#581)
  - Fix async cancellation behaviour. (#580)
  - Support `h11` 0.14. (#579)



  - Drop Python 3.6 support (#535)
  - Ensure HTTP proxy CONNECT requests include `timeout` configuration. (#506)
  - Switch to explicit `typing.Optional` for type hints. (#513)
  - For `trio` map OSError exceptions to `ConnectError`. (#543)



  - Requests which raise a PoolTimeout need to be removed from the pool queue. (#502)
  - Fix AttributeError that happened when Socks5Connection were terminated. (#501)



  - Fix SOCKS support for `http://` URLs. (#492)
  - Resolve race condition around exceptions during streaming a response. (#491)



  - SOCKS proxy support. (#478)
  - Add proxy_auth argument to HTTPProxy. (#481)
  - Improve error message on 'RemoteProtocolError' exception when server disconnects without sending a response. (#479)



  - Support HTTP/2 on HTTPS tunnelling proxies. (#468)
  - Fix proxy headers missing on HTTP forwarding. (#456)
  - Only instantiate SSL context if required. (#457)
  - More robust HTTP/2 handling. (#253, #439, #440, #441)



  - Fix race condition when removing closed connections from the pool. (#437)



  - Failed connections no longer remain in the pool. (Pull #433)



  - `max_connections` becomes optional. (Pull #429)
  - `certifi` is now included in the install dependancies. (Pull #428)
  - `h2` is now strictly optional. (Pull #428)



  The 0.14 release is a complete reworking of `httpcore`, comprehensively addressing some underlying issues in the connection pooling, as well as substantially redesigning the API to be more user friendly.

  Some of the lower-level API design also makes the components more easily testable in isolation, and the package now has 100% test coverage.

  See [discussion #419](https://github.com/encode/httpcore/discussions/419) for a little more background.

  There's some other neat bits in there too, such as the "trace" extension, which gives a hook into inspecting the internal events that occur during the request/response cycle. This extension is needed for the HTTPX cli, in order to...

  * Log the point at which the connection is established, and the IP/port on which it is made.
  * Determine if the outgoing request should log as HTTP/1.1 or HTTP/2, rather than having to assume it's HTTP/2 if the --http2 flag was passed. (Which may not actually be true.)
  * Log SSL version info / certificate info.

  Note that `curio` support is not currently available in 0.14.0. If you're using `httpcore` with `curio` please get in touch, so we can assess if we ought to prioritize it as a feature or not.



  - Fix broken error messaging when URL scheme is missing, or a non HTTP(S) scheme is used. (Pull #403)





  - Close sockets when read or write timeouts occur. (Pull #365)





  - Resolved niggles with AnyIO EOF behaviours. (Pull #358, #362)





  - Improved error messaging when URL scheme is missing, or a non HTTP(S) scheme is used. (Pull #354)



  - Switched to `anyio` as the default backend implementation when running with `asyncio`. Resolves some awkward [TLS timeout issues](https://github.com/encode/httpx/discussions/1511).





  - Support HTTP/2 prior knowledge, using `httpcore.SyncConnectionPool(http1=False)`. (Pull #333)



  - Handle cases where environment does not provide `select.poll` support. (Pull #331)





  - Improve error message for specific case of `RemoteProtocolError` where server disconnects without sending a response. (Pull #313)





  - More resiliant testing for closed connections. (Pull #311)
  - Don't raise exceptions on ungraceful connection closes. (Pull #310)



  The 0.13 release updates the core API in order to match the HTTPX Transport API,
  introduced in HTTPX 0.18 onwards.

  An example of making requests with the new interface is:

  ```python
  with httpcore.SyncConnectionPool() as http:
      status_code, headers, stream, extensions = http.handle_request(
          method=b'GET',
          url=(b'https', b'example.org', 443, b'/'),
          headers=[(b'host', b'example.org'), (b'user-agent', b'httpcore')]
          stream=httpcore.ByteStream(b''),
          extensions={}
      )
      body = stream.read()
      print(status_code, body)
  ```



  - The `.request()` method is now `handle_request()`. (Pull #296)
  - The `.arequest()` method is now `.handle_async_request()`. (Pull #296)
  - The `headers` argument is no longer optional. (Pull #296)
  - The `stream` argument is no longer optional. (Pull #296)
  - The `ext` argument is now named `extensions`, and is no longer optional. (Pull #296)
  - The `"reason"` extension keyword is now named `"reason_phrase"`. (Pull #296)
  - The `"reason_phrase"` and `"http_version"` extensions now use byte strings for their values. (Pull #296)
  - The `httpcore.PlainByteStream()` class becomes `httpcore.ByteStream()`. (Pull #296)



  - Streams now support a `.read()` interface. (Pull #296)



  - Task cancellation no longer leaks connections from the connection pool. (Pull #305)





  - Abort SSL connections on close rather than waiting for remote EOF when using `asyncio`.  (Pull #167)
  - Fix exception raised in case of connect timeouts when using the `anyio` backend. (Pull #236)
  - Fix `Host` header precedence for `:authority` in HTTP/2. (Pull #241, #243)
  - Handle extra edge case when detecting for socket readability when using `asyncio`. (Pull #242, #244)
  - Fix `asyncio` SSL warning when using proxy tunneling. (Pull #249)





  - Properly wrap connect errors on the asyncio backend. (Pull #235)
  - Fix `ImportError` occurring on Python 3.9 when using the HTTP/1.1 sync client in a multithreaded context. (Pull #237)





  - Add connect retries. (Pull #221)



  - Tweak detection of dropped connections, resolving an issue with open files limits on Linux. (Pull #185)
  - Avoid leaking connections when establishing an HTTP tunnel to a proxy has failed. (Pull #223)
  - Properly wrap OS errors when using `trio`. (Pull #225)





  - HTTP header casing is now preserved, rather than always sent in lowercase. (#216 and python-hyper/h11#104)



  - Add Python 3.9 to officially supported versions.



  - Gracefully handle a stdlib asyncio bug when a connection is closed while it is in a paused-for-reading state. (#201)





  - Add await to async semaphore release() coroutine (#197)
  - Drop incorrect curio classifier (#192)



  The Transport API with 0.11.0 has a couple of significant changes.

  Firstly we've moved changed the request interface in order to allow extensions, which will later enable us to support features
  such as trailing headers, HTTP/2 server push, and CONNECT/Upgrade connections.

  The interface changes from:

  ```python
  def request(method, url, headers, stream, timeout):
      return (http_version, status_code, reason, headers, stream)
  ```

  To instead including an optional dictionary of extensions on the request and response:

  ```python
  def request(method, url, headers, stream, ext):
      return (status_code, headers, stream, ext)
  ```

  Having an open-ended extensions point will allow us to add later support for various optional features, that wouldn't otherwise be supported without these API changes.

  In particular:

  * Trailing headers support.
  * HTTP/2 Server Push
  * sendfile.
  * Exposing raw connection on CONNECT, Upgrade, HTTP/2 bi-di streaming.
  * Exposing debug information out of the API, including template name, template context.

  Currently extensions are limited to:

  * request: `timeout` - Optional. Timeout dictionary.
  * response: `http_version` - Optional. Include the HTTP version used on the response.
  * response: `reason` - Optional. Include the reason phrase used on the response. Only valid with HTTP/1.*.

  See https://github.com/encode/httpx/issues/1274#issuecomment-694884553 for the history behind this.

  Secondly, the async version of `request` is now namespaced as `arequest`.

  This allows concrete transports to support both sync and async implementations on the same class.



  - Add curio support. (Pull #168)
  - Add anyio support, with `backend="anyio"`. (Pull #169)



  - Update the Transport API to use 'ext' for optional extensions. (Pull #190)
  - Update the Transport API to use `.request` and `.arequest` so implementations can support both sync and async. (Pull #189)





  - Added Unix Domain Socket support. (Pull #139)



  - Always include the port on proxy CONNECT requests. (Pull #154)
  - Fix `max_keepalive_connections` configuration. (Pull #153)
  - Fixes behaviour in HTTP/1.1 where server disconnects can be used to signal the end of the response body. (Pull #164)



  - Include `max_keepalive_connections` on `AsyncHTTPProxy`/`SyncHTTPProxy` classes.



  The most notable change in the 0.10.0 release is that HTTP/2 support is now fully optional.

  Use either `pip install httpcore` for HTTP/1.1 support only, or `pip install httpcore[http2]` for HTTP/1.1 and HTTP/2 support.



  - HTTP/2 support becomes optional. (Pull #121, #130)
  - Add `local_address=...` support. (Pull #100, #134)
  - Add `PlainByteStream`, `IteratorByteStream`, `AsyncIteratorByteStream`. The `AsyncByteSteam` and `SyncByteStream` classes are now pure interface classes. (#133)
  - Add `LocalProtocolError`, `RemoteProtocolError` exceptions. (Pull #129)
  - Add `UnsupportedProtocol` exception. (Pull #128)
  - Add `.get_connection_info()` method. (Pull #102, #137)
  - Add better TRACE logs. (Pull #101)



  - `max_keepalive` is deprecated in favour of `max_keepalive_connections`. (Pull #140)



  - Improve handling of server disconnects. (Pull #112)





  - Proper host resolution for sync case, including IPv6 support. (Pull #97)
  - Close outstanding connections when connection pool is closed. (Pull #98)





  - URL port becomes an `Optional[int]` instead of `int`. (Pull #92)



  - Honor HTTP/2 max concurrent streams settings. (Pull #89, #90)
  - Remove incorrect debug log. (Pull #83)





  - Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
  and TRACE level logging. (Pull #79)



  - Reuse of connections on HTTP/2 in close concurrency situations. (Pull #81)





  - Include `Host` and `Accept` headers on proxy "CONNECT" requests.
  - De-duplicate any headers also contained in proxy_headers.
  - HTTP/2 flag not being passed down to proxy connections.





  - Fix connections using proxy forwarding requests not being added to the
  connection pool properly. (Pull #70)





  - Allow inherintance of both `httpcore.AsyncByteStream`, `httpcore.SyncByteStream` without type conflicts.





  - Fixed tunnel proxy support.



  - New `TimeoutException` base class.



  - First integration with HTTPX.


pkgId: 1e0c607aa85759606bed7da57d8055872526a7695cbeaa0c51456e63df8f15ae
name: python-httpie
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: HTTPie: modern, user-friendly command-line HTTP client for the API era.
url: https://httpie.io/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de2bd6fe-b8c3-4e79-9ebc-27e6271cc292
location_href: 00010840-python-httpie/python-httpie-3.2.1-1.src.rpm
checksum_type: sha256
description:
  <br/>
  <a href="https://httpie.io" target="blank_">
      <img height="100" alt="HTTPie" src="https://raw.githubusercontent.com/httpie/httpie/master/docs/httpie-logo.svg" />
  </a>
  <br/>



  HTTPie (pronounced _aitch-tee-tee-pie_) is a command-line HTTP client.
  Its goal is to make CLI interaction with web services as human-friendly as possible.
  HTTPie is designed for testing, debugging, and generally interacting with APIs & HTTP servers.
  The `http` & `https` commands allow for creating and sending arbitrary HTTP requests.
  They use simple and natural syntax and provide formatted and colorized output.

  [![Docs](https://img.shields.io/badge/stable%20docs-httpie.io%2Fdocs-brightgreen?style=flat&color=%2373DC8C&label=Docs)](https://httpie.org/docs)
  [![Latest version](https://img.shields.io/pypi/v/httpie.svg?style=flat&label=Latest&color=%234B78E6&logo=&logoColor=white)](https://pypi.python.org/pypi/httpie)
  [![Build](https://img.shields.io/github/workflow/status/httpie/httpie/Build?color=%23FA9BFA&label=Build)](https://github.com/httpie/httpie/actions)
  [![Coverage](https://img.shields.io/codecov/c/github/httpie/httpie?style=flat&label=Coverage&color=%2373DC8C)](https://codecov.io/gh/httpie/httpie)
  [![Twitter](https://img.shields.io/twitter/follow/httpie?style=flat&color=%234B78E6&logoColor=%234B78E6)](https://twitter.com/httpie)
  [![Chat](https://img.shields.io/badge/chat-Discord-brightgreen?style=flat&label=Chat%20on&color=%23FA9BFA)](https://httpie.io/discord)

  <img src="https://raw.githubusercontent.com/httpie/httpie/master/docs/httpie-animation.gif" alt="HTTPie in action" width="100%"/>




  Please note we recently accidentally made this repo private for a moment, and GitHub deleted our community that took a decade to build. Read the full story here: https://httpie.io/blog/stardust

  ![](docs/stardust.png)




  - [Installation instructions →](https://httpie.io/docs#installation)
  - [Full documentation →](https://httpie.io/docs)



  - Expressive and intuitive syntax
  - Formatted and colorized terminal output
  - Built-in JSON support
  - Forms and file uploads
  - HTTPS, proxies, and authentication
  - Arbitrary request data
  - Custom headers
  - Persistent sessions
  - `wget`-like downloads

  [See all features →](https://httpie.io/docs)



  Hello World:

  ```bash
  $ https httpie.io/hello
  ```

  Custom [HTTP method](https://httpie.io/docs#http-method), [HTTP headers](https://httpie.io/docs#http-headers) and [JSON](https://httpie.io/docs#json) data:

  ```bash
  $ http PUT pie.dev/put X-API-Token:123 name=John
  ```

  Build and print a request without sending it using [offline mode](https://httpie.io/docs#offline-mode):

  ```bash
  $ http --offline pie.dev/post hello=offline
  ```

  Use [GitHub API](https://developer.github.com/v3/issues/comments/#create-a-comment) to post a comment on an [Issue](https://github.com/httpie/httpie/issues/83) with [authentication](https://httpie.io/docs#authentication):

  ```bash
  $ http -a USERNAME POST https://api.github.com/repos/httpie/httpie/issues/83/comments body='HTTPie is awesome! :heart:'
  ```

  [See more examples →](https://httpie.io/docs#examples)



  - Visit the [HTTPie website](https://httpie.io) for full documentation and useful links.
  - Join our [Discord server](https://httpie.io/discord) is to ask questions, discuss features, and for general API chat.
  - Tweet at [@httpie](https://twitter.com/httpie) on Twitter.
  - Use [StackOverflow](https://stackoverflow.com/questions/tagged/httpie) to ask questions and include a `httpie` tag.
  - Create [GitHub Issues](https://github.com/httpie/httpie/issues) for bug reports and feature requests.
  - Subscribe to the [HTTPie newsletter](https://httpie.io) for occasional updates.



  Have a look through existing [Issues](https://github.com/httpie/httpie/issues) and [Pull Requests](https://github.com/httpie/httpie/pulls) that you could help with. If you'd like to request a feature or report a bug, please [create a GitHub Issue](https://github.com/httpie/httpie/issues) using one of the templates provided.

  [See contribution guide →](https://github.com/httpie/httpie/blob/master/CONTRIBUTING.md)


pkgId: 33128f66023d3a45af544e0d431b5da8e4f4753f91f5652545f603c1a7cf163c
name: python-httplib2
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: A comprehensive HTTP client library.
url: https://github.com/httplib2/httplib2
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-339cef41-f83d-40ef-91d6-ee71e735f5bf
location_href: 00008976-python-httplib2/python-httplib2-0.22.0-1.src.rpm
checksum_type: sha256
description:
  A comprehensive HTTP client library, ``httplib2`` supports many features left out of other HTTP libraries.

  **HTTP and HTTPS**
    HTTPS support is only available if the socket module was compiled with SSL support.


  **Keep-Alive**
    Supports HTTP 1.1 Keep-Alive, keeping the socket open and performing multiple requests over the same connection if possible.


  **Authentication**
    The following three types of HTTP Authentication are supported. These can be used over both HTTP and HTTPS.

    * Digest
    * Basic
    * WSSE

  **Caching**
    The module can optionally operate with a private cache that understands the Cache-Control:
    header and uses both the ETag and Last-Modified cache validators. Both file system
    and memcached based caches are supported.


  **All Methods**
    The module can handle any HTTP request method, not just GET and POST.


  **Redirects**
    Automatically follows 3XX redirects on GETs.


  **Compression**
    Handles both 'deflate' and 'gzip' types of compression.


  **Lost update support**
    Automatically adds back ETags into PUT requests to resources we have already cached. This implements Section 3.2 of Detecting the Lost Update Problem Using Unreserved Checkout


  **Unit Tested**
    A large and growing set of unit tests.


pkgId: 3d8f11a0d058178302c4776b40cde750051892bdb3dd0842beee361660855d9c
name: python-httplib2shim
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A wrapper over urllib3 that matches httplib2's interface
url: https://github.com/GoogleCloudPlatform/httplib2shim
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-612bc82c-4f2b-4367-8d28-511152018f12
location_href: 00013369-python-httplib2shim/python-httplib2shim-0.0.3-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage Status| |PyPI Version|
  ``httplib2shim`` is a wrapper over ``httplib2`` that uses ``urllib3`` to perform HTTP requests. This library is intended to help existing legacy libraries (and their users) to migrate away from ``httplib2``. It is not intended to be a general purpose replacement for ``httplib2``. It does not support every feature and edge case for ``httplib2``, although contributions are welcome in order to help us cover these cases.
  Presently, ``httplib2shim`` passes the test suite for ``httplib2``. A few non-applicable tests were disabled, and it's very possible that the tests do not account for behavior that is depended on by clients.


pkgId: 8fe541eedde26970d870c97730479cbfc60cda6e07a292f7c9c6cdabc9262e97
name: python-httpretty
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: HTTP client mock for Python
url: https://httpretty.readthedocs.io/en/latest/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9941e4ad-b939-49be-9d7d-f9bf83239ac3
location_href: 00010019-python-httpretty/python-httpretty-1.1.4-1.src.rpm
checksum_type: sha256
description:
  HTTP Client mocking tool for Python created by `Gabriel Falcão <https://github.com/gabrielfalcao>`_ . It provides a full fake TCP socket module. Inspired by `FakeWeb <https://github.com/chrisk/fakeweb>`_
  - `Github Repository <https://github.com/gabrielfalcao/HTTPretty>`_
  - `Documentation <https://httpretty.readthedocs.io/en/latest/>`_
  - `PyPI Package <https://pypi.org/project/httpretty/>`_
  **Python Support:**
  - **3.6**
  - **3.7**
  - **3.8**
  - **3.9**


pkgId: d90481009930769b637ff9cae6518feb4c03cd5484114357a48ddc374d73c477
name: python-httpsig_cffi
arch: src
version: 15.0.0
epoch: 0
release: 1
summary: Secure HTTP request signing using the HTTP Signature draft specification
url: https://github.com/hawkowl/httpsig_cffi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f90d165-e1ac-49ff-a486-bec1988a96d7
location_href: 00003871-python-httpsig-cffi/python-httpsig_cffi-15.0.0-1.src.rpm
checksum_type: sha256
description:
  Sign HTTP requests with secure signatures according to the IETF HTTP Signatures specification (`Draft 3`_).
  This is `a fork`_ of the fork_ of the original module_ that was made to fully support both RSA and HMAC schemes as well as unit test both schemes to prove they work.
  This particular fork moves from PyCrypto to Cryptography, which provides PyPy support.
  See the original project_, original Python module_, original spec_, and `current IETF draft`_ for more details on the signing scheme.


pkgId: af9018a7f4aa7fe75baba162c5577d68b03ce1e5fe93467f9f62b5cef4616594
name: python-httptools
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A collection of framework independent HTTP protocol utils.
url: https://github.com/MagicStack/httptools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc79fe75-ef58-4034-b75d-66cf4f5e6242
location_href: 00003872-python-httptools/python-httptools-0.5.0-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/MagicStack/httptools/workflows/Tests/badge.svg)

  httptools is a Python binding for the nodejs HTTP parser.

  The package is available on PyPI: `pip install httptools`.




  httptools contains two classes `httptools.HttpRequestParser`,
  `httptools.HttpResponseParser` (fulfilled through
  [llhttp](https://github.com/nodejs/llhttp)) and a function for
  parsing URLs `httptools.parse_url` (through
  [http-parse](https://github.com/nodejs/http-parser) for now).
  See unittests for examples.


  ```python

  class HttpRequestParser:

      def __init__(self, protocol):
          """HttpRequestParser

          protocol -- a Python object with the following methods
          (all optional):

            - on_message_begin()
            - on_url(url: bytes)
            - on_header(name: bytes, value: bytes)
            - on_headers_complete()
            - on_body(body: bytes)
            - on_message_complete()
            - on_chunk_header()
            - on_chunk_complete()
            - on_status(status: bytes)
          """

      def get_http_version(self) -> str:
          """Return an HTTP protocol version."""

      def should_keep_alive(self) -> bool:
          """Return ``True`` if keep-alive mode is preferred."""

      def should_upgrade(self) -> bool:
          """Return ``True`` if the parsed request is a valid Upgrade request.
  	The method exposes a flag set just before on_headers_complete.
  	Calling this method earlier will only yield `False`.
  	"""

      def feed_data(self, data: bytes):
          """Feed data to the parser.

          Will eventually trigger callbacks on the ``protocol``
          object.

          On HTTP upgrade, this method will raise an
          ``HttpParserUpgrade`` exception, with its sole argument
          set to the offset of the non-HTTP data in ``data``.
          """

      def get_method(self) -> bytes:
          """Return HTTP request method (GET, HEAD, etc)"""


  class HttpResponseParser:

      """Has all methods except ``get_method()`` that
      HttpRequestParser has."""

      def get_status_code(self) -> int:
          """Return the status code of the HTTP response"""


  def parse_url(url: bytes):
      """Parse URL strings into a structured Python object.

      Returns an instance of ``httptools.URL`` class with the
      following attributes:

        - schema: bytes
        - host: bytes
        - port: int
        - path: bytes
        - query: bytes
        - fragment: bytes
        - userinfo: bytes
      """
  ```




  1. Clone this repository with
     `git clone --recursive git@github.com:MagicStack/httptools.git`

  2. Create a virtual environment with Python 3:
     `python3 -m venv envname`

  3. Activate the environment with `source envname/bin/activate`

  4. Install development requirements with `pip install -e .[test]`

  5. Run `make` and `make test`.




  MIT.


pkgId: 3e2460d4583580d16c603bc453da9f3c492bdc0d03da10957bb7fb4e5092a16f
name: python-httptools-debuginfo
arch: aarch64
version: 0.5.0
epoch: 0
release: 1
summary: Debug information for package python-httptools
url: https://github.com/MagicStack/httptools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fc79fe75-ef58-4034-b75d-66cf4f5e6242
rpm_sourcerpm: python-httptools-0.5.0-1.src.rpm
location_href: 00003872-python-httptools/python-httptools-debuginfo-0.5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-httptools.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 4b8b551cdfd1fd3709a8980882e57ffc04a4d21b8c82b7b706903542592381f8
name: python-httptools-debugsource
arch: aarch64
version: 0.5.0
epoch: 0
release: 1
summary: Debug sources for package python-httptools
url: https://github.com/MagicStack/httptools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fc79fe75-ef58-4034-b75d-66cf4f5e6242
rpm_sourcerpm: python-httptools-0.5.0-1.src.rpm
location_href: 00003872-python-httptools/python-httptools-debugsource-0.5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-httptools.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 953677198fb1ed745f18c0ff400621b1594270b0170f0134952c5c315a3962f0
name: python-httpx-socks
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: Proxy (HTTP, SOCKS) transports for httpx
url: https://github.com/romis2012/httpx-socks
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d001592d-92f1-4ec2-be7e-cd06571f34a2
location_href: 00011605-python-httpx-socks/python-httpx-socks-0.7.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://api.travis-ci.com/romis2012/httpx-socks.svg?branch=master)](https://travis-ci.com/github/romis2012/httpx-socks)
  [![Coverage Status](https://coveralls.io/repos/github/romis2012/httpx-socks/badge.svg?branch=master&_=q)](https://coveralls.io/github/romis2012/httpx-socks?branch=master)
  [![PyPI version](https://badge.fury.io/py/httpx-socks.svg)](https://badge.fury.io/py/httpx-socks)
  <!--
  [![Downloads](https://pepy.tech/badge/httpx-socks/month)](https://pepy.tech/project/httpx-socks)
  -->

  The `httpx-socks` package provides proxy transports for [httpx](https://github.com/encode/httpx) client.
  SOCKS4(a), SOCKS5(h), HTTP (tunneling) proxy supported.
  It uses [python-socks](https://github.com/romis2012/python-socks) for core proxy functionality.



  - Python >= 3.6
  - httpx>=0.21.0
  - python-socks>=2.0.0
  - async-timeout>=3.0.1 (optional)
  - trio>=0.16.0 (optional)




  only sync proxy support:
  ```
  pip install httpx-socks
  ```

  to include optional asyncio support (it requires async-timeout):
  ```
  pip install httpx-socks[asyncio]
  ```

  to include optional trio support:
  ```
  pip install httpx-socks[trio]
  ```





  ```python
  import httpx
  from httpx_socks import SyncProxyTransport

  def fetch(url):
      transport = SyncProxyTransport.from_url('socks5://user:password@127.0.0.1:1080')
      with httpx.Client(transport=transport) as client:
          res = client.get(url)
          return res.text
  ```


  ```python
  import httpx
  from httpx_socks import AsyncProxyTransport

  async def fetch(url):
      transport = AsyncProxyTransport.from_url('socks5://user:password@127.0.0.1:1080')
      async with httpx.AsyncClient(transport=transport) as client:
          res = await client.get(url)
          return res.text
  ```


  ```python
  import ssl
  import httpx
  from httpx_socks import AsyncProxyTransport

  async def fetch(url):
      proxy_ssl = ssl.SSLContext(ssl.PROTOCOL_TLS)
      proxy_ssl.verify_mode = ssl.CERT_REQUIRED
      proxy_ssl.load_verify_locations(...)

      transport = AsyncProxyTransport.from_url('http://user:password@127.0.0.1:8080', proxy_ssl=proxy_ssl)
      async with httpx.AsyncClient(transport=transport) as client:
          res = await client.get(url)
          return res.text
  ```


pkgId: 4b9916dac360c958175ec0c5e5761544e569fcfc6b7e158d3c24675355eac83a
name: python-humanfriendly
arch: src
version: 10.0
epoch: 0
release: 1
summary: Human friendly output for text interfaces using Python
url: https://humanfriendly.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1a93c92f-6aac-4298-ad06-be6b57e7f02b
location_href: 00003874-python-humanfriendly/python-humanfriendly-10.0-1.src.rpm
checksum_type: sha256
description:
  The functions and classes in the `humanfriendly` package can be used to make
  text interfaces more user friendly. Some example features:
  - Parsing and formatting numbers, file sizes, pathnames and timespans in
    simple, human friendly formats.
  - Easy to use timers for long running operations, with human friendly
    formatting of the resulting timespans.
  - Prompting the user to select a choice from a list of options by typing the
    option's number or a unique substring of the option.
  - Terminal interaction including text styling (`ANSI escape sequences`_), user
    friendly rendering of usage messages and querying the terminal for its
    size.
  The `humanfriendly` package is currently tested on Python 2.7, 3.5+ and PyPy
  (2.7) on Linux and macOS. While the intention is to support Windows as well,
  you may encounter some rough edges.


pkgId: bb4f01c08304d71cf69cd0df3007287d2138f3c6e786a1ce34ff16ffce9720e0
name: python-humblewx
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Library that simplifies creating user interfaces with wxPython.
url: https://github.com/thetimelineproj/humblewx
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d6d53238-c40a-4049-8ef5-c47e89ec484f
location_href: 00003875-python-humblewx/python-humblewx-0.2.2-1.src.rpm
checksum_type: sha256
description:
  * License: GPLv3
  * Contributions: Fork this repository and send a pull request

  For more information, see the `documentation
  <http://humblewx.readthedocs.org/en/latest/>`_.


pkgId: 73b1a259dba87fbf3f135258c9f94bacdc455d4932c21e16e61b5572c7d015c0
name: python-hurry.filesize
arch: src
version: 0.9
epoch: 0
release: 1
summary: A simple Python library for human readable file sizes (or anything sized in bytes).
url: UNKNOWN
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f904749-590c-4386-a80e-0c02bd9f9adc
location_href: 00011085-python-hurry-filesize/python-hurry.filesize-0.9-1.src.rpm
checksum_type: sha256
description:
  hurry.filesize a simple Python library that can take a number of bytes and
  returns a human-readable string with the size in it, in kilobytes (K),
  megabytes (M), etc.
  The default system it uses is "traditional", where multipliers of 1024
  increase the unit size::
    >>> from hurry.filesize import size
    >>> size(1024)
    '1K'
  An alternative, slightly more verbose system::
    >>> from hurry.filesize import alternative
    >>> size(1, system=alternative)
    '1 byte'
    >>> size(10, system=alternative)
    '10 bytes'
    >>> size(1024, system=alternative)
    '1 KB'
  A verbose system::
    >>> from hurry.filesize import verbose
    >>> size(10, system=verbose)
    '10 bytes'
    >>> size(1024, system=verbose)
    '1 kilobyte'
    >>> size(2000, system=verbose)
    '1 kilobyte'
    >>> size(3000, system=verbose)
    '2 kilobytes'
    >>> size(1024 * 1024, system=verbose)
    '1 megabyte'
    >>> size(1024 * 1024 * 3, system=verbose)
    '3 megabytes'
  You can also use the SI system, where multipliers of 1000 increase the unit
  size::
    >>> from hurry.filesize import si
    >>> size(1000, system=si)
    '1K'


pkgId: efe7b45cc2f949a372f4301dd282fb7d944dfbb0e7a3bde9a602473240804f4e
name: python-husl
arch: src
version: 4.0.3
epoch: 0
release: 1
summary: Human-friendly HSL
url: http://www.husl-colors.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-21863344-b571-4f4b-b4ea-55c25f2808bf
location_href: 00003877-python-husl/python-husl-4.0.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/husl-colors/husl-python.svg?branch=master)](http://travis-ci.org/husl-colors/husl-python)
  [![Package Version](https://img.shields.io/pypi/v/husl.svg)](https://pypi.python.org/pypi/husl/)

  A Python implementation of [HUSL](http://www.husl-colors.org) (revision 3).



  `pip install husl`



  **husl_to_hex(hue, saturation, lightness)**

  `hue` is a float between 0 and 360, `saturation` and `lightness` are floats between 0 and 100. This function returns the resulting color as a hex string.

  **husl_to_rgb(hue, saturation, lightness)**

  Like above, but returns a list of 3 floats between 0 and 1, for each RGB channel.

  **hex_to_husl(hex)**

  Takes a hex string and returns the HUSL color as a list of floats as defined above.

  **rgb_to_husl(red, green, blue)**

  Like above, but `red`, `green` and `blue` are passed as floats between 0 and 1.

  For HUSLp (the pastel variant), use `huslp_to_hex`, `huslp_to_rgb`, `hex_to_huslp` and `rgb_to_huslp`.



  Run `python setup.py test`.



  * Robert McGinley ([mcginleyr1](http://github.com/mcginleyr1))
  * Alexei Boronine ([boronine](http://github.com/boronine))


pkgId: d06a2572464a7ba922a60fe2d7d7340c054a4b6731d51d0a72d4c04166221d93
name: python-hvac
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: HashiCorp Vault API client
url: https://github.com/hvac/hvac
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-816c2b8c-6c1d-41b2-8106-40220c722440
location_href: 00003878-python-hvac/python-hvac-1.1.0-1.src.rpm
checksum_type: sha256
description:
  ![Header image](https://raw.githubusercontent.com/hvac/hvac/main/docs/_static/hvac_logo_800px.png)

  [HashiCorp](https://hashicorp.com/) [Vault](https://www.vaultproject.io) API client for Python 3.x

  [![Test](https://github.com/hvac/hvac/workflows/Test/badge.svg)](https://github.com/hvac/hvac/actions?query=workflow%3ATest)
  [![codecov](https://codecov.io/gh/hvac/hvac/branch/main/graph/badge.svg)](https://codecov.io/gh/hvac/hvac)
  [![Documentation Status](https://readthedocs.org/projects/hvac/badge/)](https://hvac.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/hvac.svg)](https://badge.fury.io/py/hvac)
  [![Twitter - @python_hvac](https://img.shields.io/twitter/follow/python_hvac.svg?label=Twitter%20-%20@python_hvac&style=social?style=plastic)](https://twitter.com/python_hvac)
  [![Gitter chat](https://badges.gitter.im/hvac/community.png)](https://gitter.im/hvac/community)

  Tested against the latest release, HEAD ref, and 3 previous minor versions (counting back from the latest release) of Vault.
  Current official support covers Vault v1.4.7 or later.

  > **NOTE:**  Support for EOL Python versions will be dropped at the end of 2022.  Starting in 2023, hvac will track
  > with the CPython EOL dates.



  ```console
  pip install hvac
  ```

  If you would like to be able to return parsed HCL data as a Python dict for methods that support it:

  ```console
  pip install "hvac[parser]"
  ```



  Additional documentation for this module available at: [hvac.readthedocs.io](https://hvac.readthedocs.io/en/stable/usage/index.html):

  * [Getting Started](https://hvac.readthedocs.io/en/stable/overview.html#getting-started)
  * [Usage](https://hvac.readthedocs.io/en/stable/usage/index.html)
  * [Advanced Usage](https://hvac.readthedocs.io/en/stable/advanced_usage.html)
  * [Source Reference / Autodoc](https://hvac.readthedocs.io/en/stable/source/index.html)
  * [Contributing](https://hvac.readthedocs.io/en/stable/contributing.html)
  * [Changelog](https://hvac.readthedocs.io/en/stable/changelog.html)


pkgId: 1729d1f51b6c7a4d2870c0bb61c45b8541b58bc4dc161f545a75d27b407df85a
name: python-hyperlink
arch: src
version: 21.0.0
epoch: 0
release: 1
summary: A featureful, immutable, and correct URL for Python.
url: https://github.com/python-hyper/hyperlink
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0bc4271a-6797-47f4-919f-205458968bdb
location_href: 00009452-python-hyperlink/python-hyperlink-21.0.0-1.src.rpm
checksum_type: sha256
description:
  The humble, but powerful, URL runs everything around us. Chances
  are you've used several just to read this text.

  Hyperlink is a featureful, pure-Python implementation of the URL, with
  an emphasis on correctness. MIT licensed.

  See the docs at http://hyperlink.readthedocs.io.


pkgId: 2a6003b6078e11eaa7ba48bf6a8888c9f0db2da09d21354d0741e92861d457a0
name: python-hypothesis-fspaths
arch: src
version: 0.1
epoch: 0
release: 1
summary: Hypothesis extension for generating filesystem paths
url: https://github.com/lazka/hypothesis-fspaths
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f634549-3e97-4ea7-9d8a-42ba6105e089
location_href: 00003879-python-hypothesis-fspaths/python-hypothesis-fspaths-0.1-1.src.rpm
checksum_type: sha256
description:
      from hypothesis import given
      from hypothesis_fspaths import fspaths
      @given(fspaths())
      def test_open_file(path):
          try:
              open(path).close()
          except IOError:
              pass


pkgId: 795485773ca612936ff2a84e988931bdd38b1fca2ffa30f22b8f73e9d05f21c2
name: python-hypothesis-jsonschema
arch: src
version: 0.22.1
epoch: 0
release: 1
summary: Generate test data from JSON schemata with Hypothesis
url: https://github.com/Zac-HD/hypothesis-jsonschema
rpm_license: MPL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-32b13953-ae6f-4bd5-bcb2-b1565be74113
location_href: 00011985-python-hypothesis-jsonschema/python-hypothesis-jsonschema-0.22.1-1.src.rpm
checksum_type: sha256
description:
  A [Hypothesis](https://hypothesis.readthedocs.io) strategy for generating data
  that matches some [JSON schema](https://json-schema.org/).

  [Here's the PyPI page.](https://pypi.org/project/hypothesis-jsonschema/)



  The public API consists of just one function: `hypothesis_jsonschema.from_schema`,
  which takes a JSON schema and returns a strategy for allowed JSON objects.

  ```python
  from hypothesis import given

  from hypothesis_jsonschema import from_schema


  @given(from_schema({"type": "integer", "minimum": 1, "exclusiveMaximum": 10}))
  def test_integers(value):
      assert isinstance(value, int)
      assert 1 <= value < 10


  @given(
      from_schema(
          {"type": "string", "format": "card"},
          
          
          custom_formats={"card": st.sampled_from(EXAMPLE_CARD_NUMBERS)},
      )
  )
  def test_card_numbers(value):
      assert isinstance(value, str)
      assert re.match(r"^\d{4} \d{4} \d{4} \d{4}$", value)
  ```

  For more details on property-based testing and how to use or customise
  strategies, [see the Hypothesis docs](https://hypothesis.readthedocs.io/).

  JSONSchema drafts 04, 05, and 07 are fully tested and working.
  As of version 0.11, this includes resolving non-recursive references!




  `hypothesis-jsonschema` requires Python 3.6 or later.
  In general, 0.x versions will require very recent versions of all dependencies
  because I don't want to deal with compatibility workarounds.

  `hypothesis-jsonschema` may make backwards-incompatible changes at any time
  before version 1.x - that's what semver means! - but I've kept the API surface
  small enough that this should be avoidable.  The main source of breaks will be
  if or when schema that never really worked turn into explicit errors instead
  of generating values that don't quite match.

  You can [sponsor me](https://github.com/sponsors/Zac-HD) to get priority
  support, roadmap input, and prioritized feature development.




  We love external contributions - and try to make them both easy and fun.
  You can [read more details in our contributing guide](https://github.com/Zac-HD/hypothesis-jsonschema/blob/master/CONTRIBUTING.md),
  and [see everyone who has contributed on GitHub](https://github.com/Zac-HD/hypothesis-jsonschema/graphs/contributors).
  Thanks, everyone!




  Patch notes [can be found in `CHANGELOG.md`](https://github.com/Zac-HD/hypothesis-jsonschema/blob/master/CHANGELOG.md).



  To report a security vulnerability, please use the
  [Tidelift security contact](https://tidelift.com/security).
  Tidelift will coordinate the fix and disclosure.


pkgId: cdb7bb47725f9ae82c41862165030b644642317d0473fc9cd3af91b936821f3b
name: python-i3ipc
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: An improved Python library to control i3wm and sway
url: https://github.com/altdesktop/i3ipc-python
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72a9e91c-cef2-43c5-880b-6a8d26bf0854
location_href: 00003880-python-i3ipc/python-i3ipc-2.2.1-1.src.rpm
checksum_type: sha256
description:
  An improved Python library to control `i3wm <http://i3wm.org>`__ and `sway <https://swaywm.org/>`__.


pkgId: ba5bddc10050286e72f8207193c956ccc53019ffbe62aea2689e5a01c0634eb3
name: python-ibis-bigquery
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Ibis BigQuery backend
url: https://github.com/ibis-project/ibis-bigquery
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fa1eba5f-d108-4029-a4da-d10e37e61995
location_href: 00013122-python-ibis-bigquery/python-ibis-bigquery-2.2.1-1.src.rpm
checksum_type: sha256
description:
  This package provides a `BigQuery <https://cloud.google.com/bigquery>`_ backend
  for `Ibis <https://ibis-project.org/>`_.


pkgId: 316232ee4dd6444693fb4deb5b853eb6b3382c7f620271194ed48074a5dd011e
name: python-ibm-cloud-sdk-core
arch: src
version: 3.16.5
epoch: 0
release: 1
summary: Core library used by SDKs for IBM Cloud Services
url: https://github.com/IBM/python-sdk-core
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-934e1104-0bb1-4a26-9f0e-9231e4aedf47
location_href: 00011245-python-ibm-cloud-sdk-core/python-ibm-cloud-sdk-core-3.16.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://app.travis-ci.com/IBM/python-sdk-core.svg?branch=main)](https://app.travis-ci.com/IBM/python-sdk-core)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ibm-cloud-sdk-core)](https://pypi.org/project/ibm-cloud-sdk-core/)
  [![Latest Stable Version](https://img.shields.io/pypi/v/ibm-cloud-sdk-core.svg)](https://pypi.python.org/pypi/ibm-cloud-sdk-core)
  [![CLA assistant](https://cla-assistant.io/readme/badge/ibm/python-sdk-core)](https://cla-assistant.io/ibm/python-sdk-core)
  [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)


  This project contains core functionality required by Python code generated by the IBM Cloud OpenAPI SDK Generator
  (openapi-sdkgen).


  The current minimum Python version supported is 3.7.



  To install, use `pip` or `easy_install`:

  ```bash
  pip install --upgrade ibm-cloud-sdk-core
  ```

  or

  ```bash
  easy_install --upgrade ibm-cloud-sdk-core
  ```


  The python-sdk-core project supports the following types of authentication:
  - Basic Authentication
  - Bearer Token Authentication
  - Identity and Access Management (IAM) Authentication
  - Container Authentication
  - VPC Instance Authentication
  - Cloud Pak for Data Authentication
  - No Authentication (for testing)

  For more information about the various authentication types and how to use them with your services, click [here](Authentication.md).



  If you encounter an issue with this project, you are welcome to submit a [bug report](https://github.com/IBM/python-sdk-core/issues).
  Before opening a new issue, please search for similar issues. It's possible that someone has already reported it.





  ```python
  import logging
  logging.basicConfig(level=logging.DEBUG)
  ```

  This would show output of the form:
  ```
  DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): iam.cloud.ibm.com:443
  DEBUG:urllib3.connectionpool:https://iam.cloud.ibm.com:443 "POST /identity/token HTTP/1.1" 200 1809
  DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): gateway.watsonplatform.net:443
  DEBUG:urllib3.connectionpool:https://gateway.watsonplatform.net:443 "POST /assistant/api/v1/workspaces?version=2018-07-10 HTTP/1.1" 201 None
  DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): gateway.watsonplatform.net:443
  DEBUG:urllib3.connectionpool:https://gateway.watsonplatform.net:443 "GET /assistant/api/v1/workspaces/883a2a44-eb5f-4b1a-96b0-32a90b475ea8?version=2018-07-10&export=true HTTP/1.1" 200 None
  DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): gateway.watsonplatform.net:443
  DEBUG:urllib3.connectionpool:https://gateway.watsonplatform.net:443 "DELETE /assistant/api/v1/workspaces/883a2a44-eb5f-4b1a-96b0-32a90b475ea8?version=2018-07-10 HTTP/1.1" 200 28
  ```


  To get low level information of the requests/ responses:

  ```python
  from http.client import HTTPConnection
  HTTPConnection.debuglevel = 1
  ```



  Find more open source projects on the [IBM Github Page](http://github.com/IBM)



  This library is licensed under Apache 2.0. Full license text is
  available in [LICENSE](LICENSE).



  See [CONTRIBUTING.md](CONTRIBUTING.md).


pkgId: 47f4715691faac4019d7d8c373be40c4ed08fb0d6b904c7001dd1ef3f41f6b51
name: python-ibm-cos-sdk
arch: src
version: 2.13.0
epoch: 0
release: 1
summary: IBM SDK for Python
url: https://github.com/ibm/ibm-cos-sdk-python
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1ab1e975-ab30-42ee-95ee-f3afc8318e60
location_href: 00011091-python-ibm-cos-sdk/python-ibm-cos-sdk-2.13.0-1.src.rpm
checksum_type: sha256
description:
  This package allows Python developers to write software that interacts with [IBM Cloud Object Storage](https://cloud.ibm.com/docs/services/cloud-object-storage/about-cos.html). It is a fork of the [`boto3` library](https://github.com/boto/boto3) and can stand as a drop-in replacement if the application needs to connect to object storage using an S3-like API and does not make use of other AWS services.



  IBM has added a [Language Support Policy](#language-support-policy). Language versions will be deprecated on the published schedule without additional notice.



  * [Core documentation for IBM COS](https://cloud.ibm.com/docs/services/cloud-object-storage/getting-started.html)
  * [Python API reference documentation](https://ibm.github.io/ibm-cos-sdk-python)
  * [REST API reference documentation](https://cloud.ibm.com/docs/services/cloud-object-storage/api-reference/about-api.html)

  For release notes, see the [CHANGELOG](CHANGELOG.md).

  * [Building from Source](#building-from-source)
  * [Getting Help](#getting-help)



  You\'ll need:

  * An instance of COS.
  * An API key from [IBM Cloud Identity and Access Management](https://cloud.ibm.com/docs/iam/users_roles.html) with at least `Writer` permissions.
  * The ID of the instance of COS that you are working with.
  * Token acquisition endpoint.
  * Service endpoint.

  These values can be found in the IBM Cloud Console by [generating a \'service credential\'](https://cloud.ibm.com/docs/services/cloud-object-storage/iam/service-credentials.html).



  Use of the Python SDK and example code can be found [here](https://cloud.ibm.com/docs/cloud-object-storage?topic=cloud-object-storage-python).



  After generating a Service Credential, the resulting JSON document can be saved to `~/.bluemix/cos_credentials`. The SDK will automatically source credentials from this file unless other credentials are explicitly set during client creation. If the cos_credentials file contains HMAC keys the client authenticates with a signature, otherwise the client uses the provided API key to authenticate by using a bearer token (using an API key still requires the `config=Config(signature_version="oauth")` to be included during client creation).



  You can automatically archive objects after a specified length of time or after a specified date. Once archived, a temporary copy of an object can be restored for access as needed. Restore time may take up to 15 hours.

  An archive policy is set at the bucket level by calling the `put_bucket_lifecycle_configuration` method on a client instance. A newly added or modified archive policy applies to new objects uploaded and does not affect existing objects. For more detail, [see the documentation](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries/python.html#python).



  Users can configure buckets with an Immutable Object Storage policy to prevent objects from being modified or deleted for a defined period of time. The retention period can be specified on a per-object basis, or objects can inherit a default retention period set on the bucket. It is also possible to set open-ended and permanent retention periods. Immutable Object Storage meets the rules set forth by the SEC governing record retention, and IBM Cloud administrators are unable to bypass these restrictions. For more detail, [see the IBM Cloud documentation](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries/python.html#python).

  Note: Immutable Object Storage does not support Aspera transfers via the SDK to upload objects or directories at this stage.



  Users can set an archive rule that would allow data restore from an archive in 2 hours or 12 hours.



  Aspera high-speed transfer through the COS SDK using the `cos-aspera` library is now legacy. New users and applications should use the [Aspera Transfer SDK](https://developer.ibm.com/apis/catalog/aspera--aspera-transfer-sdk/Introduction) instead. Existing users should begin new projects with the Aspera Transfer SDK and make plans to migrate existing applications. Users who use S3 for transfers and do not install `cos-aspera` are unaffected.



  Assuming that you have Python and `virtualenv` installed, set up your environment and install the required dependencies like this instead of the `pip install ibm-cos-sdk` defined above:

  ```sh
  git clone https://github.com/ibm/ibm-cos-sdk-python.git
  cd ibm-cos-sdk-python
  $ virtualenv venv
  ...
  . venv/bin/activate
  pip install -r requirements.txt
  pip install -e .
  ```



  Feel free to use GitHub issues for tracking bugs and feature requests, but for help please use one of the following resources:

  * Read a quick start guide in [IBM Cloud Docs](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries/python.html#python).
  * Ask a question on [Stack Overflow](https://stackoverflow.com/) and tag it with `ibm` and `object-storage`.
  * Open a support ticket with [IBM Cloud Support](https://cloud.ibm.com/unifiedsupport/supportcenter/)
  * If it turns out that you may have found a bug, please [open an issue](https://github.com/ibm/ibm-cos-sdk-python/issues/new).



  IBM supports [current public releases](https://devguide.python.org/#status-of-python-branches). IBM will deprecate language versions 90 days after a version reaches end-of-life. All clients will need to upgrade to a supported version before the end of the grace period.



  This SDK is distributed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0), see LICENSE.txt and NOTICE.txt for more information.


pkgId: 7f7831083e94373ee247d3d15e3b602adb67d137d63dae173e9c8b00f8443c6e
name: python-ibm-cos-sdk-core
arch: src
version: 2.13.0
epoch: 0
release: 1
summary: Low-level, data-driven core of IBM SDK for Python
url: https://github.com/ibm/ibm-cos-sdk-python-core
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-816c10d7-2c61-45ee-9ac3-16d673171926
location_href: 00011454-python-ibm-cos-sdk-core/python-ibm-cos-sdk-core-2.13.0-1.src.rpm
checksum_type: sha256
description:
  A low-level interface to IBM Cloud Object Storage based on the `ibm_botocore` package. This core package is the foundation for the [`ibm-cos-sdk-python`](https://github.com/ibm/ibm-cos-sdk-python) package.



  Documentation for `ibm-cos-sdk-python-core` can be found [here](https://ibm.github.io/ibm-cos-sdk-python-core/).



  Feel free to use GitHub issues for tracking bugs and feature requests, but for help please use one of the following resources:

  * Ask a question on [Stack Overflow](https://stackoverflow.com/) and tag it with `ibm` and `object-storage`.
  * Open a support ticket with [IBM Cloud Support](https://cloud.ibm.com/unifiedsupport/supportcenter/)
  * If it turns out that you may have found a bug, please [open an issue](https://github.com/ibm/ibm-cos-sdk-python-core/issues/new)


pkgId: 75e8de12b82f6b271b1d21f621a9c2aa7e83c17cfd19680c12997d010bdd0602
name: python-icecream
arch: src
version: 2.1.3
epoch: 0
release: 1
description: Information and documentation can be found at https://github.com/gruns/icecream.
url: https://github.com/gruns/icecream
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-63979725-ac4b-4bab-9d2b-e048e124d58a
location_href: 00011407-python-icecream/python-icecream-2.1.3-1.src.rpm
checksum_type: sha256
summary:
  Never use print() to debug again; inspect variables, expressions, and program execution with a single, simple function call.


pkgId: 1f662704c2ce1e32eaf6081280a5bada4239eda10bf19e109f7e90f6a402d7fb
name: python-identify
arch: src
version: 2.5.19
epoch: 0
release: 1
summary: File identification library for Python
url: https://github.com/pre-commit/identify
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-66c0f1e4-2f28-4425-9bd9-d724a34d6e5d
location_href: 00003882-python-identify/python-identify-2.5.19-1.src.rpm
checksum_type: sha256
description:
  File identification library for Python.
  Given a file (or some information about a file), return a set of standardized
  tags identifying what the file is.

  ```bash
  pip install identify
  ```


  If you have an actual file on disk, you can get the most information possible
  (a superset of all other methods):
  ```python
  >>> from identify import identify
  >>> identify.tags_from_path('/path/to/file.py')
  {'file', 'text', 'python', 'non-executable'}
  >>> identify.tags_from_path('/path/to/file-with-shebang')
  {'file', 'text', 'shell', 'bash', 'executable'}
  >>> identify.tags_from_path('/bin/bash')
  {'file', 'binary', 'executable'}
  >>> identify.tags_from_path('/path/to/directory')
  {'directory'}
  >>> identify.tags_from_path('/path/to/symlink')
  {'symlink'}
  ```
  When using a file on disk, the checks performed are:
  * File type (file, symlink, directory, socket)
  * Mode (is it executable?)
  * File name (mostly based on extension)
  * If executable, the shebang is read and the interpreter interpreted

  ```python
  >>> identify.tags_from_filename('file.py')
  {'text', 'python'}
  ```

  ```python
  >>> identify.tags_from_interpreter('python3.5')
  {'python', 'python3'}
  >>> identify.tags_from_interpreter('bash')
  {'shell', 'bash'}
  >>> identify.tags_from_interpreter('some-unrecognized-thing')
  set()
  ```

  ```
  $ identify-cli --help
  usage: identify-cli [-h] [--filename-only] path
  positional arguments:
    path
  optional arguments:
    -h, --help       show this help message and exit
    --filename-only
  ```
  ```console
  $ identify-cli setup.py; echo $?
  ["file", "non-executable", "python", "text"]
  0
  $ identify-cli setup.py --filename-only; echo $?
  ["python", "text"]
  0
  $ identify-cli wat.wat; echo $?
  wat.wat does not exist.
  1
  $ identify-cli wat.wat --filename-only; echo $?
  1
  ```

  `identify` also has an api for determining what type of license is contained
  in a file.  This routine is roughly based on the approaches used by
  [licensee] (the ruby gem that github uses to figure out the license for a
  repo).
  The approach that `identify` uses is as follows:
  1. Strip the copyright line
  2. Normalize all whitespace
  3. Return any exact matches
  4. Return the closest by edit distance (where edit distance < 5%)
  To use the api, install via `pip install identify[license]`
  ```pycon
  >>> from identify import identify
  >>> identify.license_id('LICENSE')
  'MIT'
  ```
  The return value of the `license_id` function is an [SPDX] id.  Currently
  licenses are sourced from [choosealicense.com].
  [licensee]: https://github.com/benbalter/licensee
  [SPDX]: https://spdx.org/licenses/
  [choosealicense.com]: https://github.com/github/choosealicense.com

  A call to `tags_from_path` does this:
  1. What is the type: file, symlink, directory? If it's not file, stop here.
  2. Is it executable? Add the appropriate tag.
  3. Do we recognize the file extension? If so, add the appropriate tags, stop
     here. These tags would include binary/text.
  4. Peek at the first X bytes of the file. Use these to determine whether it is
     binary or text, add the appropriate tag.
  5. If identified as text above, try to read and interpret the shebang, and add
     appropriate tags.
  By design, this means we don't need to partially read files where we recognize
  the file extension.


pkgId: 3a57bf5d92d764476dc257e60b52ea4834a3f1b4deb333a0d26ba321c18661b8
name: python-idle
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Alternavtive of notepad
url: https://pypi.org/project/idle/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3ff270c3-74de-4e5c-859d-6253cbdb86a6
location_href: 00003883-python-idle/python-idle-1.0.4-1.src.rpm
checksum_type: sha256
description:
  | ![PyPI](https://img.shields.io/pypi/v/idle?style=for-the-badge) | ![PyPI - Format](https://img.shields.io/pypi/format/idle?style=for-the-badge) |
  |------|-----|
  | ![PowerShell Gallery](https://img.shields.io/powershellgallery/p/DNS.1.1.1.1?style=for-the-badge) | ![PyPI - License](https://img.shields.io/pypi/l/idle?style=for-the-badge) |
  | ![Lines of code](https://img.shields.io/tokei/lines/github/devesh01032008/idle?style=for-the-badge) | ![GitHub release (latest by date)](https://img.shields.io/github/v/release/devesh01032008/idle?style=for-the-badge) |

  This is a program written in tkinter which acts as text editor.This can be used to edit file and as alternative of notepad.


  | ![Demo Photo](img/idle-text-editor.jpg) | ![Save Photo](img/save-as-photo.jpg) |
  |------|-------|


  ```

  sudo apt install python3
  pip3 install idle


  pip install idle


  brew install python3
  pip install idle
  ```
  It would automatically launch when it is imported in program and nothing is required to launch this program

  ```
  import idle


  ```


  ![Devesh Sharma](img/devesh.jpeg)

  I am Devesh Sharma.I read in class 9. I live in samalkha,panipat located in India has created this program as alternative of text editor such as notepad
  This program aim to provide a graphical user interface to users which uses python.


  [Github](https://www.github.com/devesh01032008/)<br />
  [Email](mailto:deveshsharma1009@gmail.com)


  ```
                    Licenced
                  © Copyright 2021-22
                  All rights reserved
  ```


pkgId: a1af846b7ca86fb83be28ca7b6edcef2bb1b70b619062feb1be3dfc7dd01ca25
name: python-idna
arch: src
version: 3.4
epoch: 0
release: 1
summary: Internationalized Domain Names in Applications (IDNA)
url: https://pypi.org/project/idna/
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-87620a9c-a304-4d1f-aed7-ce3ccb4a17b0
location_href: 00008881-python-idna/python-idna-3.4-1.src.rpm
checksum_type: sha256
description:
  Support for the Internationalized Domain Names in
  Applications (IDNA) protocol as specified in `RFC 5891
  <https://tools.ietf.org/html/rfc5891>`_. This is the latest version of
  the protocol and is sometimes referred to as “IDNA 2008”.
  This library also provides support for Unicode Technical
  Standard 46, `Unicode IDNA Compatibility Processing
  <https://unicode.org/reports/tr46/>`_.
  This acts as a suitable replacement for the “encodings.idna”
  module that comes with the Python standard library, but which
  only supports the older superseded IDNA specification (`RFC 3490
  <https://tools.ietf.org/html/rfc3490>`_).
  Basic functions are simply executed:
      >>> import idna
      >>> idna.encode('ドメイン.テスト')
      b'xn--eckwd4c7c.xn--zckzah'
      >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
      ドメイン.テスト


pkgId: 4d77236b4e33c12fe22858fc3f9e7e59872b180188e745a8682c685ff0c898b6
name: python-ifaddr
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Cross-platform network interface and IP address enumeration library
url: https://github.com/pydron/ifaddr
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f5f8f29-d6ba-4716-b7e6-b5e3389bca60
location_href: 00003887-python-ifaddr/python-ifaddr-0.2.0-1.src.rpm
checksum_type: sha256
description:
  `ifaddr` is a small Python library that allows you to find all the Ethernet and
  IP addresses of the computer. It is tested on **Linux**, **OS X**, and
  **Windows**. Other BSD derivatives like **OpenBSD**, **FreeBSD**, and
  **NetBSD** should work too, but I haven't personally tested those.
  **Solaris/Illumos** should also work.
  This library is open source and released under the MIT License. It works
  with Python 3.7+.
  You can install it with `pip install ifaddr`. It doesn't need to
  compile anything, so there shouldn't be any surprises. Even on Windows.
  Project links:
  * `ifaddr GitHub page <https://github.com/smurn/ifaddr>`_
  * `ifaddr documentation (although there isn't much to document) <http://pythonhosted.org/ifaddr/>`_


pkgId: 51182c556e20f620f8acb7fa5c8272475b540c09dcaa5338e68c9301676aa871
name: python-igraph
arch: src
version: 0.10.4
epoch: 0
release: 1
summary: High performance graph data structures and algorithms
url: https://igraph.org/python
rpm_license: GNU General Public License (GPL)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-721cb244-e86f-439e-b0ce-89f1d521833d
location_href: 00003889-python-igraph/python-igraph-0.10.4-1.src.rpm
checksum_type: sha256
description:
  Python interface to the igraph high performance graph
  library, primarily aimed at complex network research and analysis.

  Graph plotting functionality is provided by the Cairo library, so make
  sure you install the Python bindings of Cairo if you want to generate
  publication-quality graph plots. You can try either `pycairo
  <http://cairographics.org/pycairo>`_ or `cairocffi <http://cairocffi.readthedocs.io>`_,
  ``cairocffi`` is recommended because there were bug reports affecting igraph
  graph plots in Jupyter notebooks when using ``pycairo`` (but not with
  ``cairocffi``).


pkgId: 6e5ef94d6b3ed484bc8564594ac1d279496909952317b74c1be42e11eb8ac12b
name: python-image
arch: src
version: 1.5.33
epoch: 0
release: 1
url: https://github.com/francescortiz/image
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-19344bae-f685-43bd-8389-b40c99b46d38
location_href: 00010559-python-image/python-image-1.5.33-1.src.rpm
checksum_type: sha256
summary:
  Django application that provides cropping, resizing, thumbnailing, overlays and masking for images and videos with the ability to set the center of attention,

description:
  Django application that provides cropping, resizing, thumbnailing, overlays and masking for images and videos with the ability to set the center of attention,


pkgId: c3408ac479f6dd61a80c34b7d261db110087f5c0c7c070edfe88139f34f2fbe8
name: python-imageio
arch: src
version: 2.27.0
epoch: 0
release: 1
url: https://github.com/imageio/imageio
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d50f360-db43-4db2-821d-c82dc19dbdde
location_href: 00009076-python-imageio/python-imageio-2.27.0-1.src.rpm
checksum_type: sha256
summary:
  Library for reading and writing a wide range of image, video, scientific, and volumetric data formats.

description:
  .. image:: https://github.com/imageio/imageio/workflows/CI/badge.svg
      :target: https://github.com/imageio/imageio/actions


  Imageio is a Python library that provides an easy interface to read and
  write a wide range of image data, including animated images, volumetric
  data, and scientific formats. It is cross-platform, runs on Python 3.5+,
  and is easy to install.

  Main website: https://imageio.readthedocs.io/


  Release notes: https://github.com/imageio/imageio/blob/master/CHANGELOG.md

  Example:

  .. code-block:: python

      >>> import imageio
      >>> im = imageio.imread('imageio:astronaut.png')
      >>> im.shape  # im is a numpy array
      (512, 512, 3)
      >>> imageio.imwrite('astronaut-gray.jpg', im[:, :, 0])

  See the `API Reference <https://imageio.readthedocs.io/en/stable/reference/index.html>`_
  or `examples <https://imageio.readthedocs.io/en/stable/examples.html>`_
  for more information.


pkgId: 29104c7e77535388368cb3b2bdf44864361d55cfd49ac1cca4527d98b96e0ff4
name: python-imagesize
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Getting image size from png/jpeg/jpeg2000/gif file
url: https://github.com/shibukawa/imagesize_py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95f0d86c-d707-4b26-b1ed-832503fdb753
location_href: 00009210-python-imagesize/python-imagesize-1.4.1-1.src.rpm
checksum_type: sha256
description:
  It parses image files' header and return image size.

  * PNG
  * JPEG
  * JPEG2000
  * GIF
  * TIFF
  * SVG
  * Netpbm
  * WebP

  This is a pure Python library.


pkgId: 3c27925aaedcaef4a600b6f0140c57bd8f72708f5d411e11d2f9f070b98c8354
name: python-imbalanced-learn
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Toolbox for imbalanced dataset in machine learning.
url: https://github.com/scikit-learn-contrib/imbalanced-learn
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-53509055-6e12-4c97-8811-76ab58f59bf8
location_href: 00003894-python-imbalanced-learn/python-imbalanced-learn-0.10.1-1.src.rpm
checksum_type: sha256
description:
  imbalanced-learn is a python package offering a number of re-sampling techniques
  commonly used in datasets showing strong between-class imbalance.
  It is compatible with scikit-learn_ and is part of scikit-learn-contrib_
  projects.


pkgId: e8b14c94e8e092cbeff09e58f055e566bc757b272c88c6d0b1d39d52cdc4392e
name: python-img2pdf
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Convert images to PDF via direct JPEG inclusion.
url: https://gitlab.mister-muffin.de/josch/img2pdf
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ccf4310-69e6-4eb8-ba83-5a0ac71283b4
location_href: 00003895-python-img2pdf/python-img2pdf-0.4.4-1.src.rpm
checksum_type: sha256
description:
  Lossless conversion of raster images to PDF. You should use img2pdf if your
  priorities are (in this order):
   1. **always lossless**: the image embedded in the PDF will always have the
      exact same color information for every pixel as the input
   2. **small**: if possible, the difference in filesize between the input image
      and the output PDF will only be the overhead of the PDF container itself
   3. **fast**: if possible, the input image is just pasted into the PDF document
      as-is without any CPU hungry re-encoding of the pixel data
  Conventional conversion software (like ImageMagick) would either:
   1. not be lossless because lossy re-encoding to JPEG
   2. not be small because using wasteful flate encoding of raw pixel data
   3. not be fast because input data gets re-encoded
  Another advantage of not having to re-encode the input (in most common
  situations) is, that img2pdf is able to handle much larger input than other
  software, because the raw pixel data never has to be loaded into memory.
  The following table shows how img2pdf handles different input depending on the
  input file format and image color space.
  | Format                                | Colorspace                     | Result        |
  | ------------------------------------- | ------------------------------ | ------------- |
  | JPEG                                  | any                            | direct        |
  | JPEG2000                              | any                            | direct        |
  | PNG (non-interlaced, no transparency) | any                            | direct        |
  | TIFF (CCITT Group 4)                  | monochrome                     | direct        |
  | any                                   | any except CMYK and monochrome | PNG Paeth     |
  | any                                   | monochrome                     | CCITT Group 4 |
  | any                                   | CMYK                           | flate         |
  For JPEG, JPEG2000, non-interlaced PNG and TIFF images with CCITT Group 4
  encoded data, img2pdf directly embeds the image data into the PDF without
  re-encoding it. It thus treats the PDF format merely as a container format for
  the image data. In these cases, img2pdf only increases the filesize by the size
  of the PDF container (typically around 500 to 700 bytes). Since data is only
  copied and not re-encoded, img2pdf is also typically faster than other
  solutions for these input formats.
  For all other input types, img2pdf first has to transform the pixel data to
  make it compatible with PDF. In most cases, the PNG Paeth filter is applied to
  the pixel data. For monochrome input, CCITT Group 4 is used instead. Only for
  CMYK input no filter is applied before finally applying flate compression.


pkgId: ee60ef189b647e549d52b29742a34e16c8971e5b94413f8290cd509a8e7ab80a
name: python-imgaug
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Image augmentation library for deep neural networks
url: https://github.com/aleju/imgaug
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d68f12a-33e5-4909-9f15-e9fd61123474
location_href: 00010547-python-imgaug/python-imgaug-0.4.0-1.src.rpm
checksum_type: sha256
description:
  A library for image augmentation in machine learning experiments, particularly convolutional
  neural networks. Supports the augmentation of images, keypoints/landmarks, bounding boxes, heatmaps and segmentation
  maps in a variety of different ways.


pkgId: c1b58334f5715e74d8adec09400b4d5037bd40ab5287ab290564151cf57c35f5
name: python-imgkit
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Wkhtmltopdf python wrapper to convert html to image using the webkit rendering engine and qt
url: https://github.com/jarrekk/imgkit
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92bab188-6d55-4ea9-b8ed-15010e59fc27
location_href: 00011679-python-imgkit/python-imgkit-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Unit Test](https://github.com/jarrekk/imgkit/actions/workflows/unit_test.yml/badge.svg?branch=master)](https://github.com/jarrekk/imgkit/actions/workflows/unit_test.yml)
  [![codecov](https://codecov.io/gh/jarrekk/imgkit/branch/master/graph/badge.svg?token=pNl4TtuAzz)](https://codecov.io/gh/jarrekk/imgkit)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/581cfb2ff94b46aa930f11824703ea88)](https://www.codacy.com/gh/jarrekk/imgkit/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=jarrekk/imgkit&amp;utm_campaign=Badge_Grade)
  [![Release](https://github.com/jarrekk/imgkit/actions/workflows/release.yml/badge.svg)](https://github.com/jarrekk/imgkit/actions/workflows/release.yml)
  [![PyPI version](https://badge.fury.io/py/imgkit.svg)](https://badge.fury.io/py/imgkit)

  ```text
    _____   __  __    _____   _  __  _   _
   |_   _| |  \/  |  / ____| | |/ / (_) | |
     | |   | \  / | | |  __  | ' /   _  | |_
     | |   | |\/| | | | |_ | |  <   | | | __|
    _| |_  | |  | | | |__| | | . \  | | | |_
   |_____| |_|  |_|  \_____| |_|\_\ |_|  \__|

  ```

  Python 2 and 3 wrapper for wkhtmltoimage utility to convert HTML to IMG using Webkit.



  1.  Install imgkit:

      ```python
      pip install imgkit
      ```

  1.  Install wkhtmltopdf:

      - Debian/Ubuntu:

        ```bash
        sudo apt-get install wkhtmltopdf
        ```

        **Warning!** Version in debian/ubuntu repos have reduced functionality (because it compiled without the wkhtmltopdf QT patches), such as adding outlines, headers, footers, TOC etc. To use this options you should install static binary from [wkhtmltopdf](http://wkhtmltopdf.org/) site or you can use this [script](https://github.com/jarrekk/imgkit/blob/master/travis/init.sh).

      - MacOSX:

        ```bash
        brew install --cask wkhtmltopdf
        ```

      - Windows and other options:

        Check [wkhtmltopdf homepage](http://wkhtmltopdf.org/) for binary installers or [wiki page](https://github.com/pdfkit/pdfkit/wiki/Installing-WKHTMLTOPDF).



  Simple example:

  ```python
  import imgkit

  imgkit.from_url('http://google.com', 'out.jpg')
  imgkit.from_file('test.html', 'out.jpg')
  imgkit.from_string('Hello!', 'out.jpg')
  ```

  Also you can pass an opened file:

  ```python
  with open('file.html') as f:
      imgkit.from_file(f, 'out.jpg')
  ```

  If you wish to further process generated IMG, you can read it to a variable:

  ```python

  img = imgkit.from_url('http://google.com', False)
  ```

  You can find all wkhtmltoimage options by type `wkhtmltoimage` command or visit this [Manual](https://wkhtmltopdf.org/usage/wkhtmltopdf.txt). You can drop '--' in option name. If option without value, use _None, False_ or _''_ for dict value:. For repeatable options (incl. allow, cookie, custom-header, post, postfile, run-script, replace) you may use a list or a tuple. With option that need multiple values (e.g. --custom-header Authorization secret) we may use a 2-tuple (see example below).

  ```python
  options = {
      'format': 'png',
      'crop-h': '3',
      'crop-w': '3',
      'crop-x': '3',
      'crop-y': '3',
      'encoding': "UTF-8",
      'custom-header' : [
          ('Accept-Encoding', 'gzip')
      ],
      'cookie': [
          ('cookie-name1', 'cookie-value1'),
          ('cookie-name2', 'cookie-value2'),
      ],
      'no-outline': None
  }

  imgkit.from_url('http://google.com', 'out.png', options=options)
  ```

  At some headless servers, perhaps you need to install **xvfb**:

  ```bash

  sudo apt-get install xvfb

  yum install xorg-x11-server-Xvfb
  ```

  Then use **IMGKit** with option **xvfb**: `{"xvfb": ""}`.

  By default, IMGKit will show all `wkhtmltoimage` output. If you don't want it, you need to pass `quiet` option:

  ```python
  options = {
      'quiet': ''
      }

  imgkit.from_url('google.com', 'out.jpg', options=options)
  ```

  Due to wkhtmltoimage command syntax, **TOC** and **Cover** options must be specified separately. If you need cover before TOC, use `cover_first` option:

  ```python
  toc = {
      'xsl-style-sheet': 'toc.xsl'
  }

  cover = 'cover.html'

  imgkit.from_file('file.html', options=options, toc=toc, cover=cover)
  imgkit.from_file('file.html', options=options, toc=toc, cover=cover, cover_first=True)
  ```

  You can specify external CSS files when converting files or strings using _css_ option.

  ```python

  css = 'example.css'
  imgkit.from_file('file.html', options=options, css=css)


  css = ['example.css', 'example2.css']
  imgkit.from_file('file.html', options=options, css=css)
  ```

  You can also pass any options through meta tags in your HTML:

  ```python
  body = """
  <html>
    <head>
      <meta name="imgkit-format" content="png"/>
      <meta name="imgkit-orientation" content="Landscape"/>
    </head>
    Hello World!
  </html>
  """

  imgkit.from_string(body, 'out.png')
  ```



  Each API call takes an optional config paramater. This should be an instance of `imgkit.config()` API call. It takes the config options as initial paramaters. The available options are:

  - `wkhtmltoimage` - the location of the `wkhtmltoimage` binary. By default `imgkit` will attempt to locate this using which` (on UNIX type systems) or where` (on Windows).
  - `xvfb` - the location of the `xvfb-run` binary. By default `imgkit` will attempt to locate this using which` (on UNIX type systems) or where` (on Windows).
  - `meta_tag_prefix` - the prefix for `imgkit` specific meta tags - by default this is `imgkit-`

  Example - for when `wkhtmltopdf` or `xvfb` is not in `$PATH`:

  ```python
  config = imgkit.config(wkhtmltoimage='/opt/bin/wkhtmltoimage', xvfb='/opt/bin/xvfb-run')
  imgkit.from_string(html_string, output_file, config=config)
  ```



  - `IOError: 'No wkhtmltopdf executable found'`:

    Make sure that you have wkhtmltoimage in your `$PATH` or set via custom configuration (see preceding section). _where wkhtmltoimage_ in Windows or _which wkhtmltoimage_ on Linux should return actual path to binary.

  - `IOError: 'No xvfb executable found'`:

    Make sure that you have xvfb-run in your `$PATH` or set via custom configuration (see preceding section). _where xvfb_ in Windows or _which xvfb-run_ or _which Xvfb_ on Linux should return actual path to binary.

  - `IOError: 'Command Failed'`:

    This error means that IMGKit was unable to process an input. You can try to directly run a command from error message and see what error caused failure (on some wkhtmltoimage versions this can be cause by segmentation faults)



  [python PDFKit](https://github.com/JazzCore/python-pdfkit)



  - **jarrekk** <https://github.com/jarrekk>



  - **v-hunt** <https://github.com/v-hunt>
  - **archydeberker** <https://github.com/archydeberker>
  - **arayate** <https://github.com/arayate>
  - **xtrntr** <https://github.com/xtrntr>
  - **mike1703** <https://github.com/mike1703>
  - **themeewa** <https://github.com/themeewa>



  Go to https://github.com/jarrekk/imgkit/wiki/CHANGE-LOG.


pkgId: af288a859553aef592034947bd38d2f726af7488cb62fc67f4b165c9b8260143
name: python-imgtag
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: Simple XMP Image Tag & Metadata Editing Library
url: https://github.com/nimaid/python-imgtag
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0232a104-70b1-4929-934d-776055231ee4
location_href: 00012612-python-imgtag/python-imgtag-1.1.6-1.src.rpm
checksum_type: sha256
description:
  It is recomended to install using Conda to create a virtual python environment, as it makes it easy to install and manage different packages. Use the following commands to set up an environment:
  ```
  conda env create -f environment.yml
  conda activate imgtag
  ```

  <br/>

  If you choose to install manually, you must install `exempi` for your OS.

  For Debian:
  ```
  sudo apt-get install -y exempi
  ```
  For a Conda environment:
  ```
  conda install -c conda-forge exempi
  ```

  Once `exempi` is installed, install `imgtag` with:
  ```
  python3 -m pip install -y imgtag
  ```

  <br/>

  To use `imgtag`:
  ```python
  from imgtag import ImgTag


  test = ImgTag(
             filename="test.jpg",   # The image file
             force_case="lower",    # Converts the case of all tags
                                    
                                    
             strip=True,            # Strips whitespace from the ends of all tags
                                    
             no_duplicates=True,    # Removes all duplicate tags (case sensitive)
                                    
             use_warnings=True      # Toggles warnings
                                    
             memory_limit_ratio=0.8 # The maximum percent of free memory to use
                                    
         )


  print("Current tags:")
  for tag in test.get_tags():
      print("  Tag:", tag)


  test.add_tags(["sleepy", "happy"])


  test.remove_tags(["cute"])


  test.set_tags(["dog", "good boy"])


  test.close()


  test.open()


  test.clear_tags()


  del(test)
  ```


pkgId: 12d2970326c7f7ae53c556748b5e75c0b9ed4cfc72ff8d688a87707920f6fc0b
name: python-imgui
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Cython-based Python bindings for dear imgui
url: https://github.com/swistakm/pyimgui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-edf854b3-d6c0-4717-82bc-f911ce3b1e02
location_href: 00011886-python-imgui/python-imgui-1.4.1-1.src.rpm
checksum_type: sha256
description:
  [![completion](https://img.shields.io/badge/completion-81%25%20%28375%20of%20460%29-blue.svg)](https://github.com/pyimgui/pyimgui)
  [![Coverage Status](https://coveralls.io/repos/github/swistakm/pyimgui/badge.svg?branch=master)](https://coveralls.io/github/swistakm/pyimgui?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/pyimgui/badge/?version=latest)](https://pyimgui.readthedocs.io/en/latest/?badge=latest)
  [![Build status](https://ci.appveyor.com/api/projects/status/mr97t941p6k4c261/branch/master?svg=true)](https://ci.appveyor.com/project/KinoxKlark/pyimgui/branch/master)




  Python bindings for the amazing
  [dear imgui](https://github.com/ocornut/imgui) C++ library - a Bloat-free
  Immediate Mode Graphical User Interface.

  Documentation: [pyimgui.readthedocs.io](https://pyimgui.readthedocs.io/en/latest/index.html)



  **pyimgui** is available on PyPI so you can easily install it with `pip`:

      pip install imgui[full]

  Above command will install `imgui` package with additional dependencies for all
  built-in rendering backend integrations (pygame, cocos2d, etc.). If you don't
  want to install all additional dependencies you can always use bare
  `pip install imgui` command or select a specific set of extra requirements:

  * for pygame backend use `pip install imgui[pygame]`
  * for GLFW3 backend use `pip install imgui[glfw]`
  * for SDL2 backend use `pip install imgui[sdl2]`
  * for Cocos2d backend use `pip install imgui[cocos2d]`
  * for pyglet backend use `pip install imgui[pyglet]`

  Package is distributed in form of *built wheels* so it does not require
  compilation on most operating systems. For more details about compatibility
  with diffferent OSes and Python versions see the *Project ditribution*
  section of this documentation page.




  The `imgui` package provides support for the majority of core ImGui widgets and
  functionalities. Some low-level API elements and complex widgets (like plots)
  may be missing. We are working hard to provide 100% feature mapping of the core
  ImGui library. The *completion badge* shows up-to-date status of that goal.

  > The current version of *pyimgui* is based on an old version of *DearImgui* and consequently doesn't have its most recent fixes and functionalities. Version 2.0 of *pyimgui* is under development and will support recent features. If you are interested, you can look at the corresponding branch.



  This project has a working build pipeline on Appveyor and Travis. It builds
  succesfully for all major operating systems with different architectures:

  * Windows (32bit & 64bit)
  * Linux (32bit & 64bit)
  * OS X (universal build)

  Right now we are ready to shipping the built wheels for these three systems
  (even for Linux using `manylinux1` wheels). The build pipeline covers multiple
  Python versions:

  * py27
  * py33 (macOS wheel not available on PyPI)
  * py34
  * py35
  * py36
  * py37
  * py38
  * py39


  **pyimgui** provides documentation with multiple visual examples.
  Thanks to custom Sphinx extensions we are able to render GUI examples off
  screen directly from docstring snippets. These examples work also as automated
  functional tests. Documentation is hosted on
  [pyimgui.readthedocs.io](https://pyimgui.readthedocs.io/en/latest/index.html).

  If none of these wheels work in your environment you can install the `imgui`
  package by compiling it directly from sdist distribution using one of following
  commands:

      
      pip install imgui[Cython] --no-binary imgui

      
      pip install imgui --no-binary imgui



  We have tried hard to make the process of bootstrapping this project as simple
  as possible.

  In order to build and install project locally ,ake sure you have created and
  activated virtual environment using `virtualenv` or `python -m venv` (for newer
  Python releases). Then you can just run:

      make build

  This command will bootstrap whole environment (pull git submodules, install
  dev requirements etc.) and build the project. `make` will automatically install
  `imgui` in the *development/editable* mode. Then you can run some examples
  found in the `doc/examples` directory in order to verify if project is working.

  For building documentation and running tests you will need some additional
  requirements from `doc/requirements-test.txt`.

  You can run tests with:

      py.test


  If you have any problems with building or installing the project just ask us
  for help by creating GitHub issue.


pkgId: 3757a5e55ad9f34a6655b648298f8d64465fdd71a00f4ddee7a8cd14df832e19
name: python-imgui-debuginfo
arch: aarch64
version: 1.4.1
epoch: 0
release: 1
summary: Debug information for package python-imgui
url: https://github.com/swistakm/pyimgui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-edf854b3-d6c0-4717-82bc-f911ce3b1e02
rpm_sourcerpm: python-imgui-1.4.1-1.src.rpm
location_href: 00011886-python-imgui/python-imgui-debuginfo-1.4.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-imgui.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e8039eeb2e435565804067a31ed847e07ee4b4cf469de9f1543190606c87fdf3
name: python-imgui-debugsource
arch: aarch64
version: 1.4.1
epoch: 0
release: 1
summary: Debug sources for package python-imgui
url: https://github.com/swistakm/pyimgui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-edf854b3-d6c0-4717-82bc-f911ce3b1e02
rpm_sourcerpm: python-imgui-1.4.1-1.src.rpm
location_href: 00011886-python-imgui/python-imgui-debugsource-1.4.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-imgui.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: a600c75425726741eb11870d584a43b65c6b709ffdaaf857565ead710127381d
name: python-immutables
arch: src
version: 0.19
epoch: 0
release: 1
summary: Immutable Collections
url: https://github.com/MagicStack/immutables
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1c6a59a-18ae-400d-8f95-ca4a961e011c
location_href: 00009424-python-immutables/python-immutables-0.19-1.src.rpm
checksum_type: sha256
description:
  An immutable mapping type for Python.
  The underlying datastructure is a Hash Array Mapped Trie (HAMT)
  used in Clojure, Scala, Haskell, and other functional languages.
  This implementation is used in CPython 3.7 in the ``contextvars``
  module (see `PEP 550 <https://www.python.org/dev/peps/pep-0550/>`_ and
  `PEP 567 <https://www.python.org/dev/peps/pep-0567/>`_ for more details).
  Immutable mappings based on HAMT have O(log N) performance for both
  ``set()`` and ``get()`` operations, which is essentially O(1) for
  relatively small mappings.
  Below is a visualization of a simple get/set benchmark comparing
  HAMT to an immutable mapping implemented with a Python dict
  copy-on-write approach (the benchmark code is available
  `here <https://gist.github.com/1st1/292e3f0bbe43bd65ff3256f80aa2637d>`_):


pkgId: 8256fab9a3a511c6470117b82e78373a3cd227c0415d844d3a10770f127c1221
name: python-immutables-debuginfo
arch: aarch64
version: 0.19
epoch: 0
release: 1
summary: Debug information for package python-immutables
url: https://github.com/MagicStack/immutables
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f1c6a59a-18ae-400d-8f95-ca4a961e011c
rpm_sourcerpm: python-immutables-0.19-1.src.rpm
location_href: 00009424-python-immutables/python-immutables-debuginfo-0.19-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-immutables.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 401bfdee196aa3a792cd3a7dc113893c6161c8744dc56d4c202b2cf9cb4e5edf
name: python-immutables-debugsource
arch: aarch64
version: 0.19
epoch: 0
release: 1
summary: Debug sources for package python-immutables
url: https://github.com/MagicStack/immutables
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f1c6a59a-18ae-400d-8f95-ca4a961e011c
rpm_sourcerpm: python-immutables-0.19-1.src.rpm
location_href: 00009424-python-immutables/python-immutables-debugsource-0.19-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-immutables.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 5018b42a5176fa4962e4d49bc0c2f195888ef9adf72873c1e8cf038770e7da11
name: python-impacket
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Network protocols Constructors and Dissectors
url: https://www.secureauth.com/labs/open-source-tools/impacket
rpm_license: Apache modified
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea121f21-059d-456e-9dc0-61a9956d2b51
location_href: 00003898-python-impacket/python-impacket-0.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](https://img.shields.io/pypi/v/impacket.svg)](https://pypi.python.org/pypi/impacket/)
  [![Build and test Impacket](https://github.com/SecureAuthCorp/impacket/actions/workflows/build_and_test.yml/badge.svg)](https://github.com/SecureAuthCorp/impacket/actions/workflows/build_and_test.yml)
  SECUREAUTH LABS. Copyright (C) 2022 SecureAuth Corporation. All rights reserved.
  Impacket is a collection of Python classes for working with network
  protocols. Impacket is focused on providing low-level
  programmatic access to the packets and for some protocols (e.g.
  SMB1-3 and MSRPC) the protocol implementation itself.
  Packets can be constructed from scratch, as well as parsed from
  raw data, and the object-oriented API makes it simple to work with
  deep hierarchies of protocols. The library provides a set of tools
  as examples of what can be done within the context of this library.
  A description of some of the tools can be found at
  [SecureAuth Labs' Open Source Website](https://www.secureauth.com/labs/open-source-tools/impacket).


pkgId: 8a85bf656fa386f19ef8030fe936b3ad9815dd240179a72bee410e46f696f55c
name: python-importlab
arch: src
version: 0.8
epoch: 0
release: 1
summary: A library to calculate python dependency graphs.
url: https://github.com/google/importlab
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a4773df-5051-4dd7-abed-e732af5b14bf
location_href: 00010777-python-importlab/python-importlab-0.8-1.src.rpm
checksum_type: sha256
description:
  Importlab is a library for Python that automatically infers dependencies
  and calculates a dependency graph. It can perform dependency ordering of
  a set of files, including cycle detection.
  Importlab's main use case is to work with static analysis tools that
  process one file at a time, ensuring that a file's dependencies are
  analysed before it is.
  (This is not an official Google product.)


pkgId: 8618fd81c730eeca2177fcbb389abc258ff2818354877567727655e1539b5a4e
name: python-impyla
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Python client for the Impala distributed query engine
url: https://github.com/cloudera/impyla
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7df10527-bcb4-4aed-b902-d765659a5109
location_href: 00009989-python-impyla/python-impyla-0.18.0-1.src.rpm
checksum_type: sha256
description:
  Python client for HiveServer2 implementations (e.g., Impala, Hive) for
  distributed query engines.

  For higher-level Impala functionality, including a Pandas-like interface over
  distributed data sets, see the [Ibis project][ibis].



  * HiveServer2 compliant; works with Impala and Hive, including nested data

  * Fully [DB API 2.0 (PEP 249)][pep249]-compliant Python client (similar to
  sqlite or MySQL clients) supporting Python 2.6+ and Python 3.3+.

  * Works with Kerberos, LDAP, SSL

  * [SQLAlchemy][sqlalchemy] connector

  * Converter to [pandas][pandas] `DataFrame`, allowing easy integration into the
  Python data stack (including [scikit-learn][sklearn] and
  [matplotlib][matplotlib]); but see the [Ibis project][ibis] for a richer
  experience



  Required:

  * Python 2.7+ or 3.5+

  * `six`, `bitarray`

  * `thrift==0.16.0`

  * `thrift_sasl==0.4.3`

  Optional:

  * `kerberos>=1.3.0` for Kerberos over HTTP support. This also requires Kerberos libraries
     to be installed on your system - see [System Kerberos](#system-kerberos)

  * `pandas` for conversion to `DataFrame` objects; but see the [Ibis project][ibis] instead

  * `sqlalchemy` for the SQLAlchemy engine

  * `pytest` for running tests; `unittest2` for testing on Python 2.6




  Different systems require different packages to be installed to enable Kerberos support in
  Impyla. Some examples of how to install the packages on different distributions follow.

  Ubuntu:
  ```bash
  apt-get install libkrb5-dev krb5-user
  ```

  RHEL/CentOS:
  ```bash
  yum install krb5-libs krb5-devel krb5-server krb5-workstation
  ```



  Install the latest release with `pip`:

  ```bash
  pip install impyla
  ```

  For the latest (dev) version, install directly from the repo:

  ```bash
  pip install git+https://github.com/cloudera/impyla.git
  ```

  or clone the repo:

  ```bash
  git clone https://github.com/cloudera/impyla.git
  cd impyla
  python setup.py install
  ```



  impyla uses the [pytest][pytest] toolchain, and depends on the following
  environment variables:

  ```bash
  export IMPYLA_TEST_HOST=your.impalad.com
  export IMPYLA_TEST_PORT=21050
  export IMPYLA_TEST_AUTH_MECH=NOSASL
  ```

  To run the maximal set of tests, run

  ```bash
  cd path/to/impyla
  py.test --connect impala
  ```

  Leave out the `--connect` option to skip tests for DB API compliance.




  Impyla implements the [Python DB API v2.0 (PEP 249)][pep249] database interface
  (refer to it for API details):

  ```python
  from impala.dbapi import connect
  conn = connect(host='my.host.com', port=21050)
  cursor = conn.cursor()
  cursor.execute('SELECT * FROM mytable LIMIT 100')
  print cursor.description  # prints the result set's schema
  results = cursor.fetchall()
  ```

  The `Cursor` object also exposes the iterator interface, which is buffered
  (controlled by `cursor.arraysize`):

  ```python
  cursor.execute('SELECT * FROM mytable LIMIT 100')
  for row in cursor:
      print(row)
  ```

  Furthermore the `Cursor` object returns you information about the columns
  returned in the query. This is useful to export your data as a csv file.

  ```python
  import csv

  cursor.execute('SELECT * FROM mytable LIMIT 100')
  columns = [datum[0] for datum in cursor.description]
  targetfile = '/tmp/foo.csv'

  with open(targetfile, 'w', newline='') as outcsv:
      writer = csv.writer(outcsv, delimiter=',', quotechar='"', quoting=csv.QUOTE_ALL, lineterminator='\n')
      writer.writerow(columns)
      for row in cursor:
          writer.writerow(row)
  ```

  You can also get back a pandas DataFrame object

  ```python
  from impala.util import as_pandas
  df = as_pandas(cur)

  ```


  [pep249]: http://legacy.python.org/dev/peps/pep-0249/
  [pandas]: http://pandas.pydata.org/
  [sklearn]: http://scikit-learn.org/
  [matplotlib]: http://matplotlib.org/
  [pytest]: http://pytest.org/latest/
  [sqlalchemy]: http://www.sqlalchemy.org/
  [ibis]: http://www.ibis-project.org/


  You need to first sign and return an
  [ICLA](https://github.com/cloudera/native-toolchain/blob/icla/Cloudera%20ICLA_25APR2018.pdf)
  and
  [CCLA](https://github.com/cloudera/native-toolchain/blob/icla/Cloudera%20CCLA_25APR2018.pdf)
  before we can accept and redistribute your contribution. Once these are submitted you are
  free to start contributing to impyla. Submit these to CLA@cloudera.com.


  We use Github issues to track bugs for this project. Find an issue that you would like to
  work on (or file one if you have discovered a new issue!). If no-one is working on it,
  assign it to yourself only if you intend to work on it shortly.

  It's a good idea to discuss your intended approach on the issue. You are much more
  likely to have your patch reviewed and committed if you've already got buy-in from the
  impyla community before you start.


  Now start coding! As you are writing your patch, please keep the following things in mind:

  First, please include tests with your patch. If your patch adds a feature or fixes a bug
  and does not include tests, it will generally not be accepted. If you are unsure how to
  write tests for a particular component, please ask on the issue for guidance.

  Second, please keep your patch narrowly targeted to the problem described by the issue.
  It's better for everyone if we maintain discipline about the scope of each patch. In
  general, if you find a bug while working on a specific feature, file a issue for the bug,
  check if you can assign it to yourself and fix it independently of the feature. This helps
  us to differentiate between bug fixes and features and allows us to build stable
  maintenance releases.

  Finally, please write a good, clear commit message, with a short, descriptive title and
  a message that is exactly long enough to explain what the problem was, and how it was
  fixed.

  Please create a pull request on github with your patch.


pkgId: 1198908b44c34053f72a08984a5ac4c1a2549309c459589109d1597d37b0c7e6
name: python-incremental
arch: src
version: 22.10.0
epoch: 0
release: 1
summary: "A small library that versions your Python projects."
url: https://github.com/twisted/incremental
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b5cc16ae-e64c-4481-8d9b-b4749eb89280
location_href: 00009360-python-incremental/python-incremental-22.10.0-1.src.rpm
checksum_type: sha256
description:
  |gha|
  |pypi|
  |coverage|
  Incremental is a small library that versions your Python projects.
  API documentation can be found `here <https://twisted.github.io/incremental/docs/>`_.


pkgId: 1f71c5d26960b121802cc345e5e877cf34201c7602167392875e0b4584c3e3e4
name: python-indexed-gzip
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Fast random access of gzip files in Python
url: https://github.com/pauldmccarthy/indexed_gzip
rpm_license: zlib
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72d2dd16-9aea-4564-94c8-c6888eb9af3c
location_href: 00003900-python-indexed_gzip/python-indexed-gzip-1.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi version](https://img.shields.io/pypi/v/indexed_gzip.svg)](https://pypi.python.org/pypi/indexed_gzip/) [![Anaconda version](https://anaconda.org/conda-forge/indexed_gzip/badges/version.svg)](https://anaconda.org/conda-forge/indexed_gzip/)![Test status](https://github.com/pauldmccarthy/indexed_gzip/actions/workflows/master.yaml/badge.svg)


   *Fast random access of gzip files in Python*


   * [Overview](#overview)
   * [Installation](#installation)
   * [Usage](#usage)
   * [Using with `nibabel`](#using-with-nibabel)
   * [Index import/export](#index-import-export)
   * [Write support](#write-support)
   * [Performance](#performance)
   * [Acknowledgements](#acknowledgements)
   * [License](#license)





  The `indexed_gzip` project is a Python extension which aims to provide a
  drop-in replacement for the built-in Python `gzip.GzipFile` class, the
  `IndexedGzipFile`.


  `indexed_gzip` was written to allow fast random access of compressed
  [NIFTI](http://nifti.nimh.nih.gov/) image files (for which GZIP is the
  de-facto compression standard), but will work with any GZIP file.
  `indexed_gzip` is easy to use with `nibabel` (http://nipy.org/nibabel/).


  The standard `gzip.GzipFile` class exposes a random access-like interface (via
  its `seek` and `read` methods), but every time you seek to a new point in the
  uncompressed data stream, the `GzipFile` instance has to start decompressing
  from the beginning of the file, until it reaches the requested location.


  An `IndexedGzipFile` instance gets around this performance limitation by
  building an index, which contains *seek points*, mappings between
  corresponding locations in the compressed and uncompressed data streams. Each
  seek point is accompanied by a chunk (32KB) of uncompressed data which is used
  to initialise the decompression algorithm, allowing us to start reading from
  any seek point. If the index is built with a seek point spacing of 1MB, we
  only have to decompress (on average) 512KB of data to read from any location
  in the file.





  You may find `indexed_gzip` useful if you need to read from large GZIP files.
  A major advantage of `indexed_gzip` is that it will work with any GZIP file.
  However, if you have control over the creation of your GZIP files, you may
  wish to consider some alternatives:

   * [`mgzip`](https://github.com/vinlyx/mgzip/) provides an accelerated
     GZIP compression and decompression library.
   * Compression formats other than GZIP, such as `bzip2` and `xz`, have better
     support for random access.





  `indexed_gzip` is available on [PyPi](https://pypi.python.org/pypi) - to
  install, simply type:
  ```sh
  pip install indexed_gzip
  ```


  You can also install `indexed_gzip` from conda-forge:

  ```sh
  conda install -c conda-forge indexed_gzip
  ```

  To compile `indexed_gzip`, make sure you have [cython](http://cython.org/)
  installed (and `numpy` if you want to compile the tests), and then run:
  ```sh
  python setup.py develop
  ```


  To run the tests, type the following; you will need `numpy`, `nibabel`,
  `pytest`, `pytest-cov`, and `coverage` installed:

  ```sh
  python -m indexed_gzip.tests
  ```




  You can use the `indexed_gzip` module directly:


  ```python
  import indexed_gzip as igzip






  myfile = igzip.IndexedGzipFile('big_file.gz')

  some_offset_into_uncompressed_data = 234195



  myfile.seek(some_offset_into_uncompressed_data)
  data = myfile.read(1048576)
  ```




  You can use `indexed_gzip` with any Python file-like object. For example:

  ```python

  import io
  import indexed_gzip as igzip


  with open('my_file.gz') as f:
      data = f.read()



  gzf = igzip.IndexedGzipFile(fileobj=io.BytesIO(data))
  uncompressed = gzf.read(1048576)
  ```





  You can use `indexed_gzip` with `nibabel`. `nibabel` >= 2.3.0 will
  automatically use `indexed_gzip` if it is present:


  ```python
  import nibabel as nib

  image = nib.load('big_image.nii.gz')
  ```


  If you are using `nibabel` 2.2.x, you need to explicitly set the
  `keep_file_open` flag:


  ```python
  import nibabel as nib

  image = nib.load('big_image.nii.gz', keep_file_open='auto')
  ```


  To use `indexed_gzip` with `nibabel` 2.1.0 or older, you need to do a little
  more work:


  ```python
  import nibabel      as nib
  import indexed_gzip as igzip




  fobj = igzip.IndexedGzipFile(
      filename='big_image.nii.gz',
      spacing=4194304,
      readbuf_size=131072)



  fmap = nib.Nifti1Image.make_file_map()
  fmap['image'].fileobj = fobj
  image = nib.Nifti1Image.from_file_map(fmap)




  vol3 = image.dataobj[:, :, :, 3]
  ```





  If you have a large file, you may wish to pre-generate the index once, and
  save it out to an index file:


  ```python
  import indexed_gzip as igzip



  fobj = igzip.IndexedGzipFile('big_file.gz')
  fobj.build_full_index()
  fobj.export_index('big_file.gzidx')
  ```


  The next time you open the same file, you can load in the index:


  ```python
  import indexed_gip as igzip
  fobj = igzip.IndexedGzipFile('big_file.gz', index_file='big_file.gzidx')
  ```





  `indexed_gzip` does not currently have any support for writing. Currently if
  you wish to write to a file, you will need to save the file by alternate means
  (e.g.  via `gzip` or `nibabel`), and then re-create a new `IndexedGzipFile`
  instance.  For example:


  ```python

  import nibabel as nib


  image = nib.load('big_image.nii.gz')
  data = image.get_data()


  data[:, :, :, 5] *= 100


  nib.save(data, 'big_image.nii.gz')


  image = nib.load('big_image.nii.gz')
  ```





  A small [test script](indexed_gzip/tests/benchmark.py) is included with
  `indexed_gzip`; this script compares the performance of the `IndexedGzipFile`
  class with the `gzip.GzipFile` class. This script does the following:

    1. Generates a test file.

    2. Generates a specified number of seek locations, uniformly spaced
       throughout the test file.

    3. Randomly shuffles these locations

    4. Seeks to each location, and reads a chunk of data from the file.


  This plot shows the results of this test for a few compresed files of varying
  sizes, with 500 seeks:


  ![Indexed gzip performance](./performance.png)





  The `indexed_gzip` project is based upon the `zran.c` example (written by Mark
  Alder) which ships with the [zlib](http://www.zlib.net/) source code.


  `indexed_gzip` was originally inspired by Zalan Rajna's (@zrajna)
  [zindex](https://github.com/zrajna/zindex) project:

      Z. Rajna, A. Keskinarkaus, V. Kiviniemi and T. Seppanen
      "Speeding up the file access of large compressed NIfTI neuroimaging data"
      Engineering in Medicine and Biology Society (EMBC), 2015 37th Annual
      International Conference of the IEEE, Milan, 2015, pp. 654-657.

      https://sourceforge.net/projects/libznzwithzindex/


  Initial work on `indexed_gzip` took place at
  [Brainhack](http://www.brainhack.org/) Paris, at the Institut Pasteur,
  24th-26th February 2016, with the support of the
  [FMRIB Centre](https://www.ndcn.ox.ac.uk/divisions/fmrib/), at the
  University of Oxford, UK.

  Many thanks to the following contributors (listed chronologically):

   - Zalan Rajna (@zrajna): Bug fixes (#2)
   - Martin Craig (@mcraig-ibme): Porting `indexed_gzip` to Windows (#3)
   - Chris Markiewicz (@effigies): Option to drop file handles (#6)
   - Omer Ozarslan (@ozars): Index import/export (#8)
   - @DarioDaF: Windows overflow bug (#30)
   - Sławomir Zborowski (@szborows): `seek_points` method (#35), README fixes
     (#34)
   - Ashwin Ramaswami (@epicfaace): Support for in-memory file objects (#55),
     bug fixes (#63, #64, #65).
   - Michał Górny (@mgorny): Remove hard dependency on `nibabel` from test suite
     (#78).
   - Alexander Gorban (@alexgorban) Fix memory leak (#82, #83).
   - Maximilian Knespel (@mxmlnkn) Change default read buffer size to
     improve performance (#90).





  `indexed_gzip` inherits the [zlib](http://www.zlib.net) license, available for
  perusal in the [LICENSE](LICENSE) file.


pkgId: f8342cd627e1301c98af588fdbdd708fa4c71ad1501e46cb493bd8a7469a606c
name: python-inema
arch: src
version: 0.8.7
epoch: 0
release: 1
summary: A Python interface to the Deutsche Post Internetmarke and Warenpost International Online Franking
url: https://git.sysmocom.de/odoo/python-inema/
rpm_license: AGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d7b9a68-7d07-48b9-a8af-9cee0cef50d8
location_href: 00003901-python-inema/python-inema-0.8.7-1.src.rpm
checksum_type: sha256
description:
  This is a python module for interfacing the "Internetmarke" API provided
  by the German postal company "Deutsche Post".  It implements V3 of this
  API.  It also implements the new (2020) "Warenpost International API".
  The Internetmarke API allows you to buy online franking for national and
  international postal products like post cards and letters of all weight
  classes and service classes (normal, registered, ...).


pkgId: 545fc575fd81856c698c48d1f7b12a0212b065f793770ea8aa3577c587a838bd
name: python-inflection
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A port of Ruby on Rails inflector to Python
url: https://github.com/jpvanhal/inflection
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eacd581f-2500-442b-a592-85a513592bfe
location_href: 00003903-python-inflection/python-inflection-0.5.1-1.src.rpm
checksum_type: sha256
description:
  |build status|_
  Inflection is a string transformation library.  It singularizes and pluralizes
  English words, and transforms strings from CamelCase to underscored string.
  Inflection is a port of `Ruby on Rails`_' `inflector`_ to Python.


pkgId: 564e3fbc6dd5e89d0f0cbea631292b7dd6fd53412546977400baf8d0f4939f33
name: python-influxdb
arch: src
version: 5.3.1
epoch: 0
release: 1
summary: InfluxDB client
url: https://github.com/influxdb/influxdb-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3e5f8b8d-da90-4775-8cbd-62ef94918b2e
location_href: 00003904-python-influxdb/python-influxdb-5.3.1-1.src.rpm
checksum_type: sha256
description:
  InfluxDB-Python is a client for interacting with InfluxDB_.
  Development of this library is maintained by:
  +-----------+-------------------------------+
  | Github ID | URL                           |
  +===========+===============================+
  | @aviau    | (https://github.com/aviau)    |
  +-----------+-------------------------------+
  | @xginn8   | (https://github.com/xginn8)   |
  +-----------+-------------------------------+
  | @sebito91 | (https://github.com/sebito91) |
  +-----------+-------------------------------+
  InfluxDB is an open-source distributed time series database, find more about InfluxDB_ at https://docs.influxdata.com/influxdb/latest


pkgId: bc6c74f5c66252dd0ccd095dfb2ff21d09e902245507876b0f0571ee3c7a3a2c
name: python-iniparse
arch: src
version: 0.5
epoch: 0
release: 1
summary: Accessing and Modifying INI files
url: https://github.com/candlepin/python-iniparse
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-56308390-57ed-4b32-9ade-19306d749643
location_href: 00012218-python-iniparse/python-iniparse-0.5-1.src.rpm
checksum_type: sha256
description:
  iniparse is an INI parser for Python which is API compatible
  with the standard library's ConfigParser, preserves structure of INI
  files (order of sections & options, indentation, comments, and blank
  lines are preserved when data is updated), and is more convenient to
  use.


pkgId: eb79557183ecc23c70c7a491aa3e5a0f1de7ba1b7d145ff859b6bed968291df9
name: python-inotify-simple
arch: src
version: 1.3.5
epoch: 0
release: 1
url: https://github.com/chrisjbillington/inotify_simple
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-85968cb2-741c-4438-9f21-efbe3f33e35d
location_href: 00003908-python-inotify_simple/python-inotify-simple-1.3.5-1.src.rpm
checksum_type: sha256
summary:
  A simple wrapper around inotify. No fancy bells and whistles, just a literal wrapper with ctypes. Under 100 lines of code!

description:
  `inotify_simple` is a simple Python wrapper around
  [inotify](http://man7.org/linux/man-pages/man7/inotify.7.html).
  No fancy bells and whistles, just a literal wrapper with ctypes. Only  \~100
  lines of code!

  `inotify_init1()` is wrapped as a file-like object, `INotify()`, holding the inotify
  file descriptor. `INotify().read()` reads available data from the file descriptor and
  returns events as `namedtuple` objects after unpacking them with the `struct` module.
  `inotify_add_watch()` and `inotify_rm_watch()` are wrapped with no changes at all,
  taking and returning watch descriptor integers that calling code is expected to keep
  track of itself, just as one would use `inotify` from C. Works with Python 2.7 and
  Python >= 3.2.

  [View on PyPI](http://pypi.python.org/pypi/inotify_simple) |
  [Fork me on github](https://github.com/chrisjbillington/inotify_simple) |
  [Read the docs](http://inotify_simple.readthedocs.org)




  to install `inotify_simple`, run:

  ```
  $ pip3 install inotify_simple
  ```

  or to install from source:

  ```
  $ python3 setup.py install
  ```

  Note:  If on Python < 3.4, you'll need the backported [enum34
  module](https://pypi.python.org/pypi/enum34).



  There are many inotify python wrappers out there. [I found them all
  unsatisfactory](https://xkcd.com/927/). Most are far too high-level for my
  tastes, and the supposed convenience they provide actually limits one from
  using inotify in ways other than those the author imagined. Others are C
  extensions, requiring compilation for different platforms and Python versions,
  rather than a pure python module using ctypes. This one is pretty low-level
  and really just does what inotify itself does and nothing more. So hopefully
  if I've written it right, it will remain functional well into the future with
  no changes, recompilation or attention on my part.



  ```python
  import os
  from inotify_simple import INotify, flags

  os.mkdir('/tmp/inotify_test')

  inotify = INotify()
  watch_flags = flags.CREATE | flags.DELETE | flags.MODIFY | flags.DELETE_SELF
  wd = inotify.add_watch('/tmp/inotify_test', watch_flags)


  os.chdir('/tmp/inotify_test')

  os.system('mkdir foo')

  os.system('echo hello > test.txt')

  os.system('echo world >> test.txt')

  os.system('rm test.txt')

  os.system('rmdir foo')
  os.chdir('/tmp')


  os.system('rmdir inotify_test')


  for event in inotify.read():
      print(event)
      for flag in flags.from_mask(event.mask):
          print('    ' + str(flag))
  ```

  This outputs the following:
  ```
  Event(wd=1, mask=1073742080, cookie=0, name=u'foo')
      flags.CREATE
      flags.ISDIR
  Event(wd=1, mask=256, cookie=0, name=u'test.txt')
      flags.CREATE
  Event(wd=1, mask=2, cookie=0, name=u'test.txt')
      flags.MODIFY
  Event(wd=1, mask=512, cookie=0, name=u'test.txt')
      flags.DELETE
  Event(wd=1, mask=1073742336, cookie=0, name=u'foo')
      flags.DELETE
      flags.ISDIR
  Event(wd=1, mask=1024, cookie=0, name=u'')
      flags.DELETE_SELF
  Event(wd=1, mask=32768, cookie=0, name=u'')
      flags.IGNORED
  ```

  Note that the flags, since they are defined with an `enum.IntEnum`, print as
  what they are called rather than their integer values. However they are still
  just integers and so can be bitwise-ANDed and ORed etc with masks etc. The
  `flags.from_mask()` method bitwise-ANDs a mask with all possible flags and
  returns a list of matches. This is for convenience and useful for debugging
  which events are coming through, but performance critical code should
  generally bitwise-AND masks with flags of interest itself so as to not do
  unnecessary checks.

  [See here](http://inotify_simple.readthedocs.org) for more.


pkgId: 01626fe64c2dd979b2c918c84fec18fb1397115c32790f2417a69fb3bd3d4395
name: python-inspecta
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A colorized object pretty printer - for Python.
url: https://github.com/grimen/python-inspecta
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8af9c9fe-7669-4bbb-9236-3f657ecc3659
location_href: 00012845-python-inspecta/python-inspecta-0.1.3-1.src.rpm
checksum_type: sha256
description:
  *A colorized object pretty printer - for Python.*



  The default `pprint` is not human friendly enough - color syntax highlighting to the rescue.




  Install using **pip**:

  ```sh
  $ pip install inspecta
  ```




  Very basic **[example](https://github.com/grimen/python-inspecta/tree/master/examples/basic.py)**:

  ```python
  import inspecta

  data = {
      'foo': {
          'bar': {
              'baz': [
                  {
                      'a': 1,
                      'b': 'two',
                      'c': ('three', 4, 'five')
                  }
              ]
          }
      },
      'bar': [1, 2, 3],
      'baz': True
  }

  print('\n.inspect(data)\n')

  print(inspecta.inspect(data))

  print('\n.print(data)\n')

  inspecta.print(data)
  ```

  Run this with optional environment variables `COLORS` / `ERROR_COLORS` set too truthy or falsy values, so see various error info formatting in terminal.

  Something like this (imagine some colorized formatting):

  ```bash

  .inspect(data)

  {   'bar': [1, 2, 3],
      'baz': True,
      'foo': {'bar': {'baz': [{'a': 1, 'b': 'two', 'c': ('three', 4, 'five')}]}}}


  .print(data)

  {   'bar': [1, 2, 3],
      'baz': True,
      'foo': {'bar': {'baz': [{'a': 1, 'b': 'two', 'c': ('three', 4, 'five')}]}}}


  ```




  Clone down source code:

  ```sh
  $ make install
  ```

  Run **colorful tests**, with only native environment (dependency sandboxing up to you):

  ```sh
  $ make test
  ```

  Run **less colorful tests**, with **multi-environment** (using **tox**):

  ```sh
  $ make test-tox
  ```




  This project was mainly initiated - in lack of solid existing alternatives - to be used at our work at **[Markable.ai](https://markable.ai)** to have common code conventions between various programming environments where **Python** (research, CV, AI) is heavily used.




  Released under the MIT license.


pkgId: e97464f32746a59304eb07bcd94a625f5e25c59ece437ffb0da7af0e69b27e46
name: python-instagrapi
arch: src
version: 1.17.3
epoch: 0
release: 1
summary: Fast and effective Instagram Private API wrapper
url: https://github.com/adw0rd/instagrapi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8c979e4-81ef-492d-9ea4-5db0ddbf308b
location_href: 00013471-python-instagrapi/python-instagrapi-1.17.3-1.src.rpm
checksum_type: sha256
description:
  Fast and effective Instagram Private API wrapper (public+private requests and challenge resolver).

  Use the most recent version of the API from Instagram.

  Features:

  1. Performs Public API (web, anonymous) or Private API (mobile app, authorized)
     requests depending on the situation (to avoid Instagram limits)
  2. Challenge Resolver have Email (as well as recipes for automating receive a code from email) and SMS handlers
  3. Support upload a Photo, Video, IGTV, Clips (Reels), Albums and Stories
  4. Support work with User, Media, Insights, Collections, Location (Place), Hashtag and Direct objects
  5. Like, Follow, Edit account (Bio) and much more else
  6. Insights by account, posts and stories
  7. Build stories with custom background, font animation, swipe up link and mention users
  8. In the next release, account registration and captcha passing will appear


pkgId: 07ca3aa9e76379a7724212c68d79f7594a8257f73bf74ce493b7d3f3372fae1a
name: python-install
arch: src
version: 1.3.5
epoch: 0
release: 1
summary: Install packages from within code
url: https://github.com/eugenekolo/pip-install
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-36916aac-d47c-4c00-91eb-c4f0e7307288
location_href: 00010275-python-install/python-install-1.3.5-1.src.rpm
checksum_type: sha256
description:
  A package to install pip packages from within code.

  Requires Python 2.7+, 3.5+

  Usage:
  ```
  import install
  install.install('pkg_you_want')


  install.install('requirements.txt', requirements=True)


  install.install('my_pkg', pip_options=['--isolated'], install_options=['--no-clean', '--pre'])
  ```


pkgId: 3ea042901e8e0a90a85847c6d14490b3271b4609f5d41d265e6b2a44af497c45
name: python-instaloader
arch: src
version: 4.9.6
epoch: 0
release: 1
summary: Download pictures (or videos) along with their captions and other metadata from Instagram.
url: https://instaloader.github.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f86d60b8-aa0d-4032-9b2a-bbf6d80b212e
location_href: 00012768-python-instaloader/python-instaloader-4.9.6-1.src.rpm
checksum_type: sha256
description:
  To **download all pictures and videos of a profile**, as well as the
  **profile picture**, do
      instaloader profile [profile ...]
  where ``profile`` is the name of a profile you want to download. Instead
  of only one profile, you may also specify a list of profiles.
  To later **update your local copy** of that profiles, you may run
      instaloader --fast-update profile [profile ...]
  If ``--fast-update`` is given, Instaloader stops when arriving at the
  first already-downloaded picture.
  Alternatively, you can use ``--latest-stamps`` to have Instaloader store
  the time each profile was last downloaded and only download newer media:
      instaloader --latest-stamps -- profile [profile ...]
  With this option it's possible to move or delete downloaded media and still keep
  the archive updated.
  When updating profiles, Instaloader
  automatically **detects profile name changes** and renames the target directory
  accordingly.
  Instaloader can also be used to **download private profiles**. To do so,
  invoke it with
      instaloader --login=your_username profile [profile ...]
  When logging in, Instaloader **stores the session cookies** in a file in your
  temporary directory, which will be reused later the next time ``--login``
  is given.  So you can download private profiles **non-interactively** when you
  already have a valid session cookie file.
  `Instaloader Documentation <https://instaloader.github.io/basic-usage.html>`__


pkgId: 5e7acb6340f29b1084fb75b3e7d2d15755c944bc16c10a79014b0b1cb927fb4d
name: python-instana
arch: src
version: 1.38.2
epoch: 0
release: 1
summary: 🐍 Python Distributed Tracing & Metrics Sensor for Instana
url: https://www.instana.com/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-316f9347-7d49-46bf-9b95-b98e1251ff49
location_href: 00009726-python-instana/python-instana-1.38.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://disznc.s3.amazonaws.com/python-dashboard-2019.gif"/>
  </div>



  The `instana` Python package collects key metrics and distributed traces for [Instana](https://www.instana.com/).

  This package supports Python 2.7 or greater.

  Any and all feedback is welcome.  Happy Python visibility.

  [![CircleCI](https://circleci.com/gh/instana/python-sensor/tree/master.svg?style=svg)](https://circleci.com/gh/instana/python-sensor/tree/master)
  [![OpenTracing Badge](https://img.shields.io/badge/OpenTracing-enabled-blue.svg)](http://opentracing.io)



  None

  _Instana remotely instruments your Python web servers automatically via Instana [AutoTrace™️](https://www.instana.com/supported-technologies/instana-autotrace/).  To configure which Python processes this applies to, see the [Configuration page](https://docs.instana.io/ecosystem/python/configuration/#general)._



  If you wish to manually instrument your applications you can install the package with the following into the virtualenv, pipenv or container ([hosted on pypi](https://pypi.python.org/pypi/instana)):

      pip install instana

  or to alternatively update an existing installation:

      pip install -U instana



  The Instana package can then be activated _without any code changes required_ by setting the following environment variable for your Python application:

      export AUTOWRAPT_BOOTSTRAP=instana

  This will cause the Instana Python package to automatically instrument your Python application.  Once it finds the Instana host agent, it will begin to report Python metrics and distributed traces.



  Alternatively, if you prefer the really manual method, simply import the `instana` package inside of your Python application:

      import instana

  See also our detailed [Installation document](https://www.instana.com/docs/ecosystem/python/#installing) for additional information covering Django, Flask, End-user Monitoring (EUM) and more.



  You can find more documentation covering supported components and minimum versions in the Instana [documentation portal](https://docs.instana.io/ecosystem/python/).



  Bug reports and pull requests are welcome on GitHub at https://github.com/instana/python-sensor.



  Want to instrument other languages?  See our [Node.js](https://github.com/instana/nodejs), [Go](https://github.com/instana/golang-sensor), [Ruby](https://github.com/instana/ruby-sensor) instrumentation or [many other supported technologies](https://www.instana.com/supported-technologies/).


pkgId: 4a8369cda93e842820e9bb9197e6c14bd9876950f7cbf1dfbe25878a771f87ed
name: python-insteon
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A utility for interacting with insteon modems and hubs
url: https://github.com/pfrommerd/python-insteon
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9dc3bd9e-932e-49b8-b1c7-85ba01d080e0
location_href: 00003910-python-insteon/python-insteon-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A set of utilities for interacting with insteon modems and hubs

  Used as a backend for the Insteon Terminal and several insteon plugins


pkgId: 64ff9585288b16d61cdf78aac9c3b1ccdfb32372897c5f89d0b6cd7c059a7ed7
name: python-intelhex
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Python library for Intel HEX files manipulations
url: https://github.com/python-intelhex/intelhex
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-714da9d5-b34e-43ed-a817-ed20ff656f16
location_href: 00003911-python-intelhex/python-intelhex-2.3.0-1.src.rpm
checksum_type: sha256
description:
  The Intel HEX file format is widely used in microprocessors and microcontrollers
  area (embedded systems etc) as the de facto standard
  for representation of code to be programmed into microelectronic devices.
  This work implements an ``intelhex`` Python library to read, write,
  create from scratch and manipulate data from Intel HEX file format.
  The distribution package also includes several convenience Python scripts,
  including "classic" ``hex2bin`` and ``bin2hex`` converters and more,
  those based on the library itself. Check the docs to know more.


pkgId: ca5ded8357d0e272193cac852fdfc598d57a72cc0290a89bfd80fcad46e335e9
name: python-interpret
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Fit interpretable models. Explain blackbox machine learning.
url: https://github.com/interpretml/interpret
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2a5cebd8-be51-495e-bc0b-0be8f3fdaabe
location_href: 00012775-python-interpret/python-interpret-0.3.2-1.src.rpm
checksum_type: sha256
description:
  In the beginning machines learned in darkness, and data scientists struggled in the void to explain them.

  Let there be light.

  https://github.com/interpretml/interpret


pkgId: 64a368860b7a11f2cfa2e00080dece70e4a2ac0e5d88cfcb202da4a28c4bfd5c
name: python-intervaltree
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Editable interval tree data structure for Python 2 and 3
url: https://github.com/chaimleib/intervaltree
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d99419c3-b898-4526-9b3c-b7051a417756
location_href: 00003913-python-intervaltree/python-intervaltree-3.1.0-1.src.rpm
checksum_type: sha256
description:
  A mutable, self-balancing interval tree for Python 2 and 3. Queries may be by point, by range overlap, or by range envelopment.
  This library was designed to allow tagging text and time intervals, where the intervals include the lower bound but not the upper bound.
  **Version 3 changes!**
  * The `search(begin, end, strict)` method no longer exists. Instead, use one of these:
      * `at(point)`
      * `overlap(begin, end)`
      * `envelop(begin, end)`
  * The `extend(items)` method no longer exists. Instead, use `update(items)`.
  * Methods like `merge_overlaps()` which took a `strict` argument consistently default to `strict=True`. Before, some methods defaulted to `True` and others to `False`.


pkgId: c773fcb14a03c3964f71321543331b43e65206b82435c66b43cdfe3f39ecef11
name: python-into-dbus-python
arch: src
version: 0.8
epoch: 0
release: 1
summary: transforms values into properly wrapped dbus-python objects
url: https://github.com/stratis-storage/into-dbus-python
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94bee1e4-95f8-4f35-b3d7-17112be69466
location_href: 00003914-python-into-dbus-python/python-into-dbus-python-0.8-1.src.rpm
checksum_type: sha256
description:
  Facilities for converting an object that inhabits core Python types, e.g.,
  lists, ints, dicts, to an object that inhabits dbus-python types, e.g.,
  dbus.Array, dbus.UInt32, dbus.Dictionary based on a specified dbus signature.


pkgId: bdae8af57d753c9578d5e7482c44de32ee96cdb862683a56a58884777e98f820
name: python-intuit-oauth
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Intuit OAuth Client
url: https://github.com/intuit/oauth-pythonclient
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9beeb68b-4657-49a1-972d-320b0453bf69
location_href: 00012755-python-intuit-oauth/python-intuit-oauth-1.2.4-1.src.rpm
checksum_type: sha256
description:
  |build| |coverage| |docs|
  This client library is meant to work with Intuit's OAuth and OpenID implementation. The `AuthClient` object response can be used for User Info API, Accounting API and Payments API. This library supports:
  - Generating Authorization URL
  - Getting OAuth2 Bearer Token
  - Getting User Info
  - Validating OpenID token
  - Refreshing OAuth2 Token
  - Revoking OAuth2 Token
  - Migrating tokens from OAuth1.0 to OAuth2


pkgId: 1e90bbf59a30c8650f523c2ce7838d3a28fbc66de653e4b769ffe70beb23de27
name: python-invoke
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Pythonic task execution
url: https://pyinvoke.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ff6be5c4-f3c3-4956-9a8f-b10b4b33fc96
location_href: 00009375-python-invoke/python-invoke-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Invoke is a Python (2.7 and 3.4+) library for managing shell-oriented
  subprocesses and organizing executable Python code into CLI-invokable tasks. It
  draws inspiration from various sources (``make``/``rake``, Fabric 1.x, etc) to
  arrive at a powerful & clean feature set.
  To find out what's new in this version of Invoke, please see `the changelog
  <https://pyinvoke.org/changelog.html#{}>`_.
  The project maintainer keeps a `roadmap
  <https://bitprophet.org/projects#roadmap>`_ on his website.
  For a high level introduction, including example code, please see `our main
  project website <https://pyinvoke.org>`_; or for detailed API docs, see `the
  versioned API website <https://docs.pyinvoke.org>`_.


pkgId: cc464b457044b2fca6e52e4674850810417c20a7167597171a54855c5895002f
name: python-iowait
arch: src
version: 0.2
epoch: 0
release: 1
summary: Platform-independent module for I/O completion events
url: https://launchpad.net/python-iowait
rpm_license: GNU LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c9fc714f-34fe-478e-bb5a-9bab95c7dde2
location_href: 00003915-python-iowait/python-iowait-0.2-1.src.rpm
checksum_type: sha256
description:
  Different operating systems provide different ways to wait for I/O completion
  events: there's ``select()``, ``poll()``, ``epoll()`` and ``kqueue()``. For
  cross-platform applications it can be a pain to support all this system
  functions, especially because each one provides a different interface.
  IOWait solves this problem by providing a unified interface and using always
  the best and faster function available in the platform. Its only limitation is
  that, on Windows, it only works for sockets.
  This library is compatible both with Python 2 and 3.


pkgId: 0a917f8f36c27ca27661b6758e25f575db89aa4ec5de57cd3dce2d652f3743a7
name: python-ipaddr
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Google's IP address manipulation library
url: https://github.com/google/ipaddr-py
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1fc5adb7-01a6-46ef-a02f-de9673789021
location_href: 00010244-python-ipaddr/python-ipaddr-2.2.0-1.src.rpm
checksum_type: sha256
description:
  ipaddr.py is a library for working with IP addresses, both IPv4 and IPv6.

  It has been superseded by ipaddress from the Python 3 standard library, and its
  Python 2 backport.


pkgId: 25befd30d18b83f126c5ba1327de6bca8dd1b33a7cf2998d6229b0d717707fe4
name: python-ipfshttpclient
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python IPFS HTTP CLIENT library
url: https://ipfs.io/ipns/12D3KooWEqnTdgqHnkkwarSrJjeMP2ZJiADWLYADaNvUb6SQNyPF/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c87a3efc-35db-4f3e-b63a-5d948a8a5166
location_href: 00010733-python-ipfshttpclient/python-ipfshttpclient-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Made by the IPFS Community](https://img.shields.io/badge/made%20by-IPFS%20Community-blue.svg?style=flat-square)](https://docs.ipfs.io/community/)
  [![IRC #py-ipfs on chat.freenode.net](https://img.shields.io/badge/freenode%20IRC-%23py--ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23py-ipfs)
  [![Matrix #py-ipfs:ninetailed.ninja](https://img.shields.io/matrix/py-ipfs:ninetailed.ninja?color=blue&label=matrix%20chat&server_fqdn=matrix.ninetailed.ninja&style=flat-square)](https://matrix.to/#/#py-ipfs:ninetailed.ninja?via=matrix.ninetailed.ninja&via=librem.one)
  [![Standard README Compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
  [![PyPI Package ipfshttpclient](https://img.shields.io/pypi/dm/ipfshttpclient.svg?style=flat-square)](https://pypi.python.org/pypi/ipfshttpclient)
  [![Build Status](https://img.shields.io/travis/com/ipfs-shipyard/py-ipfs-http-client/master.svg?style=flat-square)](https://travis-ci.com/github/ipfs-shipyard/py-ipfs-http-client)

  ![Python IPFS HTTP Client Library](https://ipfs.io/ipfs/QmQJ68PFMDdAsgCZvA1UVzzn18asVcf7HVvCDgpjiSCAse)

  Check out [the HTTP Client reference](https://ipfs.io/ipns/12D3KooWEqnTdgqHnkkwarSrJjeMP2ZJiADWLYADaNvUb6SQNyPF/docs/) for the full command reference.

  **Note**: The `ipfsapi` PIP package and Python module have both been renamed to `ipfshttpclient`!
  See the [relevant section of the CHANGELOG](CHANGELOG.md#py-ipfs-http-client-0411-13052019) for details. There is also a `ipfsApi` library from which this library originated that is completely
  unmaintained and does not work with any recent go-IPFS version.

  **Note**: This library occasionally has to change to stay compatible with the IPFS HTTP API.
  Currently, this library is tested against [go-ipfs v0.7.0](https://github.com/ipfs/go-ipfs/releases/tag/v0.7.0).
  We strive to support the last 5 releases of go-IPFS at any given time; go-IPFS v0.4.23 therefore
  being to oldest supported version at this time.



  - [Install](#install)
  - [Usage](#usage)
  - [Documentation](#documentation)
    - [Migrating from 0.4.x to 0.6.0](#migrating-from-04x-to-060)
  - [Featured Projects](#featured-projects)
  - [Contributing](#contributing)
    - [Bug reports](#bug-reports)
    - [Pull requests](#pull-requests)
    - [Chat with Us (IRC/Matrix)](#chat-with-us-ircmatrix)
  - [License](#license)



  Install with pip:

  ```sh
  pip install ipfshttpclient
  ```



  ```sh

  git clone https://github.com/ipfs/py-ipfs-http-client.git
  cd py-ipfs-http-client


  flit install --pth-file
  ```



  Basic use-case (requires a running instance of IPFS daemon):

  ```py
  >>> import ipfshttpclient
  >>> client = ipfshttpclient.connect()  # Connects to: /dns/localhost/tcp/5001/http
  >>> res = client.add('test.txt')
  >>> res
  {'Hash': 'QmWxS5aNTFEc9XbMX1ASvLET1zrqEaTssqt33rVZQCQb22', 'Name': 'test.txt'}
  >>> client.cat(res['Hash'])
  'fdsafkljdskafjaksdjf\n'
  ```

  *Please note*: You should specify the address for an IPFS *API server*, using the address of a *gateway* (such as the public `ipfs.io` one at `/dns/ipfs.io/tcp/443/https`) will only give you [extremely limited access](https://github.com/ipfs/go-ipfs/blob/master/docs/gateway.md#read-only-api) and may not work at all. If you are only interested in downloading IPFS content through public gateway servers then this library is unlikely of being of much help.

  For real-world scripts you can reuse TCP connections using a context manager or manually closing the session after use:

  ```py
  import ipfshttpclient


  with ipfshttpclient.connect() as client:
  	hash = client.add('test.txt')['Hash']
  	print(client.stat(hash))


  class SomeObject:
  	def __init__(self):
  		self._client = ipfshttpclient.connect(session=True)

  	def do_something(self):
  		hash = self._client.add('test.txt')['Hash']
  		print(self._client.stat(hash))

  	def close(self):  # Call this when your done
  		self._client.close()
  ```

  Administrative functions:

  ```py
  >>> client.id()
  {'Addresses': ['/ip4/127.0.0.1/tcp/4001/ipfs/QmS2C4MjZsv2iP1UDMMLCYqJ4WeJw8n3vXx1VKxW1UbqHS',
                 '/ip6/::1/tcp/4001/ipfs/QmS2C4MjZsv2iP1UDMMLCYqJ4WeJw8n3vXx1VKxW1UbqHS'],
   'AgentVersion': 'go-ipfs/0.4.10',
   'ID': 'QmS2C4MjZsv2iP1UDMMLCYqJ4WeJw8n3vXx1VKxW1UbqHS',
   'ProtocolVersion': 'ipfs/0.1.0',
   'PublicKey': 'CAASpgIwgg ... 3FcjAgMBAAE='}
  ```

  Pass in API options:

  ```py
  >>> client.pin.ls(type='all')
  {'Keys': {'QmNMELyizsfFdNZW3yKTi1SE2pErifwDTXx6vvQBfwcJbU': {'Count': 1,
                                                               'Type': 'indirect'},
            'QmNQ1h6o1xJARvYzwmySPsuv9L5XfzS4WTvJSTAWwYRSd8': {'Count': 1,
                                                               'Type': 'indirect'},
            …
  ```

  Add a directory and match against a filename pattern:

  ```py
  >>> client.add('photos', pattern='*.jpg')
  [{'Hash': 'QmcqBstfu5AWpXUqbucwimmWdJbu89qqYmE3WXVktvaXhX',
    'Name': 'photos/photo1.jpg'},
   {'Hash': 'QmSbmgg7kYwkSNzGLvWELnw1KthvTAMszN5TNg3XQ799Fu',
    'Name': 'photos/photo2.jpg'},
   {'Hash': 'Qma6K85PJ8dN3qWjxgsDNaMjWjTNy8ygUWXH2kfoq9bVxH',
    'Name': 'photos/photo3.jpg'}]
  ```

  Or add a directory recursively:

  ```py
  >>> client.add('fake_dir', recursive=True)
  [{'Hash': 'QmQcCtMgLVwvMQGu6mvsRYLjwqrZJcYtH4mboM9urWW9vX',
    'Name': 'fake_dir/fsdfgh'},
   {'Hash': 'QmNuvmuFeeWWpxjCQwLkHshr8iqhGLWXFzSGzafBeawTTZ',
    'Name': 'fake_dir/test2/llllg'},
   {'Hash': 'QmX1dd5DtkgoiYRKaPQPTCtXArUu4jEZ62rJBUcd5WhxAZ',
    'Name': 'fake_dir/test2'},
   {'Hash': 'Qmenzb5J4fR9c69BbpbBhPTSp2Snjthu2hKPWGPPJUHb9M',
    'Name': 'fake_dir'}]
  ```

  This module also contains some helper functions for adding strings and JSON to IPFS:

  ```py
  >>> lst = [1, 77, 'lol']
  >>> client.add_json(lst)
  'QmQ4R5cCUYBWiJpNL7mFe4LDrwD6qBr5Re17BoRAY9VNpd'
  >>> client.get_json(_)
  [1, 77, 'lol']
  ```

  Use an IPFS server with basic auth (replace username and password with real creds):

  ```py
  >>> import ipfshttpclient
  >>> client = ipfshttpclient.connect('/dns/ipfs-api.example.com/tcp/443/https', auth=("username", "password"))
  ```

  Pass custom headers to the IPFS daemon with each request:
  ```py
  >>> import ipfshttpclient
  >>> headers = {"CustomHeader": "foobar"}
  >>> client = ipfshttpclient.connect('/dns/ipfs-api.example.com/tcp/443/https', headers=headers)
  ```

  Connect to the IPFS daemon using a Unix domain socket (plain HTTP only):
  ```py
  >>> import ipfshttpclient
  >>> client = ipfshttpclient.connect("/unix/run/ipfs/ipfs.sock")
  ```





  Documentation (currently mostly API documentation unfortunately) is available on IPFS:

  https://ipfs.io/ipns/12D3KooWEqnTdgqHnkkwarSrJjeMP2ZJiADWLYADaNvUb6SQNyPF/docs/

  The `ipfs` [command-line Client documentation](https://ipfs.io/docs/commands/) may also be useful in some cases.



  Please see the CHANGELOG for [the minor breaking changes between these releases](CHANGELOG.md#py-ipfs-http-client-060-30062020).



  Projects that currently use py-ipfs-http-client. If your project isn't here, feel free to submit a PR to add it!

  - [InterPlanetary Wayback](https://github.com/oduwsdl/ipwb) interfaces web archive ([WARC](https://www.iso.org/standard/44717.html)) files for distributed indexing and replay using IPFS.





  Over time many smaller day-to-day tasks have piled up (mostly supporting some
  newer APIs). If want to help out without getting too involved picking up one
  of tasks of our [help wanted issue list](https://github.com/ipfs-shipyard/py-ipfs-http-client/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22)
  would go a long way towards making this library more feature-complete. 👍



  You can submit bug reports using the
  [GitHub issue tracker](https://github.com/ipfs/py-ipfs-http-client/issues).



  Pull requests are welcome.  Before submitting a new pull request, please
  make sure that your code passes both the
  [code formatting](https://www.python.org/dev/peps/pep-0008/)
  (PEP-8 with tab indentation) and
  [typing](https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html)
  (PEP-484 using mypy) checks:

      $ tox -e styleck -e typeck

  As well as the unit tests:

      $ tox -e py3 -e py3-httpx

  If you are unsure, don't hasitate to just submit your code and a human will
  take a look. 🙂

  If you can, Please make sure to include new unit tests for new features or
  changes in behavior. We aim to bring coverage to 100% at some point.



  You can arrange for the code style and typing tests to be run automatically
  before each commit by installing the GIT `pre-commit` hook:

      $ ./tools/pre-commit --install



  You can find us on [#py-ipfs on chat.freenode.org](http://webchat.freenode.net/?channels=%23py-ipfs)
  or in our [Matrix chat room](https://matrix.to/#/#py-ipfs:ninetailed.ninja?via=ninetailed.ninja&via=librem.one).
  Join us if you have any suggestions, questions or if you just want to discuss
  IPFS and Python in general.

  Please note that the channel is not monitored all the time and hence you may
  only receive a reply to your message later that day. Using Matrix makes it
  easier to stay connected in the background, so please prefer the Matrix option
  or use an IRC bouncer.



  This code is distributed under the terms of the [MIT license](https://opensource.org/licenses/MIT).  Details can be found in the file
  [LICENSE](LICENSE) in this repository.


