# packages

pkgId: b681760839ce4204e00920b2fe253bdc4f3e2194461efef55f672a1c2030a0cc
name: python-flask-babel
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Adds i18n/l10n support fo Flask applications.
url: https://pypi.org/project/flask-babel/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-923a76e3-2f07-4795-aac6-f87ae7cdff09
location_href: 00003647-python-flask-babel/python-flask-babel-3.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/python-babel/flask-babel/workflows/Tests/badge.svg?branch=master)
  [![PyPI](https://img.shields.io/pypi/v/flask-babel.svg?maxAge=2592000)](https://pypi.python.org/pypi/Flask-Babel)

  Implements i18n and l10n support for Flask. This is based on the Python
  [babel][] and [pytz][] modules.



  The latest documentation is available [here][docs].

  [babel]: https://github.com/python-babel/babel
  [pytz]: https://pypi.python.org/pypi/pytz/
  [docs]: https://python-babel.github.io/flask-babel/
  [semver]: https://semver.org/


pkgId: 66bb484164677de987bbf5921bf1c3f7b38828eb3f6df26936f51eeb0a6a5f8e
name: python-flask-healthz
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A simple module to allow you to easily add health endpoints to your Flask application
url: https://github.com/fedora-infra/flask-healthz
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-75e056b0-0cfe-470a-9b34-8f8cefa8798a
location_href: 00003654-python-flask-healthz/python-flask-healthz-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Define endpoints in your Flask application that Kubernetes can use as
  [liveness and readiness probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/).






  Register the blueprint on your Flask application:

  ```python
  from flask import Flask
  from flask_healthz import healthz

  app = Flask(__name__)
  app.register_blueprint(healthz, url_prefix="/healthz")
  ```

  Define the functions you want to use to check health. To signal an error, raise `flask_healthz.HealthError`.

  ```python
  from flask_healthz import HealthError

  def liveness():
      pass

  def readiness():
      try:
          connect_database()
      except Exception:
          raise HealthError("Can't connect to the database")
  ```

  Now point to those functions in the Flask configuration:

  ```python
  HEALTHZ = {
      "live": "yourapp.checks.liveness",
      "ready": "yourapp.checks.readiness",
  }
  ```

  It is possible to directly set callables in the configuration, so you could write something like:

  ```python
  HEALTHZ = {
      "live": lambda: None,
  }
  ```

  Check that the endpoints actually work:

  ```
  $ curl http://localhost/yourapp/healthz/live
  {"status": 200, "title": "OK"}
  $ curl http://localhost/yourapp/healthz/ready
  {"status": 200, "title": "OK"}
  ```

  Now your can configure Kubernetes or OpenShift to check for those endpoints.



  You can also use the provided Flask extension to register the `healthz` blueprint:

  ```python
  from flask import Flask
  from flask_healthz import Healthz

  app = Flask(__name__)
  Healthz(app)
  ```

  The rest of the configuration is identical.

  The extension has an additional option, `no_log`, that can disable logging of the HTTP requests
  handled by your healthz endpoints, to avoid cluttering your web log files with automated requests.
  At the moment, only the [gunicorn](https://gunicorn.org/) web server is supported.

  ```python
  Healthz(app, no_log=True)
  ```



  Here's an example of how you could use flask-healthz in OpenShift's `deploymentconfig`:

  ```yaml
  kind: DeploymentConfig
  spec:
    [...]
    template:
      [...]
      spec:
        containers:
        - name: yourapp
          [...]
          livenessProbe:
            httpGet:
              path: /healthz/live
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 1
          readinessProbe:
            httpGet:
              path: /healthz/ready
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 1
  ```

  Some projects that have setup flask-healthz:

  - Noggin: https://github.com/fedora-infra/noggin/pull/287
  - FASJSON: https://github.com/fedora-infra/fasjson/pull/81




  Copyright 2020-2021 Red Hat

  Flask-Healthz is licensed under the same license as Flask itself: BSD 3-clause.


  [![codecov](https://codecov.io/gh/fedora-infra/flask-healthz/branch/dev/graph/badge.svg?token=lwlZLiSImq)](https://codecov.io/gh/fedora-infra/flask-healthz)


pkgId: b4f7a9fecf66f2e3f873f1cb09cb535b08867adbd4de116c200efb0fb357853e
name: python-flask-marshmallow
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Flask + marshmallow for beautiful APIs
url: https://github.com/marshmallow-code/flask-marshmallow
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b51bedf3-00e8-4991-b142-ce347d251cda
location_href: 00010104-python-flask-marshmallow/python-flask-marshmallow-0.15.0-1.src.rpm
checksum_type: sha256
description:
  Flask-Marshmallow is a thin integration layer for `Flask`_ (a Python web framework) and `marshmallow`_ (an object serialization/deserialization library) that adds additional features to marshmallow, including URL and Hyperlinks fields for HATEOAS-ready APIs. It also (optionally) integrates with `Flask-SQLAlchemy <http://flask-sqlalchemy.pocoo.org/>`_.


pkgId: f8deaa2bd4fb81c16bff8bc7050ca5267cefde5ed3d46ecc484f78bfefe521ae
name: python-flask-mongoengine
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/mongoengine/flask-mongoengine
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2cbacc0c-58e3-4781-8721-08631fda1fba
location_href: 00011945-python-flask-mongoengine/python-flask-mongoengine-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Flask-MongoEngine is a Flask extension that provides integration with MongoEngine and WTF model forms.

description:
  A Flask extension that provides integration with `MongoEngine <http://mongoengine.org/>`_.
  For more information on MongoEngine please check out the `MongoEngine Documentation <http://docs.mongoengine.org/>`_.
  It handles connection management for your app.
  You can also use `WTForms <http://wtforms.simplecodes.com/>`_ as model forms for your models.


pkgId: 915210f22dfbae526223d84fc39aabcc1fc573e4df45fd7b31fc16d4984980b4
name: python-flask-ngrok
arch: src
version: 0.0.25
epoch: 0
release: 1
summary: A simple way to demo Flask apps from your machine.
url: https://github.com/gstaff/flask-ngrok
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-798aabc3-d575-4d8c-a1ff-9e0e36819685
location_href: 00012711-python-flask-ngrok/python-flask-ngrok-0.0.25-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/flask-ngrok.svg)](https://badge.fury.io/py/flask-ngrok)

  A simple way to demo Flask apps from your machine.
  Makes your [Flask](http://flask.pocoo.org/) apps running on localhost available
   over the internet via the excellent [ngrok](https://ngrok.com/) tool.


  Python 3.6+ is required.



  ```bash
  pip install flask-ngrok
  ```

  Notebooks have [an issue](https://stackoverflow.com/questions/51180917/python-flask-unsupportedoperation-not-writable) with newer versions of Flask, so force an older version if working in these environments.
  ```bash
  !pip install flask==0.12.2
  ```


  1. Import with ```from flask_ngrok import run_with_ngrok```
  2. Add `run_with_ngrok(app)` to make your Flask app available upon running
  ```python

  from flask import Flask
  from flask_ngrok import run_with_ngrok

  app = Flask(__name__)
  run_with_ngrok(app)  # Start ngrok when app is run

  @app.route("/")
  def hello():
      return "Hello World!"

  if __name__ == '__main__':
      app.run()
  ```
  Running the example:
  ```bash
  python flask_ngrok_example.py
   * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
   * Running on http://<random-address>.ngrok.io
   * Traffic stats available on http://127.0.0.1:4040
  ```


pkgId: 7689c7a491b16026207b1a2b198bf2a58bb0a9722be0de76cb962657ca027587
name: python-flask-oidc
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: OpenID Connect extension for Flask
url: https://github.com/puiterwijk/flask-oidc
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fb45b5a0-2de4-4ed6-9e20-6f9d2635dc84
location_href: 00003663-python-flask-oidc/python-flask-oidc-1.4.0-1.src.rpm
checksum_type: sha256
description:
  `OpenID Connect <https://openid.net/connect/>`_ support for `Flask <http://flask.pocoo.org/>`_.
  This library should work with any standards compliant OpenID Connect provider.
  It has been tested with:
  * `Google+ Login <https://developers.google.com/accounts/docs/OAuth2Login>`_
  * `Ipsilon <https://ipsilon-project.org/>`_


pkgId: c64810421279bf8d4ea338657b0353e60c414fbd6194419006b9a17ff4335ab1
name: python-flask-shell-ipython
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Replace default `flask shell` command by similar command running IPython.
url: http://github.com/ei-grad/flask-shell-ipython
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a3fbd49-ec2e-4784-aa1c-c5da5f5c60ad
location_href: 00012168-python-flask-shell-ipython/python-flask-shell-ipython-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Replace default `flask shell` command by similar command running IPython.



  Just install:

      pip install flask-shell-ipython

  And here are you go:

      > flask shell
      Python 3.5.1 (default, Mar  3 2016, 09:29:07)
      [GCC 5.3.0] on linux
      IPython: 5.0.0
      App: discharges [debug]
      Instance: /home/ei-grad/repos/discharges/instance

      In [1]:


pkgId: f8e9cb7da7ad0bb02b4ae2617a1518b11021c86bb8c030b09ac257228b5a0826
name: python-flask-swagger
arch: src
version: 0.2.14
epoch: 0
release: 1
summary: Extract swagger specs from your flask project
url: https://github.com/gangverk/flask-swagger
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-81e02125-027e-4b9d-b115-ae1eb5226a93
location_href: 00009474-python-flask-swagger/python-flask-swagger-0.2.14-1.src.rpm
checksum_type: sha256
description:
  A Swagger 2.0 spec extractor for Flask
  Install:
      pip install flask-swagger
  Flask-swagger provides a method (swagger) that inspects the Flask app
  for endpoints that contain YAML docstrings with Swagger 2.0
  `Operation <https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#operation-object>`__
  objects.
      class UserAPI(MethodView):
          def post(self):
              """


pkgId: 2044c9de37c510e6978b7076c564d7ee27fb1b5ff3473ddc43aef336bb86fc3c
name: python-flask-swagger-ui
arch: src
version: 4.11.1
epoch: 0
release: 1
summary: Swagger UI blueprint for Flask
url: https://github.com/sveint/flask-swagger-ui
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d10addb-52d8-4e52-abb3-9b25e123ee25
location_href: 00011623-python-flask-swagger-ui/python-flask-swagger-ui-4.11.1-1.src.rpm
checksum_type: sha256
description:
  Simple Flask blueprint for adding [Swagger UI](https://github.com/swagger-api/swagger-ui) to your flask application.

  Included Swagger UI version: 4.11.1.



  `pip install flask-swagger-ui`



  Example application:

  ```python
  from flask import Flask
  from flask_swagger_ui import get_swaggerui_blueprint

  app = Flask(__name__)


  SWAGGER_URL = '/api/docs'  # URL for exposing Swagger UI (without trailing '/')
  API_URL = 'http://petstore.swagger.io/v2/swagger.json'  # Our API url (can of course be a local resource)


  swaggerui_blueprint = get_swaggerui_blueprint(
      SWAGGER_URL,  # Swagger UI static files will be mapped to '{SWAGGER_URL}/dist/'
      API_URL,
      config={  # Swagger UI config overrides
          'app_name': "Test application"
      },
      
      
      
      
      
      
      
      
  )

  app.register_blueprint(swaggerui_blueprint)

  app.run()



  ```



  The blueprint supports overloading all Swagger UI configuration options that can be JSON serialized.
  See https://github.com/swagger-api/swagger-ui#parameters for options.

  Plugins and function parameters are not supported at this time.

  OAuth2 parameters can be found at https://github.com/swagger-api/swagger-ui#oauth2-configuration .


pkgId: ec7aa1c06f1a5778bfb1d09d6e528a708556eeeef95c9c964a8cd9a9040b4b46
name: python-flask-talisman
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: HTTP security headers for Flask.
url: https://github.com/wntrblm/flask-talisman
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ca11419-1afc-4b28-bed5-c902f7523dcb
location_href: 00010247-python-flask-talisman/python-flask-talisman-1.0.0-1.src.rpm
checksum_type: sha256
description:
  |PyPI Version|
  Talisman is a small Flask extension that handles setting HTTP headers
  that can help protect against a few common web application security
  issues.
  The default configuration:
  -  Forces all connects to ``https``, unless running with debug enabled.
  -  Enables `HTTP Strict Transport
     Security <https://developer.mozilla.org/en-US/docs/Web/Security/HTTP_strict_transport_security>`_.
  -  Sets Flask's session cookie to ``secure``, so it will never be set if
     your application is somehow accessed via a non-secure connection.
  -  Sets Flask's session cookie to ``httponly``, preventing JavaScript
     from being able to access its content. CSRF via Ajax uses a separate
     cookie and should be unaffected.
  -  Sets Flask's session cookie to ``Lax``, preventing the cookie to be leaked
     in CSRF-prone request methods.
  -  Sets
     `X-Frame-Options <https://developer.mozilla.org/en-US/docs/Web/HTTP/X-Frame-Options>`_
     to ``SAMEORIGIN`` to avoid
     `clickjacking <https://en.wikipedia.org/wiki/Clickjacking>`_.
  -  Sets `X-XSS-Protection
     <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-XSS-Protection>`_
     to enable a cross site scripting filter for IE and Safari (note Chrome has
     removed this and Firefox never supported it).
  -  Sets `X-Content-Type-Options
     <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options>`_
     to prevent content type sniffing.
  -  Sets a strict `Content Security
     Policy <https://developer.mozilla.org/en-US/docs/Web/Security/CSP/Introducing_Content_Security_Policy>`__
     of ``default-src: 'self', 'object-src': 'none'``. This is intended to almost completely
     prevent Cross Site Scripting (XSS) attacks. This is probably the only
     setting that you should reasonably change. See the
     `Content Security Policy`_ section.
  -  Sets a strict `Referrer-Policy <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy>`_
     of ``strict-origin-when-cross-origin`` that governs which referrer information should be included with
     requests made.
  In addition to Talisman, you **should always use a cross-site request
  forgery (CSRF) library**. It's highly recommended to use
  `Flask-SeaSurf <https://flask-seasurf.readthedocs.org/en/latest/>`_,
  which is based on Django's excellent library.


pkgId: f702b26e8a0211db4a9375187506ee3ce2a099b7120d781d7634d84f3d1ff731
name: python-flask-whooshee
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: Flask-SQLAlchemy - Whoosh Integration
url: https://github.com/bkabrda/flask-whooshee
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e7b394c3-4b35-45f0-b3b2-040db96d0a86
location_href: 00003676-python-flask-whooshee/python-flask-whooshee-0.8.2-1.src.rpm
checksum_type: sha256
description:
  Adds Whoosh integration to Flask-SQLAlchemy.
  Setup
  `````
  Flask-Whooshee supports two different methods of setting up the extension.
  You can either initialize it directly, thus binding it to a specific
  application instance:
      app = Flask(__name__)
      whooshee = Whooshee(app)
  and the second is to use the factory pattern which will allow you to
  configure whooshee at a later point:
      whooshee = Whooshee()
      def create_app():
          app = Flask(__name__)
          whooshee.init_app(app)
          return app
  Now you can create a basic whoosheer:
      @whooshee.register_model('title', 'content')
      class Entry(db.Model):
          id = db.Column(db.Integer, primary_key=True)
          title = db.Column(db.String)
          content = db.Column(db.Text)
  and finally you can search the model:
      Entry.query.whooshee_search('chuck norris').order_by(Entry.id.desc()).all()
  Links
  `````
  * `Documentation <https://flask-whooshee.readthedocs.io>`_
  * `Source Code <https://github.com/bkabrda/flask-whooshee>`_
  * `Issues <https://github.com/bkabrda/flask-whooshee/issues>`_


pkgId: b9641984c2490a4aeb39ad56c7710bd51cba50b435daa237b85fbeb730be64c5
name: python-flatbuffers
arch: src
version: 23.3.3
epoch: 0
release: 1
summary: The FlatBuffers serialization format for Python
url: https://google.github.io/flatbuffers/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe1f4556-ae4c-48cf-8459-d6d06e86de2d
location_href: 00009082-python-flatbuffers/python-flatbuffers-23.3.3-1.src.rpm
checksum_type: sha256
description:
  Python runtime library for use with the `Flatbuffers <https://google.github.io/flatbuffers/>`_ serialization format.


pkgId: d2e26f629e2b007d60be08adba2d4e7c9040d38814e4668e9c9d3e2f319194fe
name: python-flatdict
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Python module for interacting with nested dicts as a single level dict with delimited keys.
url: https://github.com/gmr/flatdict
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f58108ca-3d06-42d8-b569-536591f66a35
location_href: 00010797-python-flatdict/python-flatdict-4.0.1-1.src.rpm
checksum_type: sha256
description:
  |Version| |Status| |Coverage| |License|
  ``FlatDict`` and ``FlatterDict`` are a dict classes that allows for single level,
  delimited key/value pair mapping of nested dictionaries. You can interact with
  ``FlatDict`` and ``FlatterDict`` like a normal dictionary and access child
  dictionaries as you normally would or with the composite key.
  *For example:*
      value = flatdict.FlatDict({'foo': {'bar': 'baz', 'qux': 'corge'}})
  *would be the same as:*
      value == {'foo:bar': 'baz', 'foo:qux': 'corge'}
  *values can be accessed as:*
      print(foo['foo:bar'])
      
      print(foo['foo']['bar'])
  Additionally, lists and tuples are also converted into dicts using ``enumerate()``,
  using the ``FlatterDict`` class.
  *For example:*
      value = flatdict.FlatterDict({'list': ['a', 'b', 'c']})
  *will be the same as:*
      value == {'list:0': 'a', 'list:1': 'b', 'list:2': 'c'}


pkgId: 9250fe37eca699aa347b7b07d794181bd3cd3edf7672095d9b401885c11ef3b2
name: python-flax
arch: src
version: 0.6.8
epoch: 0
release: 1
summary: Flax: A neural network library for JAX designed for flexibility
url: https://github.com/google/flax
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cbb969a0-190a-4ee7-8b28-93388d0dc729
location_href: 00009150-python-flax/python-flax-0.6.8-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://raw.githubusercontent.com/google/flax/main/images/flax_logo_250px.png" alt="logo"></img>
  </div>



  ![Build](https://github.com/google/flax/workflows/Build/badge.svg?branch=main) [![coverage](https://badgen.net/codecov/c/github/google/flax)](https://codecov.io/github/google/flax)


  [**Overview**](#overview)
  | [**Quick install**](#quick-install)
  | [**What does Flax look like?**](#what-does-flax-look-like)
  | [**Documentation**](https://flax.readthedocs.io/)

  This README is a very short intro. **To learn everything you need to know about Flax, refer to our [full documentation](https://flax.readthedocs.io/).**

  Flax was originally started by engineers and researchers within the Brain Team in Google Research (in close collaboration with the JAX team), and is now developed jointly with the open source community.

  Flax is being used by a growing
  community of hundreds of folks in various Alphabet research departments
  for their daily work, as well as a [growing community
  of open source
  projects](https://github.com/google/flax/network/dependents?dependent_type=REPOSITORY).

  The Flax team's mission is to serve the growing JAX neural network
  research ecosystem -- both within Alphabet and with the broader community,
  and to explore the use-cases where JAX shines. We use GitHub for almost
  all of our coordination and planning, as well as where we discuss
  upcoming design changes. We welcome feedback on any of our discussion,
  issue and pull request threads. We are in the process of moving some
  remaining internal design docs and conversation threads to GitHub
  discussions, issues and pull requests. We hope to increasingly engage
  with the needs and clarifications of the broader ecosystem. Please let
  us know how we can help!

  Please report any feature requests,
  issues, questions or concerns in our [discussion
  forum](https://github.com/google/flax/discussions), or just let us
  know what you're working on!

  We expect to improve Flax, but we don't anticipate significant
  breaking changes to the core API. We use [Changelog](https://github.com/google/flax/tree/main/CHANGELOG.md)
  entries and deprecation warnings when possible.

  In case you want to reach us directly, we're at flax-dev@google.com.



  Flax is a high-performance neural network library and ecosystem for
  JAX that is **designed for flexibility**:
  Try new forms of training by forking an example and by modifying the training
  loop, not by adding features to a framework.

  Flax is being developed in close collaboration with the JAX team and
  comes with everything you need to start your research, including:

  * **Neural network API** (`flax.linen`): Dense, Conv, {Batch|Layer|Group} Norm, Attention, Pooling, {LSTM|GRU} Cell, Dropout

  * **Utilities and patterns**: replicated training, serialization and checkpointing, metrics, prefetching on device

  * **Educational examples** that work out of the box: MNIST, LSTM seq2seq, Graph Neural Networks, Sequence Tagging

  * **Fast, tuned large-scale end-to-end examples**: CIFAR10, ResNet on ImageNet, Transformer LM1b



  You will need Python 3.6 or later, and a working [JAX](https://github.com/google/jax/blob/main/README.md)
  installation (with or without GPU support - refer to [the instructions](https://github.com/google/jax/blob/main/README.md)).
  For a CPU-only version of JAX:

  ```
  pip install --upgrade pip # To support manylinux2010 wheels.
  pip install --upgrade jax jaxlib # CPU-only
  ```

  Then, install Flax from PyPi:

  ```
  pip install flax
  ```

  To upgrade to the latest version of Flax, you can use:

  ```
  pip install --upgrade git+https://github.com/google/flax.git
  ```
  To install some additional dependencies (like `matplotlib`) that are required but not included
  by some dependencies, you can use:

  ```bash
  pip install flax[all]
  ```



  We provide three examples using the Flax API: a simple multi-layer perceptron, a CNN and an auto-encoder.

  To learn more about the `Module` abstraction, check out our [docs](https://flax.readthedocs.io/), our [broad intro to the Module abstraction](https://github.com/google/flax/blob/main/docs/notebooks/linen_intro.ipynb). For additional concrete demonstrations of best practices, refer to our
  [guides](https://flax.readthedocs.io/en/latest/guides/index.html) and
  [developer notes](https://flax.readthedocs.io/en/latest/developer_notes/index.html).

  ```py
  from typing import Sequence

  import numpy as np
  import jax
  import jax.numpy as jnp
  import flax.linen as nn

  class MLP(nn.Module):
    features: Sequence[int]

    @nn.compact
    def __call__(self, x):
      for feat in self.features[:-1]:
        x = nn.relu(nn.Dense(feat)(x))
      x = nn.Dense(self.features[-1])(x)
      return x

  model = MLP([12, 8, 4])
  batch = jnp.ones((32, 10))
  variables = model.init(jax.random.PRNGKey(0), batch)
  output = model.apply(variables, batch)
  ```

  ```py
  class CNN(nn.Module):
    @nn.compact
    def __call__(self, x):
      x = nn.Conv(features=32, kernel_size=(3, 3))(x)
      x = nn.relu(x)
      x = nn.avg_pool(x, window_shape=(2, 2), strides=(2, 2))
      x = nn.Conv(features=64, kernel_size=(3, 3))(x)
      x = nn.relu(x)
      x = nn.avg_pool(x, window_shape=(2, 2), strides=(2, 2))
      x = x.reshape((x.shape[0], -1))  # flatten
      x = nn.Dense(features=256)(x)
      x = nn.relu(x)
      x = nn.Dense(features=10)(x)
      x = nn.log_softmax(x)
      return x

  model = CNN()
  batch = jnp.ones((32, 64, 64, 10))  # (N, H, W, C) format
  variables = model.init(jax.random.PRNGKey(0), batch)
  output = model.apply(variables, batch)
  ```

  ```py
  class AutoEncoder(nn.Module):
    encoder_widths: Sequence[int]
    decoder_widths: Sequence[int]
    input_shape: Sequence[int]

    def setup(self):
      input_dim = np.prod(self.input_shape)
      self.encoder = MLP(self.encoder_widths)
      self.decoder = MLP(self.decoder_widths + (input_dim,))

    def __call__(self, x):
      return self.decode(self.encode(x))

    def encode(self, x):
      assert x.shape[1:] == self.input_shape
      return self.encoder(jnp.reshape(x, (x.shape[0], -1)))

    def decode(self, z):
      z = self.decoder(z)
      x = nn.sigmoid(z)
      x = jnp.reshape(x, (x.shape[0],) + self.input_shape)
      return x

  model = AutoEncoder(encoder_widths=[20, 10, 5],
                      decoder_widths=[5, 10, 20],
                      input_shape=(12,))
  batch = jnp.ones((16, 12))
  variables = model.init(jax.random.PRNGKey(0), batch)
  encoded = model.apply(variables, batch, method=model.encode)
  decoded = model.apply(variables, encoded, method=model.decode)
  ```



  In-detail examples to train and evaluate a variety of Flax models for
  Natural Language Processing, Computer Vision, and Speech Recognition are
  actively maintained in the [🤗 Transformers repository](https://github.com/huggingface/transformers/tree/master/examples/flax).

  As of October 2021, the [19 most-used Transformer architectures](https://huggingface.co/transformers/#supported-frameworks) are supported in Flax
  and over 5000 pretrained checkpoints in Flax have been uploaded to the [🤗 Hub](https://huggingface.co/models?library=jax&sort=downloads).



  To cite this repository:

  ```
  @software{flax2020github,
    author = {Jonathan Heek and Anselm Levskaya and Avital Oliver and Marvin Ritter and Bertrand Rondepierre and Andreas Steiner and Marc van {Z}ee},
    title = {{F}lax: A neural network library and ecosystem for {JAX}},
    url = {http://github.com/google/flax},
    version = {0.6.8},
    year = {2023},
  }
  ```

  In the above bibtex entry, names are in alphabetical order, the version number
  is intended to be that from [flax/version.py](https://github.com/google/flax/blob/main/flax/version.py), and the year corresponds to the project's open-source release.



  Flax is an open source project maintained by a dedicated team in Google Research, but is not an official Google product.


pkgId: a11374dd4b94484f59d03939df944fbc2ee26c1851fee01f06f2f7d2b6130d6c
name: python-flex
arch: src
version: 6.14.1
epoch: 0
release: 1
summary: Swagger Schema validation.
url: https://github.com/pipermerriam/flex
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b9ac1dc3-8908-4cc2-9d96-32d8f6137077
location_href: 00011318-python-flex/python-flex-6.14.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://badgen.net/travis/pipermerriam/flex)](https://travis-ci.org/pipermerriam/flex)
  [![Documentation Status](https://readthedocs.org/projects/flex-swagger/badge/?version=latest)](https://readthedocs.org/projects/flex-swagger/?badge=latest)
  [![PyPi version](https://badgen.net/pypi/v/flex)](https://pypi.org/project/flex/)
  [![PyPi downloads](https://img.shields.io/pypi/dm/flex.svg)](https://pypi.python.org/pypi/flex)


  Validation tooling for [Swagger 2.0](https://github.com/wordnik/swagger-spec/blob/master/versions/2.0.md) specifications.


  [Documentation on ReadTheDocs](http://flex-swagger.readthedocs.org/en/latest/)



  * Validate swagger schemas.
  * JSON Schema Validation
  * Validation of request/response objects against schema.
  * Command Line interface.




  Starting in version 5.0.0 the CLI interface has been changed to `swagger-flex`
  due to a collision with the Apache Flex project.


pkgId: eb172bd79fb21b21477078ade977d51e18f500cf844bf78f9bdde5af06429035
name: python-flexmock
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: flexmock is a testing library for Python that makes it easy to create mocks, stubs and fakes.
url: https://github.com/flexmock/flexmock
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-44965196-cfc5-4aeb-9c38-177ed804f2d6
location_href: 00003681-python-flexmock/python-flexmock-0.11.3-1.src.rpm
checksum_type: sha256
description:
  Flexmock is a testing library for Python that makes it easy to create mocks, stubs, and fakes.

  - **Mock**: Easily create mock objects and make assertions about which methods or attributes were used and arguments they were called with.
  - **Spy**: Proxy calls to object's original methods or attributes and make assertions based on return values or call count.
  - **Fake**: Generate a fake objects to be used in your tests with ease.
  - **Stub**: Create stub objects which replace parts of existing objects and classes with just one call.
  - **No external dependencies**: Flexmock is lightweight and only uses Python standard library. There are no external dependencies.
  - **Simple and intuitive**: Declarations are structured to read more like English sentences than API calls, so they are easy to learn and use.
  - **Fully type annotated**: External API is fully type annotated so it works great with static analysis tools and editor auto-completion.
  - **Integrations with test runners**: Integrates seamlessly with all major test runners like unittest, doctest, and pytest.
  - **Python 3.6+ and PyPy3**: Extensively tested to work with latest Python versions.

  Install with pip:
  ```
  pip install flexmock
  ```

  Flexmock features smooth integration with pretty much every popular test runner, so no special setup is necessary. Simply importing flexmock into your test module is sufficient to get started with any of the following examples:
  ```python
  from flexmock import flexmock
  ```

  Assertions take many flavors and flexmock has many different facilities to generate them:
  ```python

  flexmock(Train).should_receive("get_tickets").once()

  flexmock(Train).should_receive("get_destination").and_return("Paris").once()

  flexmock(Train).should_receive("set_destination").with_args("Seoul").at_least().twice()
  ```

  Instead of mocking, there are also times when you want to execute the actual method and simply find out how many times it was called. Flexmock uses `should_call` to generate this sort of assertions instead of `should_receive`:
  ```python

  flexmock(Train).should_call("get_tickets").at_most().times(3)

  flexmock(Train).should_call("set_destination").with_args("Helsinki").never()

  flexmock(Train).should_call("crash").with_args(str, int).and_raise(AttributeError).once()
  ```
  See more examples in the documentation.

  User guide, examples, and a full API reference is available at: https://flexmock.readthedocs.io

  Contributions are absolutely welcome and encouraged! See [CONTRIBUTING.md](https://github.com/flexmock/flexmock/blob/master/CONTRIBUTING.md) to get started.


pkgId: c610eef76d350161a2147cf9330b264078d60449bbc80a3c1a4e55d81b6acb73
name: python-flock
arch: src
version: 0.1
epoch: 0
release: 1
url: https://github.com/misli/python-flock
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4417bd75-ef2a-4013-8d49-beb5cac40f95
location_href: 00003683-python-flock/python-flock-0.1-1.src.rpm
checksum_type: sha256
summary:
  Flock object uses fcntl.flock to lock (resp. unlock) file descriptor (fd) with operation (op) when entering (resp. leaving) runtime context related to it.


pkgId: 7c5c0c250a86fd9f7ec5b9ce3bd1554fafda9950c744302b73b6f604b842078f
name: python-fluent-logger
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: A Python logging handler for Fluentd event collector
url: https://github.com/fluent/fluent-logger-python
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ff730d2f-c43d-4223-ac05-509e4137bfd5
location_href: 00010299-python-fluent-logger/python-fluent-logger-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Many web/mobile applications generate huge amount of event logs (c,f.
  login, logout, purchase, follow, etc). To analyze these event logs could
  be really valuable for improving the service. However, the challenge is
  collecting these logs easily and reliably.
  `Fluentd <https://github.com/fluent/fluentd>`__ solves that problem by
  having: easy installation, small footprint, plugins, reliable buffering,
  log forwarding, etc.
  **fluent-logger-python** is a Python library, to record the events from
  Python application.


pkgId: bb27567558d42e23ea05f9666cfc13f02c64268faa101e0e8e928011e7c95f2a
name: python-fnvhash
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Pure Python FNV hash implementation
url: https://github.com/znerol/py-fnvhash
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7dd56c13-483e-4aa1-801d-3cc86696fc33
location_href: 00012356-python-fnvhash/python-fnvhash-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Pure Python implementation of the FNV_ hash family with 100% test coverage.
  Take a look at pyhash_ for use cases where performance is more important than
  portability.


pkgId: 806c2a249592eaf50ac1ba956dd3498a5ba84cd916cea7dceceb107695d9760a
name: python-folium
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Make beautiful maps with Leaflet.js & Python
url: https://github.com/python-visualization/folium
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72776cf4-1952-41b6-b8d4-79c58840e92b
location_href: 00009801-python-folium/python-folium-0.14.0-1.src.rpm
checksum_type: sha256
description:
  |folium|
  Python Data, Leaflet.js Maps
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  `folium` builds on the data wrangling strengths of the Python ecosystem and the
  mapping strengths of the Leaflet.js library. Manipulate your data in Python,
  then visualize it in a Leaflet map via `folium`.


pkgId: 89b7a4ffeec422ec46bc26d75ad3eb08db8cb0aec78d17d3c29c7b8efadf38d6
name: python-fontconfig
arch: src
version: 0.1
epoch: 0
release: 1
summary: CFFI bindings for fontconfig
url: https://bitbucket.org/gm/fontconfig
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f0a8cc7-658f-4b55-ab32-edd3b15e1abd
location_href: 00003696-python-fontconfig/python-fontconfig-0.1-1.src.rpm
checksum_type: sha256
description:
  This package requires the `enum34`_ package. Install it via pypi:
     $ pip install enum34
  or use your distribution's package:
     $ apt-get install python-enum34
  To compile the ``_fontconfig`` extension, the following C headers are
  required:
     
     
     
     
  and the package `cffi`_. In Debian the following packages are enough:
     $ apt-get install python-cffi libfontconfig1-dev libfreetype6-dev
  Finally, to install the package itself:
     $ pip install fontconfig


pkgId: 7aab70a30387a760e256acec6a72fe3aea3fbfe53e068a2d18588ca60436a421
name: python-fontdump
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A cli tool to dump the CSS and different formats offonts for Google Fonts
url: https://github.com/glasslion/fontdump
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-64d7baf9-532b-4b38-b1cc-bde4ce931346
location_href: 00003697-python-fontdump/python-fontdump-1.3.0-1.src.rpm
checksum_type: sha256
description:
  A command line tool to dump the CSS and different formats of fonts for
  `Google Fonts <https://www.google.com/fonts>`__, so you can serve them
  on your local servers.
  Usage
  ~~~~~
      $ fontdump -h
      fontdump heps you dump google web fonts.
        __            _      _
       / _|          | |    | |
      | |_ ___  _ __ | |_ __| |_   _ _ __ ___  _ __
      |  _/ _ \| '_ \| __/ _` | | | | '_ ` _ \| '_ \
      | || (_) | | | | || (_| | |_| | | | | | | |_) |
      |_| \___/|_| |_|\__\__,_|\__,_|_| |_| |_| .__/
                                              | |
                                              |_|
      Usage:
        fontdump <google-fonts-url> [--font-dir-path=<path>]
        fontdump (-h | --help)
      Options:
        -h --help                 Show this screen.
        --font-dir-path=<path>    Path to the font dir(ends with /).
                                  e.g('staic/fonts/', 'http://cdn/.../fonts/')
        --output=<dir>            The directory saves the dumped css and font files
  FAQs
  ~~~~
  **Question**: What’s wrong with Google Fonts? Why do I want to serve the
  fonts on my own server?
  **Answer**: Google Fonts is Great. You shall use it normally. But for
  users in some countries, Google Fonts is very slow and sometimes even
  inaccessible. Serving your own fonts is the only choice for them.
  Besides, some developers may wish to have more control over web fonts.
  They might want to embed fonts as base64 strings into the css to bypass
  crazy firewalls. They might to store the fonts as jsons to the
  localstorage to speed up page loading.
  **Question**: Why do I need to install a software to download these
  fonts? Can't I just open the Chrome developer tools and download the css
  and fonts manually?
  **Answer**: Making css font rules compatible with different browsers is
  not easy. Thus Google detects the browser's User Agent string and serve
  the css that is only compatible with the given browser.
  As a web developer/designer, it is very likely that you are using a
  modern browser, so the css you get from Google only works in modern
  browsers. To improve the user experience for old browser users , we need
  to download the 4 differnet formats of fonts and merge the css rules
  into a single stylesheet. A tool can simplify the process.
  **Question**: What would the merged css look like?
  **Answer**:
  like this:
      @font-face {
        font-family: 'WebFont';
        src: url('webfont.eot'); /* IE9 Compat Modes */
        src: local('WebFont'),
             url('webfont.eot?#iefix') format('embedded-opentype'), /* IE6-IE8 */
             url('webfont.woff') format('woff'), /* Modern Browsers */
             url('webfont.ttf')  format('truetype'), /* Safari, Android, iOS */
             url('webfont.svg#svgFontName') format('svg'); /* Legacy iOS */
      }
  Reference:
  ~~~~~~~~~~
  `Using
  @font-face <http://css-tricks.com/snippets/css/using-font-face/>`__
  `Bulletproof @font-face
  Syntax <http://www.paulirish.com/2009/bulletproof-font-face-implementation-syntax/>`__
  `WEBFONT
  GENERATOR <http://www.fontsquirrel.com/tools/webfont-generator>`__
  `Avoiding Faux Weights And Styles With Google Web
  Fonts <http://www.smashingmagazine.com/2012/07/11/avoiding-faux-weights-styles-google-web-fonts/>`__


pkgId: 2df21e0ed65109bd653ae11f006a1db3ef307d40fe25aa3e0853599125c815d8
name: python-fonttools
arch: src
version: 4.39.3
epoch: 0
release: 1
summary: Tools to manipulate font files
url: http://github.com/fonttools/fonttools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7bc1d872-db02-4a1a-b86c-a82163e898df
location_href: 00009192-python-fonttools/python-fonttools-4.39.3-1.src.rpm
checksum_type: sha256
description:
  The ``fontTools`` package currently has no (required) external dependencies
  besides the modules included in the Python Standard Library.
  However, a few extra dependencies are required by some of its modules, which
  are needed to unlock optional features.
  The ``fonttools`` PyPI distribution also supports so-called "extras", i.e. a
  set of keywords that describe a group of additional dependencies, which can be
  used when installing via pip, or when specifying a requirement.
  For example:
      pip install fonttools[ufo,lxml,woff,unicode]
  This command will install fonttools, as well as the optional dependencies that
  are required to unlock the extra features named "ufo", etc.
  - ``Lib/fontTools/misc/etree.py``
    The module exports a ElementTree-like API for reading/writing XML files, and
    allows to use as the backend either the built-in ``xml.etree`` module or
    `lxml <https://lxml.de>`__. The latter is preferred whenever present,
    as it is generally faster and more secure.
    *Extra:* ``lxml``
  - ``Lib/fontTools/ufoLib``
    Package for reading and writing UFO source files; it requires:
    * `fs <https://pypi.org/pypi/fs>`__: (aka ``pyfilesystem2``) filesystem
      abstraction layer.
    * `enum34 <https://pypi.org/pypi/enum34>`__: backport for the built-in ``enum``
      module (only required on Python < 3.4).
    *Extra:* ``ufo``
  - ``Lib/fontTools/ttLib/woff2.py``
    Module to compress/decompress WOFF 2.0 web fonts; it requires:
    * `brotli <https://pypi.python.org/pypi/Brotli>`__: Python bindings of
      the Brotli compression library.
    *Extra:* ``woff``
  - ``Lib/fontTools/ttLib/sfnt.py``
    To better compress WOFF 1.0 web fonts, the following module can be used
    instead of the built-in ``zlib`` library:
    * `zopfli <https://pypi.python.org/pypi/zopfli>`__: Python bindings of
      the Zopfli compression library.
    *Extra:* ``woff``
  - ``Lib/fontTools/unicode.py``
    To display the Unicode character names when dumping the ``cmap`` table
    with ``ttx`` we use the ``unicodedata`` module in the Standard Library.
    The version included in there varies between different Python versions.
    To use the latest available data, you can install:
    * `unicodedata2 <https://pypi.python.org/pypi/unicodedata2>`__:
      ``unicodedata`` backport for Python 3.x updated to the latest Unicode
      version 15.0.
    *Extra:* ``unicode``
  - ``Lib/fontTools/varLib/interpolatable.py``
    Module for finding wrong contour/component order between different masters.
    It requires one of the following packages in order to solve the so-called
    "minimum weight perfect matching problem in bipartite graphs", or
    the Assignment problem:
    * `scipy <https://pypi.python.org/pypi/scipy>`__: the Scientific Library
      for Python, which internally uses `NumPy <https://pypi.python.org/pypi/numpy>`__
      arrays and hence is very fast;
    * `munkres <https://pypi.python.org/pypi/munkres>`__: a pure-Python
      module that implements the Hungarian or Kuhn-Munkres algorithm.
    *Extra:* ``interpolatable``
  - ``Lib/fontTools/varLib/plot.py``
    Module for visualizing DesignSpaceDocument and resulting VariationModel.
    * `matplotlib <https://pypi.org/pypi/matplotlib>`__: 2D plotting library.
    *Extra:* ``plot``
  - ``Lib/fontTools/misc/symfont.py``
    Advanced module for symbolic font statistics analysis; it requires:
    * `sympy <https://pypi.python.org/pypi/sympy>`__: the Python library for
      symbolic mathematics.
    *Extra:* ``symfont``
  - ``Lib/fontTools/t1Lib.py``
    To get the file creator and type of Macintosh PostScript Type 1 fonts
    on Python 3 you need to install the following module, as the old ``MacOS``
    module is no longer included in Mac Python:
    * `xattr <https://pypi.python.org/pypi/xattr>`__: Python wrapper for
      extended filesystem attributes (macOS platform only).
    *Extra:* ``type1``
  - ``Lib/fontTools/ttLib/removeOverlaps.py``
    Simplify TrueType glyphs by merging overlapping contours and components.
    * `skia-pathops <https://pypi.python.org/pypy/skia-pathops>`__: Python
      bindings for the Skia library's PathOps module, performing boolean
      operations on paths (union, intersection, etc.).
    *Extra:* ``pathops``
  - ``Lib/fontTools/pens/cocoaPen.py`` and ``Lib/fontTools/pens/quartzPen.py``
    Pens for drawing glyphs with Cocoa ``NSBezierPath`` or ``CGPath`` require:
    * `PyObjC <https://pypi.python.org/pypi/pyobjc>`__: the bridge between
      Python and the Objective-C runtime (macOS platform only).
  - ``Lib/fontTools/pens/qtPen.py``
    Pen for drawing glyphs with Qt's ``QPainterPath``, requires:
    * `PyQt5 <https://pypi.python.org/pypi/PyQt5>`__: Python bindings for
      the Qt cross platform UI and application toolkit.
  - ``Lib/fontTools/pens/reportLabPen.py``
    Pen to drawing glyphs as PNG images, requires:
    * `reportlab <https://pypi.python.org/pypi/reportlab>`__: Python toolkit
      for generating PDFs and graphics.
  - ``Lib/fontTools/pens/freetypePen.py``
    Pen to drawing glyphs with FreeType as raster images, requires:
    * `freetype-py <https://pypi.python.org/pypi/freetype-py>`__: Python binding
      for the FreeType library.
  - ``Lib/fontTools/ttLib/tables/otBase.py``
    Use the Harfbuzz library to serialize GPOS/GSUB using ``hb_repack`` method, requires:
    * `uharfbuzz <https://pypi.python.org/pypi/uharfbuzz>`__: Streamlined Cython
      bindings for the harfbuzz shaping engine
    *Extra:* ``repacker``
  How to make a new release
  ~~~~~~~~~~~~~~~~~~~~~~~~~
  1) Update ``NEWS.rst`` with all the changes since the last release. Write a
     changelog entry for each PR, with one or two short sentences summarizing it,
     as well as links to the PR and relevant issues addressed by the PR. Do not
     put a new title, the next command will do it for you.
  2) Use semantic versioning to decide whether the new release will be a 'major',
     'minor' or 'patch' release. It's usually one of the latter two, depending on
     whether new backward compatible APIs were added, or simply some bugs were fixed.
  3) Run ``python setup.py release`` command from the tip of the ``main`` branch.
     By default this bumps the third or 'patch' digit only, unless you pass ``--major``
     or ``--minor`` to bump respectively the first or second digit.
     This bumps the package version string, extracts the changes since the latest
     version from ``NEWS.rst``, and uses that text to create an annotated git tag
     (or a signed git tag if you pass the ``--sign`` option and your git and Github
     account are configured for `signing commits <https://docs.github.com/en/github/authenticating-to-github/managing-commit-signature-verification/signing-commits>`__
     using a GPG key).
     It also commits an additional version bump which opens the main branch for
     the subsequent developmental cycle
  4) Push both the tag and commit to the upstream repository, by running the command
     ``git push --follow-tags``. Note: it may push other local tags as well, be
     careful.
  5) Let the CI build the wheel and source distribution packages and verify both
     get uploaded to the Python Package Index (PyPI).
  6) [Optional] Go to fonttools `Github Releases <https://github.com/fonttools/fonttools/releases>`__
     page and create a new release, copy-pasting the content of the git tag
     message. This way, the release notes are nicely formatted as markdown, and
     users watching the repo will get an email notification. One day we shall
     automate that too.
  Acknowledgements
  ~~~~~~~~~~~~~~~~
  In alphabetical order:
  aschmitz, Olivier Berten, Samyak Bhuta, Erik van Blokland, Petr van Blokland,
  Jelle Bosma, Sascha Brawer, Tom Byrer, Antonio Cavedoni, Frédéric
  Coiffier, Vincent Connare, David Corbett, Simon Cozens, Dave Crossland,
  Simon Daniels, Peter Dekkers, Behdad Esfahbod, Behnam Esfahbod, Hannes
  Famira, Sam Fishman, Matt Fontaine, Takaaki Fuji, Yannis Haralambous, Greg
  Hitchcock, Jeremie Hornus, Khaled Hosny, John Hudson, Denis Moyogo Jacquerye,
  Jack Jansen, Tom Kacvinsky, Jens Kutilek, Antoine Leca, Werner Lemberg, Tal
  Leming, Peter Lofting, Cosimo Lupo, Olli Meier, Masaya Nakamura, Dave Opstad,
  Laurence Penney, Roozbeh Pournader, Garret Rieger, Read Roberts, Colin Rofls,
  Guido van Rossum, Just van Rossum, Andreas Seidel, Georg Seifert, Chris
  Simpkins, Miguel Sousa, Adam Twardoch, Adrien Tétar, Vitaly Volkov,
  Paul Wise.
  Copyrights
  ~~~~~~~~~~
  | Copyright (c) 1999-2004 Just van Rossum, LettError
    (just@letterror.com)
  | See `LICENSE <LICENSE>`__ for the full license.
  Copyright (c) 2000 BeOpen.com. All Rights Reserved.
  Copyright (c) 1995-2001 Corporation for National Research Initiatives.
  All Rights Reserved.
  Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam. All
  Rights Reserved.
  Have fun!
  Changelog
  ~~~~~~~~~


pkgId: 18c908d381cffb5f82fc1dc836cfe69637c1db733b8b58496aeaa6ad7fddce1a
name: python-forex-python
arch: src
version: 1.8
epoch: 0
release: 1
summary: Foreign exchange rates and currency conversion.
url: https://github.com/MicroPyramid/forex-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-664e5305-5223-459c-8d50-51f773ad401b
location_href: 00011179-python-forex-python/python-forex-python-1.8-1.src.rpm
checksum_type: sha256
description:
  Forex Python is a Free Foreign exchange rates and currency conversion.
  Features:
  List all currency rates.
  BitCoin price for all curuncies.
  Converting amount to BitCoins.
  Get historical rates for any day since 1999.
  Conversion rate for one currency(ex; USD to INR).
  Convert amount from one currency to other.('USD 10$' to INR).
  Currency symbols.
  Currency names.

  Documentation: http://forex-python.readthedocs.io/en/latest/usage.html
  GitHub: https://github.com/MicroPyramid/forex-python


pkgId: 62cfa123367a2f41aa412a46800de0a9a419779f9527273f730a2e92a34b9c70
name: python-formats
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Support multiple formats with ease
url: https://github.com/redodo/formats
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-739672bd-2350-4149-b437-0fd5ede175f7
location_href: 00003701-python-formats/python-formats-0.1.1-1.src.rpm
checksum_type: sha256
description:
  |Version| |License|
  Installation via PIP::
      pip install --pre formats
  Quick usage overview::
      >>> import formats
      >>> formats.discover()
      >>> text = '''
      >>> formats.parse('yaml', text)
      {'awesome_things': ['dodos', 'pythons']}
      >>> formats.convert('yaml', 'json', text)
      '{"awesome_things": ["dodos", "pythons"]}'


pkgId: 0a26cff147b441736c1b1a254499da733ccfb6659891491043c4c520e63c2d6a
name: python-fortnitepy
arch: src
version: 3.6.8
epoch: 0
release: 1
summary: Library for interacting with fortnite services
url: https://github.com/Terbau/fortnitepy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7407c345-7bb1-47a9-9a9c-67135449bbea
location_href: 00009327-python-fortnitepy/python-fortnitepy-3.6.8-1.src.rpm
checksum_type: sha256
description:
   

  [![Supported py versions](https://img.shields.io/pypi/pyversions/fortnitepy.svg)](https://pypi.org/project/fortnitepy/)
  [![Current pypi version](https://img.shields.io/pypi/v/fortnitepy.svg)](https://pypi.org/project/fortnitepy/)
  [![Donate link](https://img.shields.io/badge/paypal-donate-blue.svg)](https://www.paypal.me/terbau)

  Asynchronous library for interacting with Fortnite and EpicGames' API and XMPP services.

  **Note:** This library is still under developement so breaking changes might happen at any time.

  **Some key features:**
  - Full support for Friends.
  - Support for XMPP events including friend and party messages + many more.
  - Support for Parties.
  - Support for Battle Royale stats.


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


  ```

  py -3 -m pip install -U fortnitepy


  python3 -m pip install -U fortnitepy
  ```


  ```py
  import fortnitepy
  import json
  import os

  from fortnitepy.ext import commands

  email = 'email@email.com'
  password = 'password1'
  filename = 'device_auths.json'

  def get_device_auth_details():
      if os.path.isfile(filename):
          with open(filename, 'r') as fp:
              return json.load(fp)
      return {}

  def store_device_auth_details(email, details):
      existing = get_device_auth_details()
      existing[email] = details

      with open(filename, 'w') as fp:
          json.dump(existing, fp)

  device_auth_details = get_device_auth_details().get(email, {})
  bot = commands.Bot(
      command_prefix='!',
      auth=fortnitepy.AdvancedAuth(
          email=email,
          password=password,
          prompt_authorization_code=True,
          prompt_code_if_invalid=True,
          delete_existing_device_auths=True,
          **device_auth_details
      )
  )

  @bot.event
  async def event_device_auth_generate(details, email):
      store_device_auth_details(email, details)

  @bot.event
  async def event_ready():
      print('----------------')
      print('Bot ready as')
      print(bot.user.display_name)
      print(bot.user.id)
      print('----------------')

  @bot.event
  async def event_friend_request(request):
      await request.accept()

  @bot.command()
  async def hello(ctx):
      await ctx.send('Hello!')

  bot.run()
  ```


  How to get a one time authorization code:
  1. Log into the epic games account of your choice [here](https://www.epicgames.com/id/logout?redirectUrl=https%3A//www.epicgames.com/id/login%3FredirectUrl%3Dhttps%253A%252F%252Fwww.epicgames.com%252Fid%252Fapi%252Fredirect%253FclientId%253D3446cd72694c4a4485d81b77adbb2141%2526responseType%253Dcode).
  2. Copy the hex part from the url that shows up as showcased by the image below:

  ![Authorization Code](https://raw.githubusercontent.com/Terbau/fortnitepy/dev/docs/resources/images/authorization_code.png)


  Thanks to [Kysune](https://github.com/SzymonLisowiec), [iXyles](https://github.com/iXyles), [Vrekt](https://github.com/Vrekt) and [amrsatrio](https://github.com/Amrsatrio) for ideas and/or work that this library is built upon.

  Also thanks to [discord.py](https://github.com/Rapptz/discord.py) for much inspiration code-wise.


  If you need more help feel free to join this [discord server](https://discord.gg/rnk869s).


pkgId: 9036286bc0260edda80a9d30502e522d997cff9b68cd92eceb8923e0240963e8
name: python-fpdf
arch: src
version: 1.7.2
epoch: 0
release: 1
summary: Simple PDF generation for Python
url: http://code.google.com/p/pyfpdf
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6e6499db-20ab-4d10-8b0f-5a790a75c639
location_href: 00010250-python-fpdf/python-fpdf-1.7.2-1.src.rpm
checksum_type: sha256
description:
  PyFPDF is a library for PDF document generation under Python, ported
  from PHP (see `FPDF <http://www.fpdf.org/>`__ "Free"-PDF, a well-known
  PDFlib-extension replacement with many examples, scripts and
  derivatives).
  Compared with other PDF libraries, PyFPDF is simple, small and
  versatile, with advanced capabilities and easy to learn, extend and
  maintain.


pkgId: 8bb25bf24dd269e74f68e85a8a433f3ccebe45617998ee3d32ad8b6e0b7d941b
name: python-fpylll
arch: src
version: 0.5.9
epoch: 0
release: 1
summary: A Python interface for https://github.com/fplll/fplll
url: https://github.com/fplll/fpylll
rpm_license: GNU General Public License, version 2 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c3434b9b-7684-4937-8547-f4b6367b4a08
location_href: 00003703-python-fpylll/python-fpylll-0.5.9-1.src.rpm
checksum_type: sha256
description:
  A Python wrapper for `fplll <https://github.com/fplll/fplll>`__.
      >>> from fpylll import *
      >>> A = IntegerMatrix(50, 50)
      >>> A.randomize("ntrulike", bits=50, q=127)
      >>> A[0].norm()
      3564748886669202.5
      >>> M = GSO.Mat(A)
      >>> M.update_gso()
      >>> M.get_mu(1,0)
      0.815748944429783
      >>> L = LLL.Reduction(M)
      >>> L()
      >>> M.get_mu(1,0)
      0.41812865497076024
      >>> A[0].norm()
      24.06241883103193
  The basic BKZ algorithm can be implemented in about 60 pretty readable lines of Python code (cf. `simple_bkz.py <https://github.com/fplll/fpylll/blob/master/src/fpylll/algorithms/simple_bkz.py>`__).
  For a quick tour of the library, you can check out the `tutorial <https://github.com/fplll/fpylll/blob/master/docs/tutorial.rst>`__.


pkgId: 3ebec23adf82182668bf37a84b3508ddefd8b49ec7d15919098575293e432d3f
name: python-fqdn
arch: src
version: 1.5.1
epoch: 0
release: 1
url: https://github.com/ypcrts/fqdn
rpm_license: MPL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e4fb495-c590-44b7-90a9-dee87a13549c
location_href: 00011526-python-fqdn/python-fqdn-1.5.1-1.src.rpm
checksum_type: sha256
summary:
  Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers


pkgId: f240b3ea19165c51705c8b2d218e86c16252af4c78fec0ef5b97ecaa90110cb0
name: python-freezegun
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Let your Python tests travel through time
url: https://github.com/spulec/freezegun
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bf08ee77-3740-4035-8b6d-a50f75675076
location_href: 00009224-python-freezegun/python-freezegun-1.2.2-1.src.rpm
checksum_type: sha256
description:
  FreezeGun is a library that allows your Python tests to travel through time by mocking the datetime module.


pkgId: b2204e2adb43944913a881fe83a9b9edc62634798063f1ff6369040a7e51858b
name: python-frozendict
arch: src
version: 2.3.5
epoch: 0
release: 1
summary: A simple immutable dictionary
url: https://github.com/Marco-Sulla/python-frozendict
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df9361d5-42b3-4e1a-9066-cd380b44c5e2
location_href: 00003709-python-frozendict/python-frozendict-2.3.5-1.src.rpm
checksum_type: sha256
description:
  * [Introduction](#introduction)
  * [API](#api)
  * [Examples](#examples)
  * [Building](#building)
  * [Benchmarks](#benchmarks)


  Welcome, fellow programmer!

  `frozendict` is a simple immutable dictionary. It's fast as `dict`, and
  [sometimes faster](https://github.com/Marco-Sulla/python-frozendict#benchmarks)!

  Unlike other similar implementations, immutability is guaranteed: you can't
  change the internal variables of the class, and they are all immutable
  objects.  Reinvoking `__init__` does not alter the object.

  The API is the same as `dict`, without methods that can change the
  immutability. So it supports also `fromkeys`, unlike other implementations.
  Furthermore it can be `pickle`d, un`pickle`d and have an hash, if all values
  are hashable.

  You can also add any `dict` to a `frozendict` using the `|` operator. The result is a new `frozendict`.


  The API is the same of `dict` of Python 3.10, without the methods and operands which alter the map. Additionally, `frozendict` supports these methods:



  If all the values of the `frozendict` are hashable, returns an hash, otherwise raises a TypeError.



  It returns a new `frozendict`. If key is already in the original `frozendict`, the new one will have it with the new value associated. Otherwise, the new `frozendict` will contain the new (key, value) item.



  It returns a new `frozendict` without the item corresponding to the key. If the key is not present, a KeyError is raised.



  If key is already in `frozendict`, the object itself is returned unchanged. Otherwise, the new `frozendict` will contain the new (key, default) item. The parameter default defaults to None.



  It returns the key at the specified index (determined by the insertion order). If index is not passed, it defaults to 0. If the index is negative, the position will be the size of the `frozendict` + index


  Same as `key(index)`, but it returns the value at the given index.


  Same as `key(index)`, but it returns a tuple with (key, value) at the given index.



  ```python
  from frozendict import frozendict

  fd = frozendict({"Guzzanti": "Corrado", "Hicks": "Bill"})

  print(fd)


  print(fd["Guzzanti"])


  fd["Brignano"]


  len(fd)


  "Guzzanti" in fd


  "Guzzanti" not in fd


  "Brignano" in fd


  hash(fd)


  fd_unhashable = frozendict({1: []})
  hash(fd_unhashable)


  fd | {1: 2}


  fd5 = frozendict(fd)
  id_fd5 = id(fd5)
  fd5 |= {1: 2}
  fd5

  id(fd5) != id_fd5


  fd.set(1, 2)


  fd.set("Guzzanti", "Sabina")


  fd.delete("Guzzanti")


  fd.setdefault("Guzzanti", "Sabina")


  fd.setdefault(1, 2)


  fd.key()


  fd.value(1)


  fd.item(-1)


  fd2 = fd.copy()
  fd2 == fd


  fd3 = frozendict(fd)
  fd3 == fd


  fd4 = frozendict({"Hicks": "Bill", "Guzzanti": "Corrado"})

  print(fd4)


  fd4 == fd


  import pickle
  fd_unpickled = pickle.loads(pickle.dumps(fd))
  print(fd_unpickled)

  fd_unpickled == fd


  frozendict(Guzzanti="Corrado", Hicks="Bill")


  frozendict((("Guzzanti", "Corrado"), ("Hicks", "Bill")))


  fd.get("Guzzanti")


  print(fd.get("Brignano"))


  tuple(fd.keys())


  tuple(fd.values())


  tuple(fd.items())


  frozendict.fromkeys(["Corrado", "Sabina"], "Guzzanti")


  iter(fd)


  fd["Guzzanti"] = "Caterina"

  ```


  You can build `frozendict` directly from the code, using

  ```
  python3 setup.py bdist_wheel
  ```

  The C Extension is not optional by default. You can build the pure py package using the `py` custom argument:

  ```
  python3 setup.py py bdist_wheel
  ```



  Some benchmarks between `dict` and `frozendict`[1]:

  ```

  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(d)`;         Size:    5; Keys: str; Type:       dict; Time: 8.02e-08; Sigma: 4e-09
  Name: `constructor(d)`;         Size:    5; Keys: str; Type: frozendict; Time: 8.81e-08; Sigma: 3e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(d)`;         Size:    5; Keys: int; Type:       dict; Time: 7.96e-08; Sigma: 5e-09
  Name: `constructor(d)`;         Size:    5; Keys: int; Type: frozendict; Time: 8.97e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(d)`;         Size: 1000; Keys: str; Type:       dict; Time: 6.38e-06; Sigma: 9e-08
  Name: `constructor(d)`;         Size: 1000; Keys: str; Type: frozendict; Time: 6.21e-06; Sigma: 2e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(d)`;         Size: 1000; Keys: int; Type:       dict; Time: 3.49e-06; Sigma: 3e-07
  Name: `constructor(d)`;         Size: 1000; Keys: int; Type: frozendict; Time: 3.48e-06; Sigma: 2e-07

  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(kwargs)`;    Size:    5; Keys: str; Type:       dict; Time: 2.40e-07; Sigma: 1e-09
  Name: `constructor(kwargs)`;    Size:    5; Keys: str; Type: frozendict; Time: 2.48e-07; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(kwargs)`;    Size: 1000; Keys: str; Type:       dict; Time: 4.80e-05; Sigma: 1e-06
  Name: `constructor(kwargs)`;    Size: 1000; Keys: str; Type: frozendict; Time: 2.90e-05; Sigma: 7e-07

  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(seq2)`;      Size:    5; Keys: str; Type:       dict; Time: 2.01e-07; Sigma: 9e-10
  Name: `constructor(seq2)`;      Size:    5; Keys: str; Type: frozendict; Time: 2.50e-07; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(seq2)`;      Size:    5; Keys: int; Type:       dict; Time: 2.18e-07; Sigma: 2e-09
  Name: `constructor(seq2)`;      Size:    5; Keys: int; Type: frozendict; Time: 2.73e-07; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(seq2)`;      Size: 1000; Keys: str; Type:       dict; Time: 4.29e-05; Sigma: 6e-07
  Name: `constructor(seq2)`;      Size: 1000; Keys: str; Type: frozendict; Time: 4.33e-05; Sigma: 6e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(seq2)`;      Size: 1000; Keys: int; Type:       dict; Time: 3.04e-05; Sigma: 4e-07
  Name: `constructor(seq2)`;      Size: 1000; Keys: int; Type: frozendict; Time: 3.45e-05; Sigma: 4e-07

  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(o)`;         Size:    5; Keys: str; Type:       dict; Time: 7.93e-08; Sigma: 3e-09
  Name: `constructor(o)`;         Size:    5; Keys: str; Type: frozendict; Time: 2.41e-08; Sigma: 6e-10
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(o)`;         Size:    5; Keys: int; Type:       dict; Time: 7.94e-08; Sigma: 5e-09
  Name: `constructor(o)`;         Size:    5; Keys: int; Type: frozendict; Time: 2.41e-08; Sigma: 6e-10
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(o)`;         Size: 1000; Keys: str; Type:       dict; Time: 6.18e-06; Sigma: 3e-07
  Name: `constructor(o)`;         Size: 1000; Keys: str; Type: frozendict; Time: 2.41e-08; Sigma: 6e-10
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(o)`;         Size: 1000; Keys: int; Type:       dict; Time: 3.47e-06; Sigma: 2e-07
  Name: `constructor(o)`;         Size: 1000; Keys: int; Type: frozendict; Time: 2.41e-08; Sigma: 6e-10

  ////////////////////////////////////////////////////////////////////////////////
  Name: `o.copy()`;               Size:    5; Keys: str; Type:       dict; Time: 7.28e-08; Sigma: 2e-09
  Name: `o.copy()`;               Size:    5; Keys: str; Type: frozendict; Time: 3.18e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o.copy()`;               Size:    5; Keys: int; Type:       dict; Time: 7.21e-08; Sigma: 4e-09
  Name: `o.copy()`;               Size:    5; Keys: int; Type: frozendict; Time: 3.32e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o.copy()`;               Size: 1000; Keys: str; Type:       dict; Time: 6.16e-06; Sigma: 3e-07
  Name: `o.copy()`;               Size: 1000; Keys: str; Type: frozendict; Time: 3.18e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o.copy()`;               Size: 1000; Keys: int; Type:       dict; Time: 3.46e-06; Sigma: 1e-07
  Name: `o.copy()`;               Size: 1000; Keys: int; Type: frozendict; Time: 3.18e-08; Sigma: 2e-09

  ////////////////////////////////////////////////////////////////////////////////
  Name: `o == o`;                 Size:    5; Keys: str; Type:       dict; Time: 7.23e-08; Sigma: 8e-10
  Name: `o == o`;                 Size:    5; Keys: str; Type: frozendict; Time: 2.44e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o == o`;                 Size:    5; Keys: int; Type:       dict; Time: 7.30e-08; Sigma: 1e-09
  Name: `o == o`;                 Size:    5; Keys: int; Type: frozendict; Time: 2.44e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o == o`;                 Size: 1000; Keys: str; Type:       dict; Time: 1.38e-05; Sigma: 1e-07
  Name: `o == o`;                 Size: 1000; Keys: str; Type: frozendict; Time: 2.44e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o == o`;                 Size: 1000; Keys: int; Type:       dict; Time: 1.05e-05; Sigma: 7e-08
  Name: `o == o`;                 Size: 1000; Keys: int; Type: frozendict; Time: 2.44e-08; Sigma: 2e-09

  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o`;             Size:    5; Keys: str; Type:       dict; Time: 7.33e-08; Sigma: 2e-09
  Name: `for x in o`;             Size:    5; Keys: str; Type: frozendict; Time: 6.70e-08; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o`;             Size:    5; Keys: int; Type:       dict; Time: 7.33e-08; Sigma: 2e-09
  Name: `for x in o`;             Size:    5; Keys: int; Type: frozendict; Time: 6.70e-08; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o`;             Size: 1000; Keys: str; Type:       dict; Time: 8.84e-06; Sigma: 5e-08
  Name: `for x in o`;             Size: 1000; Keys: str; Type: frozendict; Time: 7.06e-06; Sigma: 6e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o`;             Size: 1000; Keys: int; Type:       dict; Time: 8.67e-06; Sigma: 7e-08
  Name: `for x in o`;             Size: 1000; Keys: int; Type: frozendict; Time: 6.94e-06; Sigma: 3e-08

  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.values()`;    Size:    5; Keys: str; Type:       dict; Time: 7.28e-08; Sigma: 9e-10
  Name: `for x in o.values()`;    Size:    5; Keys: str; Type: frozendict; Time: 6.48e-08; Sigma: 8e-10
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.values()`;    Size:    5; Keys: int; Type:       dict; Time: 7.25e-08; Sigma: 1e-09
  Name: `for x in o.values()`;    Size:    5; Keys: int; Type: frozendict; Time: 6.45e-08; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.values()`;    Size: 1000; Keys: str; Type:       dict; Time: 9.06e-06; Sigma: 5e-07
  Name: `for x in o.values()`;    Size: 1000; Keys: str; Type: frozendict; Time: 7.04e-06; Sigma: 4e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.values()`;    Size: 1000; Keys: int; Type:       dict; Time: 9.53e-06; Sigma: 3e-08
  Name: `for x in o.values()`;    Size: 1000; Keys: int; Type: frozendict; Time: 6.97e-06; Sigma: 3e-08

  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.items()`;     Size:    5; Keys: str; Type:       dict; Time: 1.13e-07; Sigma: 3e-09
  Name: `for x in o.items()`;     Size:    5; Keys: str; Type: frozendict; Time: 1.16e-07; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.items()`;     Size:    5; Keys: int; Type:       dict; Time: 1.14e-07; Sigma: 3e-09
  Name: `for x in o.items()`;     Size:    5; Keys: int; Type: frozendict; Time: 1.17e-07; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.items()`;     Size: 1000; Keys: str; Type:       dict; Time: 1.53e-05; Sigma: 3e-07
  Name: `for x in o.items()`;     Size: 1000; Keys: str; Type: frozendict; Time: 1.53e-05; Sigma: 4e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.items()`;     Size: 1000; Keys: int; Type:       dict; Time: 1.53e-05; Sigma: 3e-07
  Name: `for x in o.items()`;     Size: 1000; Keys: int; Type: frozendict; Time: 1.55e-05; Sigma: 4e-07

  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.dumps(o)`;        Size:    5; Keys: str; Type:       dict; Time: 6.82e-07; Sigma: 2e-08
  Name: `pickle.dumps(o)`;        Size:    5; Keys: str; Type: frozendict; Time: 2.86e-06; Sigma: 1e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.dumps(o)`;        Size:    5; Keys: int; Type:       dict; Time: 4.77e-07; Sigma: 2e-08
  Name: `pickle.dumps(o)`;        Size:    5; Keys: int; Type: frozendict; Time: 2.72e-06; Sigma: 8e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.dumps(o)`;        Size: 1000; Keys: str; Type:       dict; Time: 1.24e-04; Sigma: 4e-06
  Name: `pickle.dumps(o)`;        Size: 1000; Keys: str; Type: frozendict; Time: 1.92e-04; Sigma: 5e-06
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.dumps(o)`;        Size: 1000; Keys: int; Type:       dict; Time: 2.81e-05; Sigma: 6e-07
  Name: `pickle.dumps(o)`;        Size: 1000; Keys: int; Type: frozendict; Time: 7.37e-05; Sigma: 1e-06

  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.loads(dump)`;     Size:    5; Keys: str; Type:       dict; Time: 9.08e-07; Sigma: 6e-09
  Name: `pickle.loads(dump)`;     Size:    5; Keys: str; Type: frozendict; Time: 1.79e-06; Sigma: 9e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.loads(dump)`;     Size:    5; Keys: int; Type:       dict; Time: 4.46e-07; Sigma: 6e-09
  Name: `pickle.loads(dump)`;     Size:    5; Keys: int; Type: frozendict; Time: 1.32e-06; Sigma: 7e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.loads(dump)`;     Size: 1000; Keys: str; Type:       dict; Time: 1.57e-04; Sigma: 8e-06
  Name: `pickle.loads(dump)`;     Size: 1000; Keys: str; Type: frozendict; Time: 1.69e-04; Sigma: 7e-06
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.loads(dump)`;     Size: 1000; Keys: int; Type:       dict; Time: 5.97e-05; Sigma: 5e-06
  Name: `pickle.loads(dump)`;     Size: 1000; Keys: int; Type: frozendict; Time: 6.68e-05; Sigma: 2e-06

  ////////////////////////////////////////////////////////////////////////////////
  Name: `class.fromkeys()`;       Size:    5; Keys: str; Type:       dict; Time: 1.88e-07; Sigma: 1e-09
  Name: `class.fromkeys()`;       Size:    5; Keys: str; Type: frozendict; Time: 2.22e-07; Sigma: 7e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `class.fromkeys()`;       Size:    5; Keys: int; Type:       dict; Time: 2.08e-07; Sigma: 6e-09
  Name: `class.fromkeys()`;       Size:    5; Keys: int; Type: frozendict; Time: 2.44e-07; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `class.fromkeys()`;       Size: 1000; Keys: str; Type:       dict; Time: 4.05e-05; Sigma: 4e-06
  Name: `class.fromkeys()`;       Size: 1000; Keys: str; Type: frozendict; Time: 3.84e-05; Sigma: 5e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `class.fromkeys()`;       Size: 1000; Keys: int; Type:       dict; Time: 2.93e-05; Sigma: 7e-07
  Name: `class.fromkeys()`;       Size: 1000; Keys: int; Type: frozendict; Time: 3.08e-05; Sigma: 2e-06

  ```

  [1] Benchmarks done under Linux 64 bit, Python 3.10.2, using the C Extension.


pkgId: bf5e07537147b6f084faf3acf34dd8f90b715383496ea103e67b14be3bdc51d0
name: python-frozendict-debuginfo
arch: aarch64
version: 2.3.5
epoch: 0
release: 1
summary: Debug information for package python-frozendict
url: https://github.com/Marco-Sulla/python-frozendict
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-df9361d5-42b3-4e1a-9066-cd380b44c5e2
rpm_sourcerpm: python-frozendict-2.3.5-1.src.rpm
location_href: 00003709-python-frozendict/python-frozendict-debuginfo-2.3.5-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-frozendict.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 62bff6cf78fe1a5f1e1ff9abf9847a1d0dcdcc09a0264b1247ef9d6086fca785
name: python-frozendict-debugsource
arch: aarch64
version: 2.3.5
epoch: 0
release: 1
summary: Debug sources for package python-frozendict
url: https://github.com/Marco-Sulla/python-frozendict
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-df9361d5-42b3-4e1a-9066-cd380b44c5e2
rpm_sourcerpm: python-frozendict-2.3.5-1.src.rpm
location_href: 00003709-python-frozendict/python-frozendict-debugsource-2.3.5-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-frozendict.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 3bdc2cacd673e659b10beb9fc725558947d04b82d15fc718b315bf8d547256a6
name: python-frozenlist-debuginfo
arch: aarch64
version: 1.3.3
epoch: 0
release: 1
summary: Debug information for package python-frozenlist
url: https://github.com/aio-libs/frozenlist
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dfc3e073-4926-4d3c-996f-662efce33dea
rpm_sourcerpm: python-frozenlist-1.3.3-1.src.rpm
location_href: 00008967-python-frozenlist/python-frozenlist-debuginfo-1.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-frozenlist.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: f0571f92d65c09cc17035beb3456f6e8b177d6197c75e75338a728d3a6c5e637
name: python-frozenlist-debugsource
arch: aarch64
version: 1.3.3
epoch: 0
release: 1
summary: Debug sources for package python-frozenlist
url: https://github.com/aio-libs/frozenlist
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dfc3e073-4926-4d3c-996f-662efce33dea
rpm_sourcerpm: python-frozenlist-1.3.3-1.src.rpm
location_href: 00008967-python-frozenlist/python-frozenlist-debugsource-1.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-frozenlist.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: d62297d078ea000caeb1a025fc09a5d78d35c393e9a50ed672670cc33a0e19cc
name: python-fsleyes
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: FSLeyes, the FSL image viewer
url: https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-70c87f8f-a0c8-426c-a946-3bb33c44bb5b
location_href: 00003711-python-fsleyes/python-fsleyes-1.6.1-1.src.rpm
checksum_type: sha256
description:
  `FSLeyes <https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes>`_ is the `FSL
  <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki>`_ image viewer.


pkgId: 560394af08b3b595944095aff4004aa208f8aa533aa31c9f69369c0e8ae3de6d
name: python-fsleyes-props
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: [wx]Python event programming framework
url: https://git.fmrib.ox.ac.uk/fsl/fsleyes/props
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe8d0839-365e-4727-b86a-ab3cfe81b453
location_href: 00003712-python-fsleyes-props/python-fsleyes-props-1.9.1-1.src.rpm
checksum_type: sha256
description:
  ``fsleyes-props`` is a library which is used by used by `FSLeyes
  <https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes>`_, and which allows you to:
    - Listen for change to attributes on a python object,
    - Automatically generate ``wxpython`` widgets which are bound
      to attributes of a python object
    - Automatically generate a command line interface to set
      values of the attributes of a python object.
  To do this, you just need to subclass the ``fsleyes)props.HasProperties``
  class (also available as ``fsleyes_props.Props``), and add some
  ``PropertyBase`` types as class attributes.


pkgId: f039ffe7453b39693501cc54b2343ed5b14bd878bf18f3abab7d786232a2d7f7
name: python-fsleyes-widgets
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: A collection of wxPython widgets used by FSLeyes
url: https://git.fmrib.ox.ac.uk/fsl/fsleyes/widgets
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b936ad86-ae1a-49f0-bf9f-2e339a6aaac9
location_href: 00003713-python-fsleyes-widgets/python-fsleyes-widgets-0.13.0-1.src.rpm
checksum_type: sha256
description:
  The ``fsleyes-widgets`` package contains a collection of GUI widgets and
  utilities, based on `wxPython <http://www.wxpython.org>`_. These widgets are
  used by `fsleyes-props <https://git.fmrib.ox.ac.uk/fsl/fsleyes/props>`_ and
  `FSLeyes <https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes>`_,


pkgId: 36910422c9e9127a42d57247e1a80167e727d30bfb851078577755dd5718246d
name: python-fslpy
arch: src
version: 3.11.3
epoch: 0
release: 1
summary: FSL Python library
url: https://git.fmrib.ox.ac.uk/fsl/fslpy
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ecde4dfc-c6be-4054-91af-768a139baa11
location_href: 00003714-python-fslpy/python-fslpy-3.11.3-1.src.rpm
checksum_type: sha256
description:
  The ``fslpy`` project is a `FSL <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/>`_
  programming library written in Python. It is used by `FSLeyes
  <https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes/>`_.
  ``fslpy`` is tested against Python versions 3.8, 3.9, 3.10, and 3.11.


pkgId: 84c9423e3ef8f0357dc80954165e745dbc2c6bf12951ca2c61686c495c64664c
name: python-fsspec
arch: src
version: 2023.3.0
epoch: 0
release: 1
summary: File-system specification
url: http://github.com/fsspec/filesystem_spec
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3b124682-80f1-46fd-b38e-6a153a51ed87
location_href: 00003715-python-fsspec/python-fsspec-2023.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/fsspec.svg)](https://pypi.python.org/pypi/fsspec/)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/fsspec/badges/version.svg)](https://anaconda.org/conda-forge/fsspec)
  ![Build](https://github.com/fsspec/filesystem_spec/workflows/CI/badge.svg)
  [![Docs](https://readthedocs.org/projects/filesystem-spec/badge/?version=latest)](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)

  A specification for pythonic filesystems.



  ```bash
  pip install fsspec
  ```
  or
  ```bash
  conda install -c conda-forge fsspec
  ```



  To produce a template or specification for a file-system interface, that specific implementations should follow,
  so that applications making use of them can rely on a common behaviour and not have to worry about the specific
  internal implementation decisions with any given backend. Many such implementations are included in this package,
  or in sister projects such as `s3fs` and `gcsfs`.

  In addition, if this is well-designed, then additional functionality, such as a key-value store or FUSE
  mounting of the file-system implementation may be available for all implementations "for free".



  Please refer to [RTD](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)



  fsspec uses GitHub Actions for CI. Environment files can be found
  in the "ci/" directory. Note that the main environment is called "py38",
  but it is expected that the version of python installed be adjustable at
  CI runtime. For local use, pick a version suitable for you.



  Tests can be run in the dev environment, if activated, via ``pytest fsspec``.

  The full fsspec suite requires a system-level docker, docker-compose, and fuse
  installation. If only making changes to one backend implementation, it is
  not generally necessary to run all tests locally.

  It is expected that contributors ensure that any change to fsspec does not
  cause issues or regressions for either other fsspec-related packages such
  as gcsfs and s3fs, nor for downstream users of fsspec. The "downstream" CI
  run and corresponding environment file run a set of tests from the dask
  test suite, and very minimal tests against pandas and zarr from the
  test_downstream.py module in this repo.



  fsspec uses [Black](https://black.readthedocs.io/en/stable) to ensure
  a consistent code format throughout the project.
  Run ``black fsspec`` from the root of the filesystem_spec repository to
  auto-format your code. Additionally, many editors have plugins that will apply
  ``black`` as you edit files. ``black`` is included in the ``tox`` environments.

  Optionally, you may wish to setup [pre-commit hooks](https://pre-commit.com) to
  automatically run ``black`` when you make a git commit.
  Run ``pre-commit install --install-hooks`` from the root of the
  filesystem_spec repository to setup pre-commit hooks. ``black`` will now be run
  before you commit, reformatting any changed files. You can format without
  committing via ``pre-commit run`` or skip these checks with ``git commit
  --no-verify``.


pkgId: 9b3d78c967f71bebffd6c66ef23b47621de71c2e5b1ae52c05b63e8026d9c6ff
name: python-ftfy
arch: src
version: 6.1.1
epoch: 0
release: 1
summary: Fixes mojibake and other problems with Unicode, after the fact
url: https://pypi.org/project/ftfy/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-17006081-7af9-43fa-bc98-aa370fcaf142
location_href: 00009670-python-ftfy/python-ftfy-6.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI package](https://badge.fury.io/py/ftfy.svg)](https://badge.fury.io/py/ftfy)
  [![Docs](https://readthedocs.org/projects/ftfy/badge/?version=latest)](https://ftfy.readthedocs.org/en/latest/)

  ```python
  >>> print(fix_encoding("(à¸‡'âŒ£')à¸‡"))
  (ง'⌣')ง
  ```

  The full documentation of ftfy is available at [ftfy.readthedocs.org](https://ftfy.readthedocs.org). The documentation covers a lot more than this README, so here are
  some links into it:

  - [Fixing problems and getting explanations](https://ftfy.readthedocs.io/en/latest/explain.html)
  - [Configuring ftfy](https://ftfy.readthedocs.io/en/latest/config.html)
  - [Encodings ftfy can handle](https://ftfy.readthedocs.io/en/latest/encodings.html)
  - [“Fixer” functions](https://ftfy.readthedocs.io/en/latest/fixes.html)
  - [Is ftfy an encoding detector?](https://ftfy.readthedocs.io/en/latest/detect.html)
  - [Heuristics for detecting mojibake](https://ftfy.readthedocs.io/en/latest/heuristic.html)
  - [Support for “bad” encodings](https://ftfy.readthedocs.io/en/latest/bad_encodings.html)
  - [Command-line usage](https://ftfy.readthedocs.io/en/latest/cli.html)
  - [Citing ftfy](https://ftfy.readthedocs.io/en/latest/cite.html)



  - “My life is livable again!”
    — [@planarrowspace](https://twitter.com/planarrowspace)
  - “A handy piece of magic”
    — [@simonw](https://twitter.com/simonw)
  - “Saved me a large amount of frustrating dev work”
    — [@iancal](https://twitter.com/iancal)
  - “ftfy did the right thing right away, with no faffing about. Excellent work, solving a very tricky real-world (whole-world!) problem.”
    — Brennan Young
  - “I have no idea when I’m gonna need this, but I’m definitely bookmarking it.”
    — [/u/ocrow](https://reddit.com/u/ocrow)
  - “9.2/10”
    — [pylint](https://bitbucket.org/logilab/pylint/)



  Here are some examples (found in the real world) of what ftfy can do:

  ftfy can fix mojibake (encoding mix-ups), by detecting patterns of characters that were clearly meant to be UTF-8 but were decoded as something else:

      >>> import ftfy
      >>> ftfy.fix_text('âœ” No problems')
      '✔ No problems'

  Does this sound impossible? It's really not. UTF-8 is a well-designed encoding that makes it obvious when it's being misused, and a string of mojibake usually contains all the information we need to recover the original string.

  ftfy can fix multiple layers of mojibake simultaneously:

      >>> ftfy.fix_text('The Mona Lisa doesnÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢t have eyebrows.')
      "The Mona Lisa doesn't have eyebrows."

  It can fix mojibake that has had "curly quotes" applied on top of it, which cannot be consistently decoded until the quotes are uncurled:

      >>> ftfy.fix_text("l’humanitÃ©")
      "l'humanité"

  ftfy can fix mojibake that would have included the character U+A0 (non-breaking space), but the U+A0 was turned into an ASCII space and then combined with another following space:

      >>> ftfy.fix_text('Ã\xa0 perturber la rÃ©flexion')
      'à perturber la réflexion'
      >>> ftfy.fix_text('Ã perturber la rÃ©flexion')
      'à perturber la réflexion'

  ftfy can also decode HTML entities that appear outside of HTML, even in cases where the entity has been incorrectly capitalized:

      >>> # by the HTML 5 standard, only 'P&Eacute;REZ' is acceptable
      >>> ftfy.fix_text('P&EACUTE;REZ')
      'PÉREZ'

  These fixes are not applied in all cases, because ftfy has a strongly-held goal of avoiding false positives -- it should never change correctly-decoded text to something else.

  The following text could be encoded in Windows-1252 and decoded in UTF-8, and it would decode as 'MARQUɅ'. However, the original text is already sensible, so it is unchanged.

      >>> ftfy.fix_text('IL Y MARQUÉ…')
      'IL Y MARQUÉ…'



  ftfy is a Python 3 package that can be installed using `pip`:

      pip install ftfy

  (Or use `pip3 install ftfy` on systems where Python 2 and 3 are both globally
  installed and `pip` refers to Python 2.)



  ftfy is developed using `poetry`. Its `setup.py` is vestigial and is not the
  recommended way to install it.

  [Install Poetry](https://python-poetry.org/docs/master/#installing-with-the-official-installer), check out this repository, and run `poetry install` to install ftfy for local development, such as experimenting with the heuristic or running tests.



  I'm Robyn Speer, also known as Elia Robyn Lake. You can find me
  [on GitHub](https://github.com/rspeer) or [Twitter](https://twitter.com/r_speer).



  ftfy has been used as a crucial data processing step in major NLP research.

  It's important to give credit appropriately to everyone whose work you build on
  in research. This includes software, not just high-status contributions such as
  mathematical models. All I ask when you use ftfy for research is that you cite
  it.

  ftfy has a citable record [on Zenodo](https://zenodo.org/record/2591652).
  A citation of ftfy may look like this:

      Robyn Speer. (2019). ftfy (Version 5.5). Zenodo.
      http://doi.org/10.5281/zenodo.2591652

  In BibTeX format, the citation is::

      @misc{speer-2019-ftfy,
        author       = {Robyn Speer},
        title        = {ftfy},
        note         = {Version 5.5},
        year         = 2019,
        howpublished = {Zenodo},
        doi          = {10.5281/zenodo.2591652},
        url          = {https://doi.org/10.5281/zenodo.2591652}
      }


pkgId: 7129adf741aaab9efdc9eb72d0898ef633b05e60971732a1ce7fab8663de3cd0
name: python-ftputil
arch: src
version: 5.0.4
epoch: 0
release: 1
summary: High-level FTP client library (virtual file system and more)
url: https://ftputil.sschwarzer.net/
rpm_license: Open source (revised BSD license)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-89064f7a-693d-4305-b584-25d42d57198f
location_href: 00012738-python-ftputil/python-ftputil-5.0.4-1.src.rpm
checksum_type: sha256
description:
  ftputil is a high-level FTP client library for the Python programming
  language. ftputil implements a virtual file system for accessing FTP servers,
  that is, it can generate file-like objects for remote files. The library
  supports many functions similar to those in the os, os.path and
  shutil modules. ftputil has convenience functions for conditional uploads
  and downloads, and handles FTP clients and servers in different timezones.


pkgId: 8175d0b5c73d015f1a3f2d2bdac947fdf7a168661f3d0972a7a329d354610742
name: python-fuckit
arch: src
version: 4.8.1
epoch: 0
release: 1
summary: The Python Error Steamroller
url: https://github.com/ajalt/fuckitpy
rpm_license: WTFPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b183b80-7e0b-4a5e-89d2-21861c891a8f
location_href: 00003716-python-fuckit/python-fuckit-4.8.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/travis/ajalt/fuckitpy/master.svg)](https://travis-ci.org/ajalt/fuckitpy)
  [![PyPI version](https://img.shields.io/badge/pypi-4.8.1-brightgreen.svg)](https://pypi.python.org/pypi/fuckit/4.8.1)
  [![Coverage Status](https://img.shields.io/badge/coverage-110%25-brightgreen.svg)](https://coveralls.io/r/ajalt/fuckitpy?branch=master)
  [![Downloads](https://img.shields.io/badge/downloads-1.1M%2Fmonth-brightgreen.svg)](https://pypi.python.org/pypi/fuckit)


  FuckIt.py uses state-of-the-art technology to make sure your Python code runs
  whether it has any right to or not. Some code has an error? Fuck it.


  FuckIt.py uses a combination of dynamic compilation, Abstract Syntax Tree rewriting, live call stack modification, and love to get rid of all those pesky errors that make programming _so hard_.


  All functionality is provided through the fuckit module. Add `import fuckit` to the top of your script, then use fuckit in any of the following ways:


  Use fuckit to replace an import when a module has errors.
  Just change `import some_shitty_module` to `fuckit('some_shitty_module')`. Note that you have to surround the module name with quotes and parentheses.

  ```python
  import fuckit

  fuckit('some_shitty_module')
  some_shitty_module.some_function()
  ```

  Still getting errors? Chain fuckit calls. This module is like violence: if it doesn't work, you just need more of it.

  ```python
  import fuckit
  fuckit(fuckit('some_shitty_module'))

  some_shitty_module.some_function()
  ```


  Use fuckit as a function decorator when a single function is giving you trouble. Exceptions will be silenced, and in most cases the function will continue to run, skipping the statements that cause errors.

  ```python
  @fuckit
  def func():
      problem_solved
  ```

  You can use fuckit as a class decorator, too.

  ```python
  @fuckit
  class C(object):
      def __init__(self):
          everything_works_now
  ```

  Keep in mind that the decorator form of fuckit can't stop syntax errors. For those, you have to use the import form.


  Use fuckit as a context manager to save yourself from having to type out try/except block to silence exceptions yourself.

  ```python
  with fuckit:
      some_code
  ```

  This is functionally equivalent to the following:

  ```python
  try:
      some_code
  except Exception:
      pass
  ```

  The context manager form of fuckit can't allow the code to continue past an error like the decorator and import forms can. If you want the code to continue after an exception, wrap the code block in a function and use the decorator instead.




                  DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                         Version 2, December 2004

  	Copyright (C) 2014-2018 AJ Alt

  	Everyone is permitted to copy and distribute verbatim or modified
  	copies of this license document, and changing it is allowed as long
  	as the name is changed.

                  DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
         TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

   	0. You just DO WHAT THE FUCK YOU WANT TO.



  This module is inspired by Matt Diamond's [FuckIt.js](https://github.com/mattdiamond/fuckitjs).


pkgId: 5531769b23e025c9fbd3ea9c17781cc8a33533d8d2ee887809487ff1371fa2cf
name: python-funcparserlib
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Recursive descent parsing library based on functional combinators
url: https://funcparserlib.pirx.ru
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26d08a3b-b74d-40f7-807b-db8d44ecc0f4
location_href: 00003717-python-funcparserlib/python-funcparserlib-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Recursive descent parsing library for Python based on functional combinators.
  [![PyPI](https://img.shields.io/pypi/v/funcparserlib)](https://pypi.org/project/funcparserlib/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/funcparserlib)](https://pypi.org/project/funcparserlib/)


pkgId: 1ba6a2e3c5611199a4c1c2e1c695539c5d0f052aef997c70ea711317ab17484e
name: python-funcy
arch: src
version: 1.18
epoch: 0
release: 1
summary: A fancy and practical functional tools
url: http://github.com/Suor/funcy
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fdf7b2ce-b160-4c84-a975-3c84402c96e9
location_href: 00003718-python-funcy/python-funcy-1.18-1.src.rpm
checksum_type: sha256
description:
  A collection of fancy functional tools focused on practicality.
  Inspired by clojure, underscore and my own abstractions. Keep reading to get an overview
  or `read the docs <http://funcy.readthedocs.org/>`_.
  Or jump directly to `cheatsheet <http://funcy.readthedocs.io/en/stable/cheatsheet.html>`_.
  Works with Python 2.7, 3.4+ and pypy.


pkgId: d3d59c4eafa68216b5e6aef6f02841b90e1e5185d0f2dae110cedfbac0477dfb
name: python-fusepy
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Simple ctypes bindings for FUSE
url: http://github.com/fusepy/fusepy
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e9db4eb3-0def-44f5-8953-a4fdc0be5716
location_href: 00003720-python-fusepy/python-fusepy-3.0.1-1.src.rpm
checksum_type: sha256
description:
      **NOTE**: *This project has moved to be under a GitHub organization and can
      be found at https://github.com/fusepy/fusepy. The project has new
      maintainers and will be looking to incorporate pull requests in a more
      timely manner. If you would like to help maintain this package please open
      a pull request and demonstrate willingness to help (we will leave
      maintainer criteria up to the current maintainers).*
  ``fusepy`` is a Python module that provides a simple interface to FUSE_ and
  MacFUSE_. It's just one file and is implemented using ctypes.
  The original version of ``fusepy`` was hosted on `Google Code`_, but is now
  `officially hosted on GitHub`_.
  ``fusepy`` is written in 2x syntax, but trying to pay attention to bytes and
  other changes 3x would care about.


pkgId: 9994b94c9a4bb0f76fd792417a7e70704d8c8a44df32297d19de62ff617120a7
name: python-future
arch: src
version: 0.18.3
epoch: 0
release: 1
summary: Clean single-source support for Python 3 and 2
url: https://python-future.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-607a96fb-e42b-4a15-aabd-b0b9b33f1402
location_href: 00008948-python-future/python-future-0.18.3-1.src.rpm
checksum_type: sha256
description:
  ``future`` is the missing compatibility layer between Python 2 and Python
  3. It allows you to use a single, clean Python 3.x-compatible codebase to
  support both Python 2 and Python 3 with minimal overhead.
  It is designed to be used as follows::
      from __future__ import (absolute_import, division,
                              print_function, unicode_literals)
      from builtins import (
               bytes, dict, int, list, object, range, str,
               ascii, chr, hex, input, next, oct, open,
               pow, round, super,
               filter, map, zip)
  followed by predominantly standard, idiomatic Python 3 code that then runs
  similarly on Python 2.6/2.7 and Python 3.3+.
  The imports have no effect on Python 3. On Python 2, they shadow the
  corresponding builtins, which normally have different semantics on Python 3
  versus 2, to provide their Python 3 semantics.
  Standard library reorganization
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  ``future`` supports the standard library reorganization (PEP 3108) through the
  following Py3 interfaces:
      >>> # Top-level packages with Py3 names provided on Py2:
      >>> import html.parser
      >>> import queue
      >>> import tkinter.dialog
      >>> import xmlrpc.client
      >>> # etc.
      >>> # Aliases provided for extensions to existing Py2 module names:
      >>> from future.standard_library import install_aliases
      >>> install_aliases()
      >>> from collections import Counter, OrderedDict   # backported to Py2.6
      >>> from collections import UserDict, UserList, UserString
      >>> import urllib.request
      >>> from itertools import filterfalse, zip_longest
      >>> from subprocess import getoutput, getstatusoutput


pkgId: c8216a551e3fdbe67ce89917c368a5335dd2eaf97d285f459e4865b5bbde0758
name: python-fuzzysearch-debuginfo
arch: aarch64
version: 0.7.3
epoch: 0
release: 1
summary: Debug information for package python-fuzzysearch
url: https://github.com/taleinat/fuzzysearch
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e64ee0b3-cde8-4303-af7b-5ffaf3983ec6
rpm_sourcerpm: python-fuzzysearch-0.7.3-1.src.rpm
location_href: 00010410-python-fuzzysearch/python-fuzzysearch-debuginfo-0.7.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-fuzzysearch.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 5925f0552c8e350bbed98f763627d777e1e51fa8996155d2b57fcffefa5c57a1
name: python-fuzzysearch-debugsource
arch: aarch64
version: 0.7.3
epoch: 0
release: 1
summary: Debug sources for package python-fuzzysearch
url: https://github.com/taleinat/fuzzysearch
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e64ee0b3-cde8-4303-af7b-5ffaf3983ec6
rpm_sourcerpm: python-fuzzysearch-0.7.3-1.src.rpm
location_href: 00010410-python-fuzzysearch/python-fuzzysearch-debugsource-0.7.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-fuzzysearch.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 8d36e6c22e24b12e2dabbd18e5093c84e8df0d01a4fcf88fcde1ab59207820f3
name: python-fuzzywuzzy
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Fuzzy string matching in python
url: https://github.com/seatgeek/fuzzywuzzy
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0582322e-d5d3-472a-b2de-505df81b8fac
location_href: 00003724-python-fuzzywuzzy/python-fuzzywuzzy-0.18.0-1.src.rpm
checksum_type: sha256
description:
  Fuzzy string matching like a boss. It uses `Levenshtein Distance <https://en.wikipedia.org/wiki/Levenshtein_distance>`_ to calculate the differences between sequences in a simple-to-use package.


pkgId: ef2a2483428af828e3cc2bdb3eee78575833a9e1bc4318c5f67ec26895c85f2b
name: python-fypp
arch: src
version: 3.1
epoch: 0
release: 1
summary: Python powered Fortran preprocessor
url: https://github.com/aradi/fypp
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a242ee5-43c6-4a51-8f24-564a172e7f35
location_href: 00003725-python-fypp/python-fypp-3.1-1.src.rpm
checksum_type: sha256
description:
  * Definition, evaluation and removal of variables::
      
        print *, "Some debug information"
      
      
      print *, "LOGLEVEL: ${LOGLEVEL}$"
      
  * Macro definitions and macro calls::
      
        
          if (.not. ${cond}$) then
            print *, "Assert failed in file ${_FILE_}$, line ${_LINE_}$"
            error stop
          end if
        
      
      ! Invoked via direct call (argument needs no quotation)
      @:ASSERT(size(myArray) > 0)
      ! Invoked as Python expression (argument needs quotation)
      $:ASSERT('size(myArray) > 0')
  * Conditional output::
      program test
      
        use mpi
      
        use openmp
      
        use serial
      
  * Iterated output (e.g. for generating Fortran templates)::
      interface myfunc
      
        module procedure myfunc_${dtype}$
      
      end interface myfunc
  * Inline directives::
      logical, parameter :: hasMpi = #{if defined('MPI')}# .true. #{else}# .false. #{endif}#
  * Insertion of arbitrary Python expressions::
      character(*), parameter :: comp_date = "${time.strftime('%Y-%m-%d')}$"
  * Inclusion of files during preprocessing::
      
  * Using Fortran-style continutation lines in preprocessor directives::
      
          & or var2 > var4
        print *, "Doing something here"
      
  * Passing (unquoted) multiline string arguments to callables::
      
      
        
          $:code
        
      
      
      
        if (size(array) > 100) then
          print *, "DEBUG: spuriously large array"
        end if
      
      
      
        
          $:code
        
      
      
      
      this will be repeated 3 times
      
  * Preprocessor comments::
      
      
  * Suppressing the preprocessor output in selected regions::
      
      
      
      
  * Explicit request for stopping the preprocessor::
      
        
      
  * Easy check for macro parameter sanity::
      
        
        
      
  * Line numbering directives in output::
      program test
      
      use mpi
      
    transformed to ::
      
      program test
      
      use mpi
      
    when variable ``MPI`` is defined and Fypp was instructed to generate line
    markers.
  * Automatic folding of generated lines exceeding line length limit


pkgId: fcc1dbad1876cc09b2005bc284eaecdb95a7b77fd369cbe2980e6f96683e416c
name: python-gTTS
arch: src
version: 2.3.1
epoch: 0
release: 1
url: https://pypi.org/project/gTTS/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b353b50-1506-4325-9cc1-b94738f9b39b
location_href: 00003824-python-gtts/python-gTTS-2.3.1-1.src.rpm
checksum_type: sha256
summary:
  gTTS (Google Text-to-Speech), a Python library and CLI tool to interface with Google Translate text-to-speech API

description:
  **gTTS** (*Google Text-to-Speech*), a Python library and CLI tool to interface with Google Translate's text-to-speech API.
  Write spoken `mp3` data to a file, a file-like object (bytestring) for further audio manipulation, or `stdout`.
  <http://gtts.readthedocs.org/>

  [![PyPI version](https://img.shields.io/pypi/v/gTTS.svg)](https://pypi.org/project/gTTS/)
  [![Python versions](https://img.shields.io/pypi/pyversions/gTTS.svg)](https://pypi.org/project/gTTS/)
  [![Tests workflow](https://github.com/pndurette/gTTS/workflows/Tests/badge.svg)](https://github.com/pndurette/gTTS/actions)
  [![codecov](https://codecov.io/gh/pndurette/gTTS/branch/master/graph/badge.svg)](https://codecov.io/gh/pndurette/gTTS)
  [![Commits Since](https://img.shields.io/github/commits-since/pndurette/gTTS/latest.svg)](https://github.com/pndurette/gTTS/commits/)
  [![PyPi Downloads](http://pepy.tech/badge/gtts)](http://pepy.tech/project/gtts)
  [![Buy me a Coffee](https://img.shields.io/badge/buy%20me%20a-coffee-orange)](https://www.buymeacoffee.com/pndurette)



  -   Customizable speech-specific sentence tokenizer that allows for unlimited lengths of text to be read, all while keeping proper intonation, abbreviations, decimals and more;
  -   Customizable text pre-processors which can, for example, provide pronunciation corrections;



      $ pip install gTTS



  Command Line:

      $ gtts-cli 'hello' --output hello.mp3

  Module:

      >>> from gtts import gTTS
      >>> tts = gTTS('hello')
      >>> tts.save('hello.mp3')

  See <http://gtts.readthedocs.org/> for documentation and examples.



  This project is *not* affiliated with Google or Google Cloud. Breaking upstream changes *can* occur without notice. This project is leveraging the undocumented [Google Translate](https://translate.google.com) speech functionality and is *different* from [Google Cloud Text-to-Speech](https://cloud.google.com/text-to-speech/).



  -   [Questions & community](https://github.com/pndurette/gTTS/discussions)
  -   [Changelog](CHANGELOG.rst)
  -   [Contributing](CONTRIBUTING.rst)



  [The MIT License (MIT)](LICENSE) Copyright © 2014-2022 Pierre Nicolas Durette & [Contributors](https://github.com/pndurette/gTTS/graphs/contributors)


pkgId: ee52bafc97beb35df2e0859632b525c1d786e4ee807859b5e9b395a928c91d66
name: python-gTTS-token
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: Calculates a token to run the Google Translate text to speech
url: https://github.com/boudewijn26/gTTS-token
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-23772271-0203-4ca4-bbe1-d44777894f68
location_href: 00003825-python-gtts-token/python-gTTS-token-1.1.4-1.src.rpm
checksum_type: sha256
description:
  **gTTS-token** (Google Text to Speech token): A python implementation of the token validation of Google Translate
  [![Build Status](https://travis-ci.org/Boudewijn26/gTTS-token.svg?branch=master)](https://travis-ci.org/Boudewijn26/gTTS-token)


pkgId: 8ebb9a58334807a389c6ae7c874e71107c2d94f9417503ecfce63ccc51b436dd
name: python-gabbi
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: Declarative HTTP testing library
url: https://github.com/cdent/gabbi
rpm_license: Apache-2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7cdbf2da-4270-4b1b-80c1-6ce27fae535b
location_href: 00003726-python-gabbi/python-gabbi-2.8.0-1.src.rpm
checksum_type: sha256
description:
  `Release Notes`_
  Gabbi is a tool for running HTTP tests where requests and responses
  are represented in a declarative YAML-based form. The simplest test
  looks like this::
      tests:
      - name: A test
        GET: /api/resources/id
  See the docs_ for more details on the many features and formats for
  setting request headers and bodies and evaluating responses.
  Gabbi is tested with Python 3.6, 3.7, 3.8, 3.9, 3.10 and pypy3.
  Tests can be run using `unittest`_ style test runners, `pytest`_
  or from the command line with a `gabbi-run`_ script.
  There is a `gabbi-demo`_ repository which provides a tutorial via
  its commit history. The demo builds a simple API using gabbi to
  facilitate test driven development.


pkgId: ba84b8ac3a41246df4a28026289cb0f188b0a7ae25f968de05d3ac418ea49269
name: python-gapic-google-cloud-datastore-v1
arch: src
version: 0.90.4
epoch: 0
release: 1
summary: GAPIC library for the Google Cloud Datastore API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e0037ad-d2f5-4f9d-9e02-1ef2b10fdafe
checksum_type: sha256
description:
  gapic-google-cloud-datastore-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Cloud Datastore API`_ (v1) defined in the googleapis_ git repository

location_href:
  00011706-python-gapic-google-cloud-datastore-v1/python-gapic-google-cloud-datastore-v1-0.90.4-1.src.rpm


pkgId: 1d7d222df2c3867b24a46d36d2e563fa1d547119044e7c451e12a62fbf2af934
name: python-gapic-google-cloud-datastore-v1-help
arch: noarch
version: 0.90.4
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-datastore-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e0037ad-d2f5-4f9d-9e02-1ef2b10fdafe
rpm_sourcerpm: python-gapic-google-cloud-datastore-v1-0.90.4-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-datastore-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Cloud Datastore API`_ (v1) defined in the googleapis_ git repository

location_href:
  00011706-python-gapic-google-cloud-datastore-v1/python-gapic-google-cloud-datastore-v1-help-0.90.4-1.noarch.rpm


pkgId: 6743975e1eeba677a72fae44cbd151fb25136fad7cfc63cbe6577369ad2554b3
name: python-gapic-google-cloud-error-reporting-v1beta1
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: GAPIC library for the Stackdriver Error Reporting API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-83c2a1e5-7525-4b24-90c5-b610e03c7af5
checksum_type: sha256
description:
  gapic-google-cloud-error-reporting-v1beta1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Stackdriver Error Reporting API`_ (v1beta1) defined in the googleapis_ git repository

location_href:
  00012109-python-gapic-google-cloud-error-reporting-v1beta1/python-gapic-google-cloud-error-reporting-v1beta1-0.15.3-1.src.rpm


pkgId: 15baed4c3de31a4223c54862c53619b001e03b9e3744e7075bf9d59f1b450794
name: python-gapic-google-cloud-error-reporting-v1beta1-help
arch: noarch
version: 0.15.3
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-error-reporting-v1beta1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-83c2a1e5-7525-4b24-90c5-b610e03c7af5
rpm_sourcerpm: python-gapic-google-cloud-error-reporting-v1beta1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-error-reporting-v1beta1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Stackdriver Error Reporting API`_ (v1beta1) defined in the googleapis_ git repository

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


pkgId: 4c37aaf1ac0ada3d7abf58530f85583d6b0386156bff9922d4d947bfa4de6aef
name: python-gapic-google-cloud-logging-v2
arch: src
version: 0.91.3
epoch: 0
release: 1
summary: GAPIC library for the Stackdriver Logging API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a94de723-df21-4fb3-a33a-8ca0e0d0df0b
location_href: 00011562-python-gapic-google-cloud-logging-v2/python-gapic-google-cloud-logging-v2-0.91.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-logging-v2 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Stackdriver Logging API`_ (v2) defined in the googleapis_ git repository


pkgId: 542e443e326930bcd9ac4b2a297f558d0a78d5073466d84cbc2110d381a5f828
name: python-gapic-google-cloud-logging-v2-help
arch: noarch
version: 0.91.3
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-logging-v2
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a94de723-df21-4fb3-a33a-8ca0e0d0df0b
rpm_sourcerpm: python-gapic-google-cloud-logging-v2-0.91.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-logging-v2 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Stackdriver Logging API`_ (v2) defined in the googleapis_ git repository

location_href:
  00011562-python-gapic-google-cloud-logging-v2/python-gapic-google-cloud-logging-v2-help-0.91.3-1.noarch.rpm


pkgId: db7514385a41643c0a59a510bf92000785a1ae7d8ef78eeb1f3270651920ac91
name: python-gapic-google-cloud-pubsub-v1
arch: src
version: 0.15.4
epoch: 0
release: 1
summary: GAPIC library for the Google Cloud Pub/Sub API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d735ca58-70d3-41af-a157-f09ae802ad49
location_href: 00012492-python-gapic-google-cloud-pubsub-v1/python-gapic-google-cloud-pubsub-v1-0.15.4-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-pubsub-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Cloud Pub/Sub API`_ (v1) defined in the googleapis_ git repository


pkgId: a1f75a39e1b5e9c2519e3e9c25fefcb9299729db023320ac973b3865cee4161e
name: python-gapic-google-cloud-pubsub-v1-help
arch: noarch
version: 0.15.4
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-pubsub-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d735ca58-70d3-41af-a157-f09ae802ad49
rpm_sourcerpm: python-gapic-google-cloud-pubsub-v1-0.15.4-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-pubsub-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Cloud Pub/Sub API`_ (v1) defined in the googleapis_ git repository

location_href:
  00012492-python-gapic-google-cloud-pubsub-v1/python-gapic-google-cloud-pubsub-v1-help-0.15.4-1.noarch.rpm


pkgId: f81299abe4d7e77f080888d46672efe645ad9da1165fcdaa0014da7d80e80efb
name: python-gapic-google-cloud-spanner-admin-database-v1
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: GAPIC library for the Cloud Spanner Database Admin API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22372065-e447-4587-901e-42f46e35bb35
checksum_type: sha256
description:
  gapic-google-cloud-spanner-admin-database-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Cloud Spanner Database Admin API`_ (v1) defined in the googleapis_ git repository

location_href:
  00012997-python-gapic-google-cloud-spanner-admin-database-v1/python-gapic-google-cloud-spanner-admin-database-v1-0.15.3-1.src.rpm


pkgId: e4e372081cd1ce5a04d534a4c1a5b6a62b9a2190dde03db56db610e3335ab2c9
name: python-gapic-google-cloud-spanner-admin-database-v1-help
arch: noarch
version: 0.15.3
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-spanner-admin-database-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22372065-e447-4587-901e-42f46e35bb35
rpm_sourcerpm: python-gapic-google-cloud-spanner-admin-database-v1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-spanner-admin-database-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Cloud Spanner Database Admin API`_ (v1) defined in the googleapis_ git repository

location_href:
  00012997-python-gapic-google-cloud-spanner-admin-database-v1/python-gapic-google-cloud-spanner-admin-database-v1-help-0.15.3-1.noarch.rpm


pkgId: 6a6b27bf340a58e32b9926bd87c40a956a840af9557010326715fc411ae2ebb0
name: python-gapic-google-cloud-spanner-v1
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: GAPIC library for the Cloud Spanner API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86314ed9-122e-4cdd-9c2a-51663f6b87ce
location_href: 00013000-python-gapic-google-cloud-spanner-v1/python-gapic-google-cloud-spanner-v1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-spanner-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Cloud Spanner API`_ (v1) defined in the googleapis_ git repository


pkgId: ac97deb0866fe02565dd834cdde464f36500f8c66fb999090b77fd49e426a018
name: python-gapic-google-cloud-spanner-v1-help
arch: noarch
version: 0.15.3
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-spanner-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86314ed9-122e-4cdd-9c2a-51663f6b87ce
rpm_sourcerpm: python-gapic-google-cloud-spanner-v1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-spanner-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Cloud Spanner API`_ (v1) defined in the googleapis_ git repository

location_href:
  00013000-python-gapic-google-cloud-spanner-v1/python-gapic-google-cloud-spanner-v1-help-0.15.3-1.noarch.rpm


pkgId: 773d7817cfb349cd0301fbebdfbc8e5daa68c4d264d76a554ca1ba84a2b47cce
name: python-gast
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Python AST that abstracts the underlying Python version
url: https://github.com/serge-sans-paille/gast/
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ddc16c1-e6b5-4277-a43f-ba18d49d6e8e
location_href: 00009083-python-gast/python-gast-0.5.3-1.src.rpm
checksum_type: sha256
description:
  A generic AST to represent Python2 and Python3's Abstract Syntax Tree(AST).

  GAST provides a compatibility layer between the AST of various Python versions,
  as produced by ``ast.parse`` from the standard ``ast`` module.


pkgId: 2b53ed39ca254186b6cbffa659c8c4ac798fb45ffe236f889034487bfdb94262
name: python-gatspy
arch: src
version: 0.3
epoch: 0
release: 1
summary: General tools for Astronomical Time Series in Python
url: http://github.com/astroml/gatspy
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc9cfa8a-8c06-4528-af0d-9da4234865e4
location_href: 00003728-python-gatspy/python-gatspy-0.3-1.src.rpm
checksum_type: sha256
description:
  Gatspy (pronounced as F. Scott Fitzgerald might pronounce it) is a collection of tools for analyzing astronomical time series in Python.
  For more information, visit http://github.com/astroml/gatspy/


pkgId: 2af4b84f39011f308b1e042d7b2905807a4be508c946562290715d93c329217a
name: python-gax-google-pubsub-v1
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: DEPRECATED
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2bc43eba-49db-4639-a2ae-af7eb8c53ab5
location_href: 00011964-python-gax-google-pubsub-v1/python-gax-google-pubsub-v1-0.8.3-1.src.rpm
checksum_type: sha256
description:
  gax-google-pubsub-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Pubsub API`_ (v1) defined in the googleapis_ git repository


pkgId: 126fcd9d4734ba6ed18afd8b83aef2dc6985676259114c163e6854d95a754100
name: python-gccinvocation
arch: src
version: 0.1
epoch: 0
release: 1
summary: Library for parsing GCC command-line options
url: https://github.com/fedora-static-analysis/gccinvocation
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8a34c07c-f07d-4869-85d1-176207812dc1
location_href: 00003730-python-gccinvocation/python-gccinvocation-0.1-1.src.rpm
checksum_type: sha256
description:
  This is a Python module that can parse gcc command lines and extract
  data of interest e.g. include paths, defines, etc


pkgId: a52d683dcc422c5c44f529da05065e87271866b8ca52a58f4571687ba09f0e43
name: python-gcovr
arch: src
version: 6.0
epoch: 0
release: 1
summary: Generate C/C++ code coverage reports with gcov
url: https://gcovr.com
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5058234-b4fb-41c6-8c63-369b39aa7351
location_href: 00010931-python-gcovr/python-gcovr-6.0-1.src.rpm
checksum_type: sha256
description:
  generate GCC code coverage reports
  `website and documentation <website_>`__ • bugtracker_ • `GitHub <repo_>`__
  |GitHub-Actions-badge| |pypi-badge| |codecov-badge| |gitter-badge|
  Gcovr provides a utility for managing the use of the GNU gcov_ utility
  and generating summarized code coverage results. This command is
  inspired by the Python coverage.py_ package, which provides a similar
  utility for Python.
  The ``gcovr`` command can produce different kinds of coverage reports:
     * - CLI Option
       - User Guide
       - Description
     * - default, |abstract-option-txt|
       - |abstract-guide-txt|
       - compact human-readable summaries
     * - |abstract-option-html|
       - |abstract-guide-html|
       - overview of all files
     * - |abstract-option-html-details|
       - |abstract-guide-html-details|
       - annotated source files
     * - |abstract-option-cobertura|
       - |abstract-guide-cobertura|
       - machine readable XML reports in Cobertura_ format
     * - |abstract-option-sonarqube|
       - |abstract-guide-sonarqube|
       - machine readable XML reports in Sonarqube format
     * - |abstract-option-json|
       - |abstract-guide-json|
       - JSON report with source file structure and coverage
     * - |abstract-option-json-summary|
       - |abstract-guide-json-summary|
       - JSON summary coverage report
     * - |abstract-option-csv|
       - |abstract-guide-csv|
       - CSV report summarizing the coverage of each file
     * - |abstract-option-coveralls|
       - |abstract-guide-coveralls|
       - machine readable JSON report in Coveralls_ format
  Thus, gcovr can be viewed
  as a command-line alternative to the lcov_ utility, which runs gcov
  and generates an HTML-formatted report.
  The development of gcovr was motivated by the need for
  text summaries and XML reports.
  Example HTML summary:
  Example HTML details:


pkgId: d7f9e72ae2a64ad81d3905b249436e15b5cd7a297ecc022f1f8c32c4d2f1685c
name: python-gcs-oauth2-boto-plugin
arch: src
version: 3.0
epoch: 0
release: 1
url: https://developers.google.com/storage/docs/gspythonlibrary
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c107cc61-9ab2-4550-a055-ff84041bc4a1
location_href: 00010404-python-gcs-oauth2-boto-plugin/python-gcs-oauth2-boto-plugin-3.0-1.src.rpm
checksum_type: sha256
summary:
  Auth plugin allowing use the use of OAuth 2.0 credentials for Google Cloud Storage in the Boto library.

description:
  gcs-oauth2-boto-plugin is a Python application whose purpose is to behave as an
  auth plugin for the boto auth plugin framework for use with OAuth 2.0
  credentials for the Google Cloud Platform. This plugin is compatible with both
  user accounts and service accounts, and its functionality is essentially a
  wrapper around oauth2client with the addition of automatically caching tokens
  for the machine in a thread- and process-safe fashion.


pkgId: 9fbde3fcc6c6aec9ceca05a707ebf4c387faf3543cdfb0fbc566e6820b8e4c3c
name: python-gcsfs
arch: src
version: 2023.3.0
epoch: 0
release: 1
summary: Convenient Filesystem interface over GCS
url: https://github.com/fsspec/gcsfs
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dfd2673f-efd8-4742-bed6-f1f438613623
location_href: 00003731-python-gcsfs/python-gcsfs-2023.3.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Doc Status|
  Pythonic file-system for Google Cloud Storage
  For documentation, go to readthedocs_.


pkgId: 785ad3a5d40ff957617e72ee414054afd2397f3afa4cdaba825c453c185998fd
name: python-gdown
arch: src
version: 4.7.1
epoch: 0
release: 1
summary: Google Drive direct download of big files.
url: http://github.com/wkentaro/gdown
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b450aa5a-1ee7-4df9-9b8a-7b275b00f784
location_href: 00010671-python-gdown/python-gdown-4.7.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    gdown
  </h1>

  <h4 align="center">
    Download a large file from Google Drive.
  </h4>

  <div align="center">
    <a href="https://pypi.python.org/pypi/gdown"><img src="https://img.shields.io/pypi/v/gdown.svg"></a>
    <a href="https://pypi.org/project/gdown"><img src="https://img.shields.io/pypi/pyversions/gdown.svg"></a>
    <a href="https://github.com/wkentaro/gdown/actions"><img src="https://github.com/wkentaro/gdown/workflows/ci/badge.svg"></a>
  </div>

  <div align="center">
    <img src=".readme/cli.png" width="90%">
    <img src=".readme/python.png" width="90%">
  </div>

  <br/>




  Download a large file from Google Drive.
  If you use curl/wget, it fails with a large file because of
  the security warning from Google Drive.
  Supports downloading from Google Drive folders (max 50 files per folder).




  ```bash
  pip install gdown


  pip install --upgrade gdown
  ```






  ```bash
  $ gdown --help
  usage: gdown [-h] [-V] [-O OUTPUT] [-q] [--fuzzy] [--id] [--proxy PROXY]
               [--speed SPEED] [--no-cookies] [--no-check-certificate]
               [--continue] [--folder] [--remaining-ok]
               url_or_id
  ...

  $ # a large file (~500MB)
  $ gdown https://drive.google.com/uc?id=1l_5RK28JRL19wpT22B-DY9We3TVXnnQQ
  $ md5sum fcn8s_from_caffe.npz
  256c2a8235c1c65e62e48d3284fbd384

  $ # same as the above but with the file ID
  $ gdown 1l_5RK28JRL19wpT22B-DY9We3TVXnnQQ

  $ # a small file
  $ gdown https://drive.google.com/uc?id=0B9P1L--7Wd2vU3VUVlFnbTgtS2c
  $ cat spam.txt
  spam

  $ # download with fuzzy extraction of a file ID
  $ gdown --fuzzy 'https://drive.google.com/file/d/0B9P1L--7Wd2vU3VUVlFnbTgtS2c/view?usp=sharing&resourcekey=0-WWs_XOSctfaY_0-sJBKRSQ'
  $ cat spam.txt
  spam

  $ # --fuzzy option also works with Microsoft Powerpoint files
  $ gdown --fuzzy "https://docs.google.com/presentation/d/15umvZKlsJ3094HNg5S4vJsIhxcFlyTeK/edit?usp=sharing&ouid=117512221203072002113&rtpof=true&sd=true"

  $ # a folder
  $ gdown https://drive.google.com/drive/folders/15uNXeRBIhVvZJIhL4yTw4IsStMhUaaxl -O /tmp/folder --folder

  $ # as an alternative to curl/wget
  $ gdown https://httpbin.org/ip -O ip.json
  $ cat ip.json
  {
    "origin": "126.169.213.247"
  }

  $ # write stdout and pipe to extract
  $ gdown https://github.com/wkentaro/gdown/archive/refs/tags/v4.0.0.tar.gz -O - --quiet | tar zxvf -
  $ ls gdown-4.0.0/
  gdown  github2pypi  LICENSE  MANIFEST.in  pyproject.toml  README.md  setup.cfg  setup.py  tests
  ```



  ```python
  import gdown


  url = "https://drive.google.com/uc?id=1l_5RK28JRL19wpT22B-DY9We3TVXnnQQ"
  output = "fcn8s_from_caffe.npz"
  gdown.download(url, output, quiet=False)


  id = "0B9P1L--7Wd2vNm9zMTJWOGxobkU"
  gdown.download(id=id, output=output, quiet=False)


  url = "https://drive.google.com/file/d/0B9P1L--7Wd2vNm9zMTJWOGxobkU/view?usp=sharing"
  gdown.download(url=url, output=output, quiet=False, fuzzy=True)


  md5 = "fa837a88f0c40c513d975104edf3da17"
  gdown.cached_download(url, output, md5=md5, postprocess=gdown.extractall)


  url = "https://drive.google.com/drive/folders/15uNXeRBIhVvZJIhL4yTw4IsStMhUaaxl"
  gdown.download_folder(url, quiet=True, use_cookies=False)


  id = "15uNXeRBIhVvZJIhL4yTw4IsStMhUaaxl"
  gdown.download_folder(id=id, quiet=True, use_cookies=False)
  ```




  See [LICENSE](LICENSE).


pkgId: f8b81caae9b0176c9af61f7b1137e51b6a7d56b604832c3703321200c30aafaa
name: python-gearbox
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Command line toolkit born as a PasteScript replacement for the TurboGears2 web framework
url: https://github.com/TurboGears/gearbox
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0171199c-0d81-4d24-bc08-55017f9932c4
location_href: 00003736-python-gearbox/python-gearbox-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Gearbox is a paster command replacement for TurboGears2.
  It has been created during the process of providing Python3 support to the TurboGears2 web framework,
  while still being backward compatible with the existing TurboGears projects.
  Gearbox is based on a stripped down version of *Cliff* command line framework, you might want
  to consider `Cliff <http://docs.openstack.org/developer/cliff/>`_ for more advanced use cases
  and custom command interpreters.


pkgId: ff53da12a855c65d1b52626d9384c6764539b518ab26f7932fc2d086eacda6c8
name: python-gekitchen
arch: src
version: 0.2.20
epoch: 0
release: 1
summary: Python SDK for GE Kitchen Appliances
url: https://github.com/ajmarks/gekitchen
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-31dd394c-bef6-4559-88c6-f54bc50c68a5
location_href: 00003737-python-gekitchen/python-gekitchen-0.2.20-1.src.rpm
checksum_type: sha256
description:
  Python SDK for GE WiFi-enabled kitchen appliances.
  The primary goal is to use this to power integrations for [Home Assistant](https://www.home-assistant.io/), though that
  will probably need to wait on some new entity types.


  ```pip install gekitchen```



  Here we're going to run the client in a pre-existing event loop.  We're also going to register some event callbacks
  to update appliances every five minutes and to turn on our oven the first time we see it.  Because that is safe!
  ```python
  import aiohttp
  import asyncio
  import logging
  from gekitchen.secrets import USERNAME, PASSWORD
  from gekitchen import GeWebsocketClient

  _LOGGER = logging.getLogger(__name__)


  if __name__ == "__main__":
      logging.basicConfig(level=logging.DEBUG, format='-8s s')

      loop = asyncio.get_event_loop()
      client = GeWebsocketClient(loop, USERNAME, PASSWORD)

      session = aiohttp.ClientSession()
      asyncio.ensure_future(client.async_get_credentials_and_run(session), loop=loop)
      loop.run_until_complete(asyncio.sleep(60))

      for appliance in client.appliances:
          print(appliance)
  ```


  The authentication process has a few steps.  First, for both the websocket and XMPP APIs, we use Oauth2 to authenticate
  to the HTTPS API.  From there, we can either get a websocket endpoint with `access_token` or proceed with the XMPP login
  flow.  For XMPP, we get a mobile device token, which in turn be used to get a new `Bearer` token, which, finally,
  is used to get XMPP credentials to authenticate to the Jabber server.  In `gekitchen`, going from username/password
  to XMPP credentials is handled by `do_full_xmpp_flow(username, password)`.



  Function to authenticate to the web API and get XMPP credentials.  Returns a `dict` of XMPP credentials

  Function to authenticate to the web API and get websocket credentials.  Returns a `dict` of WSS credentials



  Main Websocket client
   * `event_loop: asyncio.AbstractEventLoop` Optional event loop.  If `None`, the client will use `asyncio.get_event_loop()`
   * `username`/`password` Optional strings to use when authenticating

   * `async_get_credentials(session, username=None, password=None)` Get new WSS credentials using either the specified
   `username` and `password` or ones already set in the constructor.
   * `get_credentials(username=None, password=None)` Blocking version of the above
   * `add_event_handler(event, callback)` Add an event handler
   * `disconnect()` Disconnect the client
   * `async_run_client()` Run the client
   * `async_get_credentials_and_run(sessions, username=None, password=None)` Authenticate and run the client

   * `appliances` A `Dict[str, GeAppliance]` of all known appliances keyed on the appliances' JIDs.

  * `EVENT_ADD_APPLIANCE` - Triggered immediately after a new appliance is added, before the initial update request has
  even been sent. The `GeAppliance` object is passed to the callback.
  * `EVENT_APPLIANCE_INITIAL_UPDATE` - Triggered when an appliance's type changes, at which point we know at least a
  little about the appliance. The `GeAppliance` object is passed to the callback.
  * `EVENT_APPLIANCE_STATE_CHANGE` - Triggered when an appliance message with a new state, different from the existing, cached
  state is received.  A tuple `(appliance, state_changes)` is passed to the callback, where `appliance` is the
  `GeAppliance` object with the updated state and `state_changes` is a dictionary `{erd_key: new_value}` of the changed
  state.
  * `EVENT_APPLIANCE_UPDATE_RECEIVED` - Triggered after processing an ERD update message whether or not the state changed
  * `EVENT_CONNECTED` - Triggered when the API connects, after adding basic subscriptions
  * `EVENT_DISCONNECTED` - Triggered when the API disconnects
  * `EVENT_GOT_APPLIANCE_LIST` - Triggered when we get the list of appliances


  Main XMPP client, and a subclass of `slixmpp.ClientXMPP`.
   * `xmpp_credentials: dict` A dictionary of XMPP credentials, usually obtained from either `do_full_login_flow` or, in a
   more manual process, `get_xmpp_credentials`
   * `event_loop: asyncio.AbstractEventLoop` Optional event loop.  If `None`, the client will use `asyncio.get_event_loop()`
   * `**kwargs` Passed to `slixmpp.ClientXMPP`

   * `connect()` Connect to the XMPP server
   * `process_in_running_loop(timeout: Optional[int] = None)` Run in an existing event loop.  If `timeout` is given, stop
   running after `timeout` seconds
   * `add_event_handler(name: str, func: Callable)` Add an event handler.  In addition to the events supported by
   `slixmpp.ClientXMPP`, we've added some more event types detailed below.

   * `appliances` A `Dict[str, GeAppliance]` of all known appliances keyed on the appliances' JIDs.

  In addition to the standard `slixmpp` events, the `GeClient` object has support for the following:
  * `EVENT_ADD_APPLIANCE` - Triggered immediately after a new appliance is added, before the initial update request has
  even been sent. The `GeAppliance` object is passed to the callback.
  * `EVENT_APPLIANCE_INITIAL_UPDATE` - Triggered when an appliance's type changes, at which point we know at least a
  little about the appliance. The `GeAppliance` object is passed to the callback.
  * `EVENT_APPLIANCE_STATE_CHANGE` - Triggered when an appliance message with a new state, different from the existing, cached
  state is received.  A tuple `(appliance, state_changes)` is passed to the callback, where `appliance` is the
  `GeAppliance` object with the updated state and `state_changes` is a dictionary `{erd_key: new_value}` of the changed
  state.


  Representation of a single appliance
   * `mac_addr: Union[str, slixmpp.JID]` The appliance's MAC address, which is what GE uses as unique identifiers
   * `client: GeBaseClient` The client used to communicate with the device

   * `decode_erd_value(erd_code: ErdCodeType, erd_value: str)` Decode a raw ERD property value.
   * `encode_erd_value(erd_code: ErdCodeType, erd_value: str)` Decode a raw ERD property value.
   * `get_erd_value(erd_code: ErdCodeType)` Get the cached value of ERD code `erd_code`.  If `erd_code` is a string, this
   function will attempt to convert it to an `ErdCode` object first.
   * `async_request_update()` Request the appliance send an update of all properties
   * `set_available()` Mark the appliance as available
   * `async_set_erd_value(erd_code: ErdType, value)` Tell the device to set the property represented by `erd_code` to `value`
   * `set_unavailable()` Mark the appliance as unavailable
   * `update_erd_value(erd_code: ErdType, value)` Update the local property cache value for `erd_code` to `value`, where
   value is the not yet decoded hex string sent from the API. Returns `True` if that is a change in state, `False` otherwise.
   * `update_erd_values(self, erd_values: Dict[ErdCodeType, str])` Update multiple values in the local property cache.
   Returns a dictionary of changed states or an empty `dict` if nothing actually changed.

   * `appliance_type: Optional[ErdApplianceType]` The type of appliance, `None` if unknown
   * `available: bool` `True` if the appliance is available, otherwise `False`
   * `mac_addr` The appliance's MAC address (used as the appliance ID)



  * `ErdCode` `Enum` of known ERD property codes
  * `ErdApplianceType` Values for `ErdCode.APPLIANCE_TYPE`
  * `ErdMeasurementUnits` Values for `ErdCode.TEMPERATURE_UNIT`
  * `ErdOvenCookMode` Possible oven cook modes, used for `OvenCookSetting` among other things
  * `ErdOvenState` Values for `ErdCode.LOWER_OVEN_CURRENT_STATE` and `ErdCode.UPPER_OVEN_CURRENT_STATE`


  * `OvenCookSetting` A `namedtuple` of an `ErdOvenCookMode` and an `int` temperature
  * `OvenConfiguration` A `namedtuple` of boolean properties representing an oven's physical configuration





  The GE SmartHQ app communicates with devices through (at least) three different APIs: XMPP, HTTP REST, and what they
  seem to call MQTT (though that's not really accurate).  All of them are based around sending (pseudo-)HTTP requests
  back and forth.  Device properties are represented by hex codes (represented by `ErdCode` objects in `gekitchen`), and
  values are sent as hexadecimal strings without leading `"0x"`, then json encoded as a dictionary.  One thing that is
  important to note is that not all appliances support every API.

  1. REST - We can access or set most device properties via HTTP REST.  Unfortunately, relying on this means we need to
   result to constantly polling the devices, which is less than desirable, especially, e.g., for ovens that where we want
   to know exactly when a timer finishes. This API is not directly supported.
  2. Websocket "MQTT" - The WSS "MQTT" API is basically a wrapper around the REST API with the ability to subscribe to a
   device, meaning that we can treat it as (in Home Assistant lingo) IoT Cloud Push instead of IoT Cloud Polling.  In
   `gekitchen`, support for the websocket API is provided by the `GeWebsocketClient` class.
  2. XMPP - As far as I can tell, there seems to be little, if any, benefit to the XMPP API except that it will notify
   the client if a new device becomes available.  I suspect that this can be achieved with websocket API as well via
   subscriptions, but have not yet tested.  Support for the XMPP API is provided by the `GeXmppClient` class, based on
    [`slixmpp`](https://slixmpp.readthedocs.io/), which it requires as an optional dependency.


  The device informs the client of a state change by sending a `PUBLISH` message like this, informing us that the value of
  property 0x5205 (`ErdCode.LOWER_OVEN_KITCHEN_TIMER` in `gekitchen`) is now "002d" (45 minutes):

  ```xml
  <body>
      <publish>
          <method>PUBLISH</method>
          <uri>/UUID/erd/0x5205</uri>
          <json>{"0x5205":"002d"}</json>
      </publish>
  </body>
  ```

  Similarly, we can set the timer to 45 minutes by `POST`ing to the same "endpoint":
  ```xml
  <body>
      <request>
          <method>POST</method>
          <uri>/UUID/erd/0x5205</uri>
          <json>{"0x5205":"002d"}</json>
      </request>
  </body>
  ```
  In `gekitchen`, that would handled by the `GeAppliance.set_erd_value` method:
  ```python
  appliance.async_set_erd_value(ErdCode.LOWER_OVEN_KITCHEN_TIMER, timedelta(minutes=45))
  ```

  We can also get a specific property, or, more commonly, request a full cache refresh by `GET`ing the `/UUID/cache`
  endpoint:

  ```xml
  <body>
      <request>
          <id>0</id>
          <method>GET</method>
          <uri>/UUID/cache</uri>
      </request>
  </body>
  ```

  The device will then respond to the `GET` with a `response` having a json payload:
  ```xml
  <body>
      <response>
          <id>0</id>
          <method>GET</method>
          <uri>/UUID/cache</uri>
          <json>{
              "0x0006":"00",
              "0x0007":"00",
              "0x0008":"07",
              "0x0009":"00",
              "0x000a":"03",
              "0x0089":"",
              ...
          }</json>
      </response>
  </body>
  ```


pkgId: 7ca82d5f8b75ec8956c80544ca45e272089030b5400407f32ac6cbd501f235b4
name: python-geocoder
arch: src
version: 1.38.1
epoch: 0
release: 1
summary: Geocoder is a simple and consistent geocoding library.
url: https://github.com/DenisCarriere/geocoder
rpm_license: The MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-566b5ab2-3177-462c-b757-2c9ff77ce3ed
location_href: 00009321-python-geocoder/python-geocoder-1.38.1-1.src.rpm
checksum_type: sha256
description:
  <!-- TOC -->
  - [Overview](#overview)
  - [A glimpse at the API](#a-glimpse-at-the-api)
      - [Forward](#forward)
      - [Multiple results](#multiple-results)
      - [Reverse](#reverse)
      - [House Addresses](#house-addresses)
      - [IP Addresses](#ip-addresses)
      - [Bounding Box](#bounding-box)
  - [Command Line Interface](#command-line-interface)
  - [Providers](#providers)
  - [Installation](#installation)
      - [PyPi Install](#pypi-install)
      - [GitHub Install](#github-install)
      - [Snap Install](#snap-install)
  - [Feedback](#feedback)
  - [Contribution](#contribution)
      - [Documenting](#documenting)
      - [Coding](#coding)
  - [ChangeLog](#changelog)
  <!-- /TOC -->

  Many online providers such as Google & Bing have geocoding services,
  these providers do not include Python libraries and have different
  JSON responses between each other.
  It can be very difficult sometimes to parse a particular geocoding provider
  since each one of them have their own JSON schema.
  Here is a typical example of retrieving a Lat & Lng from Google using Python,
  things shouldn't be this hard.
  ```python
  >>> import requests
  >>> url = 'https://maps.googleapis.com/maps/api/geocode/json'
  >>> params = {'sensor': 'false', 'address': 'Mountain View, CA'}
  >>> r = requests.get(url, params=params)
  >>> results = r.json()['results']
  >>> location = results[0]['geometry']['location']
  >>> location['lat'], location['lng']
  (37.3860517, -122.0838511)
  ```
  Now lets use Geocoder to do the same task
  ```python
  >>> import geocoder
  >>> g = geocoder.google('Mountain View, CA')
  >>> g.latlng
  (37.3860517, -122.0838511)
  ```

  Many properties are available once the geocoder object is created.

  ```python
  >>> import geocoder
  >>> g = geocoder.google('Mountain View, CA')
  >>> g.geojson
  >>> g.json
  >>> g.wkt
  >>> g.osm
  ```

  ```python
  >>> import geocoder
  >>> g = geocoder.mapquest(['Mountain View, CA', 'Boulder, Co'], method='batch')
  >>> for result in g:
  ('Mountain View', [37.39008, -122.08139])
  ('Boulder', [40.015831, -105.27927])
  ```

  ```python
  >>> import geocoder
  >>> g = geocoder.geonames('Mountain View, CA', maxRows=5)
  >>> print(len(g))
  5
  >>> for result in g:
  Mountain View ['37.38605', '-122.08385']
  Mountain View Elementary School ['34.0271', '-117.59116']
  Best Western Plus Mountainview Inn and Suites ['51.79516', '-114.62793']
  Best Western Mountainview Inn ['49.3338', '-123.1446']
  Mountain View Post Office ['37.393', '-122.07774']
  ```
  > The providers currently supporting multiple results are listed in the table [below](#providers).

  ```python
  >>> g = geocoder.google([45.15, -75.14], method='reverse')
  >>> g.city
  >>> g.state
  >>> g.state_long
  >>> g.country
  >>> g.country_long
  ```

  ```python
  >>> g = geocoder.google("453 Booth Street, Ottawa ON")
  >>> g.housenumber
  >>> g.postal
  >>> g.street
  >>> g.street_long
  ```

  ```python
  >>> g = geocoder.ip('199.7.157.0')
  >>> g = geocoder.ip('me')
  >>> g.latlng
  >>> g.city
  ```

  Accessing the JSON & GeoJSON attributes will be different
  ```python
  >>> g = geocoder.google("Ottawa")
  >>> g.bbox
  {"northeast": [45.53453, -75.2465979], "southwest": [44.962733, -76.3539158]}
  >>> g.geojson['bbox']
  [-76.3539158, 44.962733, -75.2465979, 45.53453]
  >>> g.southwest
  [44.962733, -76.3539158]
  ```

  ```bash
  $ geocode "Ottawa, ON"  >> ottawa.geojson
  $ geocode "Ottawa, ON" \
      --provide google \
      --out geojson \
      --method geocode
  ```

  | Provider                       | Optimal   | Usage Policy                    | Multiple results | Reverse | Proximity | Batch |
  |:-------------------------------|:----------|:--------------------------------|:-----------------|:--------|:----------|:------|
  | [ArcGIS][ArcGIS]               | World     |                                 | yes              | yes     |           |       |
  | [Baidu][Baidu]                 | China     | API key                         |                  | yes     |           |       |
  | [Bing][Bing]                   | World     | API key                         | yes              | yes     |           | yes   |
  | [CanadaPost][CanadaPost]       | Canada    | API key                         | yes              |         |           |       |
  | [FreeGeoIP][FreeGeoIP]         | World     |                                 |                  |         |           |       |
  | [Gaode][Gaode]                 | China     | API key                         |                  | yes     |           |       |
  | [Geocoder.ca][Geocoder.ca] (Geolytica) | CA & US | Rate Limit                |                  |         |           |       |
  | [GeocodeFarm][GeocodeFarm]     | World     | [Policy][GeocodeFarm-Policy]    | yes              | yes     |           |       |
  | [GeoNames][GeoNames]           | World     | Username                        | yes              |         | yes       |       |
  | [GeoOttawa][GeoOttawa]         | Ottawa    |                                 | yes              |         |           |       |
  | [Gisgraphy][Gisgraphy]         | World     | API key                         | yes              | yes     | yes       |       |
  | [Google][Google]               | World     | Rate Limit, [Policy][G-Policy]  | yes              | yes     | yes       |       |
  | [HERE][HERE]                   | World     | API key                         | yes              | yes     |           |       |
  | [IPInfo][IPInfo]               | World     | Rate Limit, [Plans][IP-Plans]   |                  |         |           |       |
  | [Komoot][Komoot] (OSM powered) | World     |                                 | yes              | yes     |           |       |
  | [LocationIQ][LocationIQ]       | World     | API Key                         | yes              | yes     |           |       |
  | [Mapbox][Mapbox]               | World     | API key                         | yes              | yes     | yes       |       |
  | [MapQuest][MapQuest]           | World     | API key                         | yes              | yes     |           | yes   |
  | [~~Mapzen~~][Mapzen]           | Shutdown  | API key                         | yes              | yes     |           |       |
  | [MaxMind][MaxMind]             | World     |                                 |                  |         |           |       |
  | [OpenCage][OpenCage]           | World     | API key                         | yes              | yes     |           |       |
  | [OpenStreetMap][OpenStreetMap] | World     | [Policy][OpenStreetMap-Policy]  | yes              | yes     |           |       |
  | [Tamu][Tamu]                   | US        | API key                         |                  |         |           |       |
  | [TGOS][TGOS]                   | Taiwan    |                                 |                  |         |           |       |
  | [TomTom][TomTom]               | World     | API key                         | yes              |         |           |       |
  | [USCensus][USCensus]           | US        |                                 |                  | yes     |           | yes   |
  | [What3Words][What3Words]       | World     | API key                         |                  | yes     |           |       |
  | [Yahoo][Yahoo]                 | World     |                                 |                  |         |           |       |
  | [Yandex][Yandex]               | Russia    |                                 | yes              | yes     |           |       |


  To install Geocoder, simply:
  ```bash
  $ pip install geocoder
  ```

  Installing the latest version from Github:
  ```bash
  $ git clone https://github.com/DenisCarriere/geocoder
  $ cd geocoder
  $ python setup.py install
  ```

  To install the stable geocoder [snap](https://snapcraft.io) in any of the [supported Linux distros](https://snapcraft.io/docs/core/install):
  ```bash
  $ sudo snap install geocoder
  ```
  If you want to help testing the latest changes from the master branch, you can install it from the edge channel:
  ```bash
  $ sudo snap install geocoder --edge
  ```
  The installed snap will be updated automatically every time a new version is pushed to the store.

  Please feel free to give any feedback on this module.
  Speak up on Twitter [@DenisCarriere](https://twitter.com/DenisCarriere) and tell me how you use this Python Geocoder. New updates will be pushed to Twitter Hashtags [#python](https://twitter.com/search?q=%23python).

  If you find any bugs or any enhancements to recommend please send some of your comments/suggestions to the [Github Issues Page](https://github.com/DenisCarriere/geocoder/issues).
  Some way to contribute, from the most generic to the most detailed:

  If you are not comfortable with development, you can still contibute with the documentation.
  - review the documentation of a specific provider. Most of the time they are lacking details...
  - review the parameters for a specific method, compared to what is supported by the provider
  - review documentation for command line
  If you miss any feature, just create an issue accordingly. Be sure to describe clearly your use case, and to provide links to the correct sources.

  - add support for a new provider. _Documentation TBD_, starting point possible with [wip_guide](https://geocoder.readthedocs.io/wip_guide.html).
  - extend methods for an existing support, i.e support an additionnal API). _Documentation TBD_
  - extend support of an existing API, i.e, support more (json) fields from the response, or more parameters. _Documentation TBD_

  See [CHANGELOG.md](./CHANGELOG.md)
  [TGOS]: http://geocoder.readthedocs.org/providers/TGOS.html
  [Mapbox]: http://geocoder.readthedocs.org/providers/Mapbox.html
  [Google]: http://geocoder.readthedocs.org/providers/Google.html
  [G-Policy]: https://developers.google.com/maps/documentation/geocoding/usage-limits
  [Bing]: http://geocoder.readthedocs.org/providers/Bing.html
  [LocationIQ]: http://geocoder.readthedocs.org/providers/LocationIQ.html
  [OpenStreetMap]: http://geocoder.readthedocs.org/providers/OpenStreetMap.html
  [OpenStreetMap-Policy]: https://operations.osmfoundation.org/policies/nominatim/
  [HERE]: http://geocoder.readthedocs.org/providers/HERE.html
  [TomTom]: http://geocoder.readthedocs.org/providers/TomTom.html
  [MapQuest]: http://geocoder.readthedocs.org/providers/MapQuest.html
  [OpenCage]: http://geocoder.readthedocs.org/providers/OpenCage.html
  [Yahoo]: http://geocoder.readthedocs.org/providers/Yahoo.html
  [ArcGIS]: http://geocoder.readthedocs.org/providers/ArcGIS.html
  [Yandex]: http://geocoder.readthedocs.org/providers/Yandex.html
  [Geocoder.ca]: http://geocoder.readthedocs.org/providers/Geocoder-ca.html
  [Baidu]: http://geocoder.readthedocs.org/providers/Baidu.html
  [GeoOttawa]: http://geocoder.readthedocs.org/providers/GeoOttawa.html
  [FreeGeoIP]: http://geocoder.readthedocs.org/providers/FreeGeoIP.html
  [MaxMind]: http://geocoder.readthedocs.org/providers/MaxMind.html
  [Mapzen]: https://mapzen.com/blog/shutdown
  [What3Words]: http://geocoder.readthedocs.org/providers/What3Words.html
  [CanadaPost]: http://geocoder.readthedocs.org/providers/CanadaPost.html
  [GeoNames]: http://geocoder.readthedocs.org/providers/GeoNames.html
  [IPInfo]: http://geocoder.readthedocs.org/providers/IPInfo.html
  [Tamu]: http://geoservices.tamu.edu/Services/Geocode/WebService/
  [GeocodeFarm]: https://geocode.farm/
  [GeocodeFarm-Policy]: https://geocode.farm/geocoding/free-api-documentation/
  [Gaode]: http://geocoder.readthedocs.org/providers/.html
  [IP-Plans]: http://ipinfo.io/pricing
  [Komoot]: http://photon.komoot.de
  [USCensus]: https://geocoding.geo.census.gov/geocoder/Geocoding_Services_API.html
  [Gisgraphy]: https://premium.gisgraphy.com/


pkgId: a78072c2cda5cebbf66cfe1f3ed8f6ef796be1efba355bb8bb9c225d6053b6b0
name: python-geog
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Numpy-based vectorized geospatial functions
url: https://github.com/jwass/geog
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc8316d7-db6e-4f3d-80a3-58119fb54fd1
location_href: 00012875-python-geog/python-geog-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A pure numpy implementation for geodesic functions. The interfaces are
  vectorized according to numpy broadcasting rules compatible with a variety of
  inputs including lists, numpy arrays, and
  [Shapely](http://toblerity.org/shapely/) geometries - allowing for 1-to-1,
  N-to-1, or the element-wise N-to-N calculations in a single call.
  `geog` uses a spherical Earth model (subject to change) with radius 6371.0 km.
  `geog` draws inspiration from [TurfJS](https://www.turfjs.org)


pkgId: 7a360dd919428fed890638620103cd1414a03b363666cb91d97c8d638809f72e
name: python-geographiclib
arch: src
version: 2.0
epoch: 0
release: 1
summary: The geodesic routines from GeographicLib
url: https://geographiclib.sourceforge.io/Python/2.0
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e4613f6-b833-4dcd-8b8d-b2b6b62556c0
location_href: 00002849-python-GeographicLib/python-geographiclib-2.0-1.src.rpm
checksum_type: sha256
description:
  This is a library to solve geodesic problems on an ellipsoid model of
  the earth.

  Licensed under the MIT/X11 License; see
  [LICENSE.txt](https://geographiclib.sourceforge.io/LICENSE.txt).

  The algorithms are documented in

  * C. F. F. Karney,
    [Algorithms for geodesics](https://doi.org/10.1007/s00190-012-0578-z),
    J. Geodesy **87**(1), 43–55 (2013);
    [Addenda](https://geographiclib.sourceforge.io/geod-addenda.html).

  The documentation for this package is in
  https://geographiclib.sourceforge.io/Python/doc


pkgId: 8e9e231672ba69d236c8caf31a82120ba298c0eb8d37e9e717f9f8315cabc548
name: python-geohash2
arch: src
version: 1.1
epoch: 0
release: 1
url: https://github.com/dbarthe/geohash/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a71a7061-6460-4edc-8e59-4deac920501b
location_href: 00011241-python-geohash2/python-geohash2-1.1-1.src.rpm
checksum_type: sha256
summary:
  (Geohash fixed for python3) Module to decode/encode Geohashes to/from latitude and longitude.  See http://en.wikipedia.org/wiki/Geohash

description:
  This module provides functions to decode and encode Geohashes to and from latitude and longitude coordinates.

rpm_license:
  GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.


pkgId: ae243cd37c1a8616f4337cd3edcd5330a2ab2c943ddda382931c843d6dfb025d
name: python-geojson
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Python bindings and utilities for GeoJSON
url: https://github.com/jazzband/geojson
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df6d5196-ab79-42ee-90c1-a6e2965e4f2a
location_href: 00003743-python-geojson/python-geojson-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This Python library contains:
  - Functions for encoding and decoding GeoJSON_ formatted data
  - Classes for all GeoJSON Objects
  - An implementation of the Python `__geo_interface__ Specification`_
  **Table of Contents**


pkgId: 497fc188a2d5d2a56cbf6daa6ff2da52df7b5b5ec5deb068bc973f8edf796900
name: python-geolib
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: A library for geohash encoding, decoding and associated functions
url: https://github.com/joyanujoy/geolib
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0438aad9-fd41-41f8-90ef-218d1a5716a4
location_href: 00014093-python-geolib/python-geolib-1.0.7-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/joyanujoy/geolib.svg?branch=master)](https://travis-ci.org/joyanujoy/geolib) ![python 2.7|3.4|3.5|3.6|3.7](https://img.shields.io/badge/python-2.7|3.4|3.5|3.6|3.7-blue.svg)[![Downloads](https://pepy.tech/badge/geolib)](https://pepy.tech/project/geolib)


  A python library for geohash encoding, decoding and finding neighbour cells. This is a python port of [Chris Veness' javascript implementation](https://www.movable-type.co.uk/scripts/geohash.html).

  [Wikipedia reference](http://en.wikipedia.org/wiki/Geohash)

  ```pipenv install geolib```
  or
  ```pip install geolib```


      from geolib import geohash
     
      geohash.encode(latitude, longitude, precision)
      >>> geohash.encode('70.2995', '-27.9993', 7)
      >>> gkkpfve

     
      geohash.decode(geohash), returns latitude, longitude as tuple of decimals
      >>> geohash.decode('gkkpfve')
      >>> (70.2995, -27.9993)

     
      geohash.neighbours(geohash)
      retuns a namedtuple (n, ne, e, se, s, sw, w, nw)

      >>> neighbours = geohash.neighbours('gcpuyph')
      >>> neighbours
      >>> ('gcpuypk', 'gcpuypm', 'gcpuypj', 'gcpuynv', 'gcpuynu', 'gcpuyng', 'gcpuyp5', 'gcpuyp7')
      >>> neighbours.ne
      >>> gcpuypm

     
      geohash.adjacent(geohash, direction)
      >>> geohash.adjacent('gcpuyph', 'n')
      >>> gcpuypk

     
      geohash.bounds(geohash)
      returns a namedtuple ((sw_lat, sw_lon), ((ne_lat, ne_lon))
      >>> bounds = geohash.bounds('ezs42')
      >>> bounds
      >>> ((42.583, -5.625), (42.627, -5.58)))
      >>> bounds.sw.lat
      >>> 42.583


     [Geolib readthedocs](https://geolib.readthedocs.io/en/latest/)


pkgId: d26e871a9edf9e5ceefb891ca7242a684241adc8c806917acd60b1b9ebf979e7
name: python-geomet
arch: src
version: 1.0.0
epoch: 0
release: 1
description:
  GeoMet

  Convert GeoJSON to WKT/WKB (Well-Known Text/Binary), and vice versa.

url: https://github.com/geomet/geomet
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c646974-25fd-4012-9bbf-c3262b280cf2
location_href: 00003744-python-geomet/python-geomet-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Conversion library for common geospatial data formats (GeoJSON/WKT/EWKT/WKB/EWKB/GeoPackage/EsriJson)


pkgId: 8bd5fd91dfb43c6551a77b816ed2a7745cead59781e54987412d1472b9a3c19e
name: python-geopandas
arch: src
version: 0.12.2
epoch: 0
release: 1
summary: Geographic pandas extensions
url: http://geopandas.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fb35b4d5-821b-4f44-8c95-eb3185488137
location_href: 00003745-python-geopandas/python-geopandas-0.12.2-1.src.rpm
checksum_type: sha256
description:
  GeoPandas is a project to add support for geographic data to
  `pandas`_ objects.

  The goal of GeoPandas is to make working with geospatial data in
  python easier. It combines the capabilities of `pandas`_ and `shapely`_,
  providing geospatial operations in pandas and a high-level interface
  to multiple geometries to shapely. GeoPandas enables you to easily do
  operations in python that would otherwise require a spatial database
  such as PostGIS.

  .. _pandas: http://pandas.pydata.org
  .. _shapely: http://shapely.readthedocs.io/en/latest/


pkgId: a9f726cb1b39d8d525e76638c1ebebbcc8ec26ccdc0a6692870ff893ce241955
name: python-geopy
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Python Geocoding Toolbox
url: https://github.com/geopy/geopy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-213fff94-76e6-4c02-a097-c64da1f6969c
location_href: 00003747-python-geopy/python-geopy-2.3.0-1.src.rpm
checksum_type: sha256
description:
  geopy is a Python client for several popular geocoding web
  services.
  geopy makes it easy for Python developers to locate the coordinates of
  addresses, cities, countries, and landmarks across the globe using
  third-party geocoders and other data sources.
  geopy includes geocoder classes for the `OpenStreetMap Nominatim`_,
  `Google Geocoding API (V3)`_, and many other geocoding services.
  The full list is available on the `Geocoders doc section`_.
  Geocoder classes are located in `geopy.geocoders`_.
  geopy is tested against CPython (versions 3.7, 3.8, 3.9, 3.10, 3.11)
  and PyPy3. geopy 1.x line also supported CPython 2.7, 3.4 and PyPy2.
  © geopy contributors 2006-2018 (see AUTHORS) under the `MIT
  License <https://github.com/geopy/geopy/blob/master/LICENSE>`__.


pkgId: f891a3cd342b800f9fb9ab2ec63217a81a473d31efd2a642faaca07ce0a3f547
name: python-geospark
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: GeoSpark Python
url: https://github.com/DataSystemsLab/GeoSpark/tree/master/python
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f3f0d9d-986a-4d77-9980-52f82149c19f
location_href: 00012083-python-geospark/python-geospark-1.3.1-1.src.rpm
checksum_type: sha256
description:
  This library is Python wrapper on GeoSpark library.

  GeoSpark is a cluster computing system for processing large-scale spatial data. GeoSpark extends Apache Spark / SparkSQL with a set of out-of-the-box Spatial Resilient Distributed Datasets (SRDDs)/ SpatialSQL that efficiently load, process, and analyze large-scale spatial data across machines.

  Python version supports:
  <li> GeoSpark core </li>
  <li> GeoSpark SQL </li>

  Please follow tutorial on official GeoSpark website:
  https://datasystemslab.github.io/GeoSpark/


pkgId: 135bb1f9d745b61c3a3d82829d86d7b7d7bd436ac966dfdd277302c8f0998f34
name: python-gerritlib
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Client library for accessing Gerrit.
url: https://opendev.org/opendev/gerritlib
rpm_license: apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d7469c72-9314-427a-8b77-0f507cd50eea
location_href: 00003748-python-gerritlib/python-gerritlib-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Gerritlib is a Python library for interacting with Gerrit_.
  It aims to provide a more conventionally pythonic way of managing a
  Gerrit instance.
  To install::
      $ sudo python setup.py install
  Online documentation:
  * http://gerritlib.readthedocs.org/en/latest/


pkgId: 6934980ff99fad4a52b0a71cfbf49ebaa375f4cddbdc8922e46474ce6cc64337
name: python-gerrymander
arch: src
version: 1.5
epoch: 0
release: 1
summary: A client API and command line tool for gerrit
url: https://github.com/berrange/gerrymander
rpm_license: ASL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2ef7892a-42df-4e77-9881-44eb00683511
location_href: 00003749-python-gerrymander/python-gerrymander-1.5-1.src.rpm
checksum_type: sha256
description:
  Gerrymander provides a set of APIs and command line tool for interacting with the gerrit code review system


pkgId: 8ade35eeb6614c764127b265d4111fddc464c1433232f9d387637268feebbd94
name: python-gertty
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Gertty is a console-based interface to the Gerrit Code Review system.
url: http://ttygroup.org/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d36a7469-7032-4952-a6d9-20c474a0b78d
location_href: 00003750-python-gertty/python-gertty-1.6.0-1.src.rpm
checksum_type: sha256
description:
  Gertty is a console-based interface to the Gerrit Code Review system.
  As compared to the web interface, the main advantages are:
   * Workflow -- the interface is designed to support a workflow similar
     to reading network news or mail.  In particular, it is designed to
     deal with a large number of review requests across a large number
     of projects.
   * Offline Use -- Gertty syncs information about changes in subscribed
     projects to a local database and local git repos.  All review
     operations are performed against that database and then synced back
     to Gerrit.
   * Speed -- user actions modify locally cached content and need not
     wait for server interaction.
   * Convenience -- because Gertty downloads all changes to local git
     repos, a single command instructs it to checkout a change into that
     repo for detailed examination or testing of larger changes.


pkgId: 0933864e1f34de1c6299ecfff576885a5e1278bbee1ec42c59d2ef40ac33a054
name: python-getmac
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Get MAC addresses of remote hosts and local interfaces
url: https://github.com/GhostofGoes/getmac
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b6733fd1-51e1-4afa-9be5-46111da0865a
location_href: 00003751-python-getmac/python-getmac-0.9.2-1.src.rpm
checksum_type: sha256
description:
  [![Latest version on PyPI](https://badge.fury.io/py/getmac.svg)](https://pypi.org/project/getmac/)
  [![Coverage Status](https://coveralls.io/repos/github/GhostofGoes/getmac/badge.svg?branch=main)](https://coveralls.io/github/GhostofGoes/getmac?branch=main)
  [![GitHub Actions Pipeline Status](https://github.com/ghostofgoes/getmac/actions/workflows/ci.yml/badge.svg)](https://github.com/GhostofGoes/getmac/actions)
  [![Weekly PyPI downloads](https://pepy.tech/badge/getmac/week)](https://pepy.tech/project/getmac)
  [![PyPI downloads](https://pepy.tech/badge/getmac)](https://pepy.tech/project/getmac)
  [![PyPI downloadss of the old name](https://pepy.tech/badge/get-mac)](https://pepy.tech/project/get-mac)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  Pure-Python package to get the MAC address of network interfaces and hosts on the local network.

  It provides a platform-independent interface to get the MAC addresses of:

  - System network interfaces (by interface name)
  - Remote hosts on the local network (by IPv4/IPv6 address or hostname)

  It provides one function: `get_mac_address()`

  [![asciicast](https://asciinema.org/a/rk6dUACUcZY18taCuIBE5Ssus.png)](https://asciinema.org/a/rk6dUACUcZY18taCuIBE5Ssus)

  [![asciicast](https://asciinema.org/a/n3insrxfyECch6wxtJEl3LHfv.png)](https://asciinema.org/a/n3insrxfyECch6wxtJEl3LHfv)



  If you only need the addresses of network interfaces, have a limited set of platforms to support, and are able to handle C-extension modules, then you should instead check out the excellent [netifaces](https://pypi.org/project/netifaces/) package by Alastair Houghton ([@al45tair](https://github.com/al45tair)). It's significantly faster (thanks to it being C-code) and has been around a long time and seen widespread usage. However, unfortunately it is no longer maintained as of [May 2021](https://github.com/al45tair/netifaces/commit/ec55b59e27542776f55e0f9e3213a75bf8e0f367), so it may not be a great choice for new projects. Another great option that fits these requirements is the well-known and battle-hardened [psutil](https://github.com/giampaolo/psutil) package by Giampaolo Rodola.

  If the only system you need to run on is Linux, you can run as root, and C-extensions modules are fine, then you should instead check out the [arpreq](https://pypi.org/project/arpreq/) package by Sebastian Schrader. In some cases it can be significantly faster.

  If you want to use `psutil`, `scapy`, or `netifaces`, I have examples of how to do so in a [GitHub Gist](https://gist.github.com/GhostofGoes/0a8e82930e75afcefbd879a825ba4c26).


  Stable release from PyPI

  ```bash
  pip install getmac
  ```

  Latest development version

  ```bash
  pip install https://github.com/ghostofgoes/getmac/archive/main.tar.gz
  ```


  ```python
  from getmac import get_mac_address
  eth_mac = get_mac_address(interface="eth0")
  win_mac = get_mac_address(interface="Ethernet 3")
  ip_mac = get_mac_address(ip="192.168.0.1")
  ip6_mac = get_mac_address(ip6="::1")
  host_mac = get_mac_address(hostname="localhost")
  updated_mac = get_mac_address(ip="10.0.0.1", network_request=True)


  from getmac import getmac
  getmac.DEBUG = 2  # DEBUG level 2
  print(getmac.get_mac_address(interface="Ethernet 3"))


  from getmac import getmac
  getmac.PORT = 44444  # Default is 55555
  print(getmac.get_mac_address(ip="192.168.0.1", network_request=True))
  ```


  **Python 2 users**: use `getmac2` or `python -m getmac` instead of `getmac`.
  ```bash
  getmac --help
  getmac --version


  getmac


  python3 -m getmac


  getmac --interface ens33
  getmac --ip 192.168.0.1
  getmac --ip6 ::1
  getmac --hostname home.router


  python -m getmac -i 'Ethernet 4'
  python -m getmac -4 192.168.0.1
  python -m getmac -6 ::1
  python -m getmac -n home.router




  getmac --no-network-request --ip 192.168.0.1
  python -m getmac --no-network-request -n home.router


  getmac --verbose


  getmac -v --debug
  python -m getmac -v -d -i enp11s4
  python -m getmac -v -dd -n home.router


  getmac --ip 192.168.0.1 --override-port 9001





  getmac -i eth0 --override-platform linux
  getmac --ip 192.168.0.1 --override-platform windows


  getmac -v -dddd --ip 192.168.0.1 --force-method ctypeshost
  ```


  - `interface`: Name of a network interface on the system
  - `ip`: IPv4 address of a remote host
  - `ip6`: IPv6 address of a remote host
  - `hostname`: Hostname of a remote host
  - `network_request`: If an network request should be made to update and populate the ARP/NDP table of remote hosts used to lookup MACs in most circumstances. Disable this if you want to just use what's already in the table, or if you have requirements to prevent network traffic. The network request is a empty UDP packet sent to a high port, `55555` by default. This can be changed by setting `getmac.PORT` to the desired integer value. Additionally, on Windows, this will send a UDP packet to `1.1.1.1:53` to attempt to determine the default interface (Note: the IP is [CloudFlare's DNS server](https://www.cloudflare.com/learning/dns/what-is-1.1.1.1/)).


  - `logging.getLogger("getmac")`: Runtime messages and errors are recorded to the `getmac` logger using Python's [logging](https://docs.python.org/3/library/logging.html) module. They can be configured by using [logging.basicConfig()](https://docs.python.org/3/library/logging.html#logging.basicConfig) or adding handlers to the `"getmac"` logger.
  - `getmac.getmac.DEBUG`: integer value that controls debugging output. The higher the value, the more output you get.
  - `getmac.getmac.PORT`: UDP port used to populate the ARP/NDP table (see the documentation of the `network_request` argument in `get_mac_address()` for details)
  - `getmac.getmac.OVERRIDE_PLATFORM`: Override the platform detection with the given value (e.g. `"linux"`, `"windows"`, `"freebsd"`, etc.'). Any values returned by `platform.system()` are valid.
  - `getmac.getmac.FORCE_METHOD`: Force a specific method to be used, e.g. 'IpNeighborShow'. This will be used regardless of it's method type or platform compatibility, and `Method.test()` will NOT be checked! The list of available methods is in `getmac.getmac.METHODS`.


  - Pure-Python (no compiled C-extensions required!)
  - Python 2.7 and 3.4+
  - Lightweight, with no dependencies and a small package size
  - Can be dropped into a project as a standalone .py file
  - Supports most interpreters: CPython, pypy, pypy3, IronPython 2.7, and Jython 2.7
  - Provides a simple command line tool (when installed as a package)
  - MIT licensed!


  If you are running a old Python (2.6/3.3 and older) or interpreter, then you can install an older version of `getmac` that supported that version. The wheels are available in the [GitHub releases](https://github.com/GhostofGoes/getmac/releases), or from PyPI with a current version of `pip` and some special arguments.

  - Python 2.5: get-mac 0.5.0
  - Python 2.6: getmac 0.6.0
  - Python 3.2: get-mac 0.3.0
  - Python 3.3: get-mac 0.3.0

  NOTE: these versions do not have many of the performance improvements, platform support, and bug fixes that came with later releases. They generally work, just not as well. However, if you're using such an old Python, you probably don't care about all that :)


  - Python 3.10 and 3.11 should work, but are not automatically tested at the moment due to having to support 2.7
  - If none of the arguments are selected, the default network interface for the system will be used. If the default network interface cannot be determined, then it will attempt to fallback to typical defaults for the platform (`Ethernet` on Windows, `em0` on BSD, `en0` on OSX/Darwin, and `eth0` otherwise). If that fails, then it will fallback to `lo` on POSIX systems.
  - "Remote hosts" refer to hosts in your local layer 2 network, also commonly referred to as a "broadcast domain", "LAN", or "VLAN". As far as I know, there is not a reliable method to get a MAC address for a remote host external to the LAN. If you know any methods otherwise, please [open a GitHub issue](https://github.com/GhostofGoes/getmac/issues) or shoot me an email, I'd love to be wrong about this.
  - The first four arguments are mutually exclusive. `network_request` does not have any functionality when the `interface` argument is specified, and can be safely set if using in a script.
  - The physical transport is assumed to be Ethernet (802.3). Others, such as Wi-Fi (802.11), are currently not tested or considered. I plan to address this in the future, and am definitely open to pull requests or issues related to this, including error reports.
  - **Exceptions will be handled silently and returned as a None.** If you run into problems, you can set `DEBUG` to true and get more     information about what's happening. If you're still having issues, please create an [issue on GitHub](https://github.com/GhostofGoes/getmac/issues) and include the output with `DEBUG` enabled.


  - Windows
      - Commands: `getmac.exe`, `ipconfig.exe`, `arp.exe`, `wmic.exe`
      - Libraries: `uuid`, `ctypes`, `socket`
  - Linux/Unix
      - Commands: `arp`, `ip`, `ifconfig`, `netstat`, `ip link`, `lanscan`
      - Libraries: `uuid`, `fcntl`, `socket`
      - Files: `/sys/class/net/{iface}/address`, `/proc/net/arp`
      - Default interfaces: `/proc/net/route`, `route`, `ip route list`
  - Mac OSX (Darwin)
      - `networksetup`
      - Same commands as Linux
  - WSL
      - Windows commands are used for remote hosts
      - Unix commands are used for interfaces
  - OpenBSD
      - Commands: `ifconfig`, `arp`
      - Default interfaces: `route`
  - FreeBSD
      - Commands: `ifconfig`, `arp`
      - Default interfaces: `netstat`
  - Android
      - Commands: `ip link`


  All or almost all features should work on "supported" platforms. While other versions of the same family or distro may work, they are untested and may have bugs or missing features.

  - Windows
      - Desktop: 7, 8, 8.1, 10, 11 (thanks @StevenLooman for testing Windows 11!)
      - Server: TBD
      - Partially supported (untested): 2000, XP, Vista
  - Linux distros
      - CentOS/RHEL 6+
      - Ubuntu 16.04+ (15.10 and older should work, but are untested)
      - Fedora (24+)
  - Mac OSX (Darwin)
      - The latest two versions probably (TBD)
  - Android (6+)
  - Windows Subsystem for Linux (WSL)
  - FreeBSD (11+)
  - OpenBSD
  - Docker


  Add `-v /proc/1/net/arp:/host/arp -e ARP_PATH=/host/arp` to access arp table of host inside container in bridge network mode.

  ```bash
  docker build -f packaging/Dockerfile -t getmac .
  docker run -it getmac:latest --help
  docker run -it getmac:latest --version
  docker run -it getmac:latest -n localhost
  docker run --rm -it -v /proc/1/net/arp:/host/arp -e ARP_PATH=/host/arp getmac:latest -n 192.168.0.1
  ```


  - Depending on the platform, there could be a performance detriment, due to heavy usage of regular expressions.
  - Platform test coverage is imperfect. If you're having issues, then you might be using a platform I haven't been able to test. Keep calm, open a GitHub issue, and I'd be more than happy to help.


  - Linux, WSL: Getting the mac of a local interface IP does not currently work (`getmac --ip 10.0.0.4` will fail if `10.0.0.4` is the IP address of a local interface). This issue may be present on other POSIX systems as well.
  - Hostnames for IPv6 devices are not yet supported.
  - Windows: the "default" (used when no arguments set or specified) of selecting the default route interface only works effectively if `network_request` is enabled. If not, `Ethernet` is used as the default.
  - IPv6 support is good but lags behind IPv4 in some places and isn't as well-tested across the supported platform set.


  The Python standard library has a robust set of networking functionality, such as `urllib`, `ipaddress`, `ftplib`, `telnetlib`, `ssl`, and more. Imagine my surprise, then, when I discovered there was not a way to get a seemingly simple piece of information: a MAC address. This package was born out of a need to get the MAC address of hosts on the network without needing admin permissions, and a cross-platform way get the addresses of local interfaces.

  In Fall 2018 the package name changed to `getmac` from `get-mac`. This affected the package name, the CLI script, and some of the documentation. There were no changes to the core library code. While both package names will updated on PyPI, the use of `getmac` is preferred.

  In Summer 2020, the code was significantly refactored, moving to a class-based structure and significantly improving performance and accuracy. See [docs/rewrite.md](docs/rewrite.md) for details.


  Contributors are more than welcome! See the [contribution guide](CONTRIBUTING.md) to get started, and checkout the [todo list](TODO.md) for a full list of tasks and bugs.

  Before submitting a PR, please make sure you've completed the [pull request checklist](CONTRIBUTING.md#Code_requirements)!

  The [Python Discord server](https://discord.gg/python) is a good place to ask questions or discuss the project (Handle: @KnownError#0001).


  - Christopher Goes (@ghostofgoes) - Author and maintainer
  - Calvin Tran (@cyberhobbes) - Windows interface detection improvements
  - Daniel Flanagan (@FlantasticDan) - Code cleanup
  - @emadmahdi - Android fixes
  - Izra Faturrahman (@Frizz925) - Unit tests using the platform samples
  - Jose Gonzalez (@Komish) - Docker container and Docker testing
  - @fortunate-man - Awesome usage videos
  - @martmists - legacy Python compatibility improvements
  - @hargoniX - scripts and specfiles for RPM packaging
  - Ville Skyttä (@scop) - arping lookup support
  - Tomasz Duda (@tomaszduda23) - support for docker in network bridge mode
  - Steven Looman (@StevenLooman) - Windows 11 testing


  Many of the methods used to acquire an address and the core logic framework are attributed to the CPython project's UUID implementation.

  - https://github.com/python/cpython/blob/master/Lib/uuid.py
  - https://github.com/python/cpython/blob/2.7/Lib/uuid.py


  - [_unix_fcntl_by_interface](https://stackoverflow.com/a/4789267/2214380)
  - [_windows_get_remote_mac_ctypes](goo.gl/ymhZ9p)
  - [String joining](https://stackoverflow.com/a/3258612/2214380)


  MIT. Feel free to copy, modify, and use to your heart's content. Enjoy :)




  **NOTE**: if any changes significantly impact your project or use case, please open an issue on [GitHub](https://github.com/GhostofGoes/getmac/issues) or email me (see git commit author info for address).

  **Announcement**: Compatibility with Python versions older than 3.7 (2.7, 3.4, 3.5, and 3.6) is deprecated and will be removed in getmac 1.0.0. If you are stuck on an unsupported Python, consider loosely pinning the version of this package in your dependency list, e.g. `getmac<1.0.0` or `getmac~=0.9.0`.




  * Fix flakyness with UuidArpGetNode on MacOS by making it the last method attempted (Fixes issue [#82](https://github.com/GhostofGoes/getmac/issues/82))




  * Deprecate Python 3.6 support (support will be removed in getmac 1.0.0)


  * Fix links in README and PyPI metadata to use "main" instead of "master" for primary branch
  * Remove "Documentation" link from PyPI (the ReadTheDocs site is broken and hasn't been updated since 0.5.0)
  * Add PyPI classifiers for 3.10 and 3.11
  * Some cleanup of CHANGELOG



  This release is a *complete rewrite of getmac from the ground up*. The public API of `getmac` is **unchanged** as part of this rewrite. `get_mac_address()` is still the primary way of getting a MAC address, it's just the "under the hood" internals that have changed completely.

   It's passing tests and seems to be operable. However, with a change this large there are inevitably issues that the tests or I don't catch, so I'm doing a series of pre-releases until I'm 99% confident in it's stability. Refer to `docs/rewrite.md` for a in-depth explanation of the rewrite changes.

  The new system has a number of benefits
  - Reduction of false-positives and false-negatives by improving method selection accuracy (platform, validity, etc.)
  - *Significantly* faster overall
  - "Misses" have the same performance as "Hits"
  - Easier to test, since each method can be tested directly via it's class
  - Easier to type annotate and analyze with mypy
  - Easier to read, improving reviewability and ease of contributing for newcomers
  - Extensible! Custom methods can be defined and added at runtime (which is perfect if you have some particular edge case but aren't able to open-source it).


  * Fully support Python 3.9 (automated tests in CI)
  * Tentatively support Python 3.10 and 3.11 (unable to test due to the need to be able to still test 2.7)
  * Added default interface detection for MacOS (command: `route get default`)
  * Added initial support for Solaris/SunOS. There were a few existing methods that worked as-is, so just added indicators that those methods support `sunos` (Which applies to any system where `platform.system() == SunOS`).
  * `arping` (POSIX) or `SendARP` (Windows) will now *always* be used instead of sending a UDP packet when looking for the MAC of a IPv4 host, if they're available and operable (otherwise, UDP + ARP table check will be used like before).
  * The amount of time taken to get a result (in seconds) will now be recorded and logged if debugging is enabled (`DEBUG>=1` or `-d`)
  * Added command line argument to override the UDP port for network requests: `--override-port` (this was already possible in Python via `getmac.getmac.PORT`, but wasn't configurable via the CLI. Now it is!).
  * Added ability to override the detected platform via `--override-platform` argument (CLI) or `getmac.getmac.OVERRIDE_PLATFORM` variable (Python). This will force methods for that platform to be used, regardless of the actual platform. Here's an example forcing `linux` to be used as the platform: `getmac -i eth0 --override-platform linux`. In version 1.0.0, this feature will added as an argument to `get_mac_address()`.
  * Added ability to force a specific method to be used via `--force-method` argument (CLI) or `getmac.getmac.FORCE_METHOD` variable (Python). This is useful for troubleshooting issues, general debugging, and testing changes. Example: `getmac -v -dddd --ip 192.168.0.1 --force-method ctypeshost`


  * **Complete rewrite of `getmac` from the ground up. Refer to `docs/rewrite.md` for a in-depth explanation of the rewrite changes**
  * Fixed a failure to look up a hostname now returns `None`, as expected, instead of raising an exception (`socket.gaierror`).
  * Fixed numerous false-negative and false-positive bugs
  * Improved overall performance
  * Performance for cases where no MAC is found is now the same as cases where a MAC is found (speed of "misses" now equals that of "hits")
  * Improved the reliability and performance of many methods
  * Fixed `netstat` on older Linux distros (such as Ubuntu 12.04)
  * Overhauled `ifconfig` parsing. It should now be far more reliable and accurate across all platforms.
  * Improved Android support. Note that newer devices are locked down and the amount of information that's obtainable by an unprivileged process is quite limited (Android 7/9 and newer, not sure exactly when they changed this, I'm not an Android guy). That being said, the normal Linux methods should work fine, provided you have the proper permissions (usually, `root`).
  * Fixed bug with `/proc/net/route` parsing (this affected Android and potentially other platforms)
  * Improve default interface detection for FreeBSD (command: `route get default`)


  * Removed man pages from distribution (`getmac.1`/`getmac2.1`). They were severely out of date and unused. May re-add at a later date.


  * Migrate CI to GitHub Actions, remove TravisCI and Appveyor
  * Add flake8 plugins: `flake8-pytest-style` and `flake8-annotations`
  * Add additional samples and tests for WSL1 (with the Ubuntu 18.04 distro)
  * Add additional samples for Windows 10
  * Add additional samples for MacOS
  * Add samples and tests for Ubuntu 12.04
  * Add samples for NetBSD 8 (support coming in a future release)
  * Add samples for Solaris 10 (support TBD)
  * Add samples for several versions of Android
  * Add new tests
  * Improve existing tests
  * Consolidate everything related to RPM packaging to `packaging/rpm/`. This stuff hasn't been updated since 0.6.0, may remove in the future and leave distro packaging to distro maintainers.





  * Added support for Thomas Habets' version of `arping` in addition to the existing iputils one (contributed by Ville Skyttä (@scop) in [#52](https://github.com/GhostofGoes/getmac/pull/52) and [#54](https://github.com/GhostofGoes/getmac/pull/54))
  * Added support for docker in network bridge mode (contributed by Tomasz Duda (@tomaszduda23) in [#57](https://github.com/GhostofGoes/getmac/pull/57))
  * Add CHANGELOG URL to PyPI metadata (contributed by Ville Skyttä (@scop) in [#58](https://github.com/GhostofGoes/getmac/pull/58))
  * Fixed code quality test suite errors (includes changes by Daniel Flanagan (@FlantasticDan) in [#67](https://github.com/GhostofGoes/getmac/pull/67))
  * Improved Android support (contributed by @emadmahdi in [#71](https://github.com/GhostofGoes/getmac/pull/71))
  * Minor code quality fixes (2 years of neglecting master branch)
  * Add [Code of Conduct](https://github.com/GhostofGoes/getmac/blob/main/CODE_OF_CONDUCT.md) for project contributors
  * Add [SECURITY.md](https://github.com/GhostofGoes/getmac/blob/main/SECURITY.md) for reporting security issues (e.g. vulnerabilities)
  * Deprecate Python 3.4 and 3.5
  * Issue deprecation message as a warning in addition to a log message





  * Added warning about Python 2 compatibility being dropped in 1.0.0
  * Officially support Python 3.8
  * Documented a known issue with looking up IP of a local interface on Linux/WSL (See the "Known Issues" section in the README)
  * Added remote host lookup using `arping` as last resort


  * Standardized formatting on [Black](https://github.com/psf/black)
  * Lint additions: `vulture`, several Flake8 plugins
  * Pinned test dependencies (pytest 5 dropped Python 2 support)
  * Various quality-of-life improvements for contributors/developers





  * Fixed sockets being opened and not closed when `ip` or `ip6` were used,
  which could lead to a `ResourceWarning` (GH-42)





  * OpenBSD support
  * FreeBSD support
  * Python logging is now used instead of `print` (logger: `getmac`)
  * Include tests in the source distribution
  * (CLI) Added aliases for `--no-network-requests`: `-N` and `--no-net`
  * (CLI) New argument: `-v`/`--verbose`


  * Errors are now logged instead of raising a `RuntimeWarning`
  * Improved Ubuntu support
  * Performance improvements


  * Significant increase in overall test coverage
  * Fixed and migrated the sample tests to `pytest`
  * Added tests for the CLI





  * Type annotations (PEP 484)


  * Dropped support for Python 2.6
  * Removed the usage of third-party packages (`netifaces`, `psutil`, `scapy`, and `arpreq`).
  This should improve the performance of lookups of non-existent interfaces
  or hosts, since this feature was punishing that path without providing much value.
  If you want to use these packages directly, I have a guide on how to do so on a
  [GitHub Gist](https://gist.github.com/GhostofGoes/0a8e82930e75afcefbd879a825ba4c26).


  * Significantly improved the performance of the common cases on Linux
  for interfaces and remote hosts
  * Improved POSIX interface performance. Commands specific to OSX
  will be run only on that platform, and vice-versa.
  * Significantly improved the speed and accuracy of determining
  the default interface on Linux
  * Python 2 will install an executor named getmac2 and Python 3 an
  executor named getmac so they do not conflict when both RPMs are
  installed on the same system (Credit: @hargoniX)
  * The `warnings` module will only be imported if a error/warning
  occurs (improve compatibility with some freezers, notably PyInstaller)
  * Improved system platform detection
  * Various other minor performance improvements


  * Added unit tests for the samples (Credit: @Frizz925)
  * Scripts for building RPMs in the /scripts directory (Credit: @hargoniX)
  * Improved code quality and health checks
  * Include the CHANGELOG on the PyPI project page
  * Using `pytest` for all tests now instead of `unittest`


  * Added instructions on how to build a Debian package (Credit: @kofrezo)




  * Windows default interface detection if `network_request` is enabled (Credit: @cyberhobbes)
  * Docker container (Credit: @Komish)


  * Changed project name to `getmac`. This applies to the
  command line tool, GitHub, and the documentation.
  * Use proper Python 2-compatible print functions (Credit: @martmists)


  * Support for Python 2.5. It is not feasible to test, and potentially
  breaks some useful language features, such as `__future__`
  * Variables PORT and DEBUG from top-level package imports, since changing
  them would have no actual effect on execution. Instead, use `getmac.getmac.DEBUG`.


  * Added example videos demonstrating usage (Credit: @fortunate-man)
  * Added contribution guide
  * Added documentation on ReadTheDocs
  * Added a manpage




  * Full support for Windows Subsystem for Linux (WSL). This is working for
  all features, including default interface selection! The only edge case
  is lookup of remote host IP addresses that are actually local interfaces
  will not resolve to a MAC (which should be ff-ff-ff-ff-ff-ff).

  * Require `argparse` if Python version is 2.6 or older

  * Updated tox tests: added Jython and IronPython, removed 2.6




  * New methods for remote host MACs
      * Windows: `arp`
      * POSIX: `arpreq` package
  * New methods for interface MACs
      * Windows: `wmic nic`
  * DEBUG levels: DEBUG value is now an integer, and increasing it will
  increase the amount and verbosity of output. On the CLI, it can be
  configured by increasing the amount of characters for the debug argument,
  e.g. '-dd' for DEBUG level 2.
  * Jython support (Note: on Windows Jython currently only works with interfaces)
  * IronPython support


  * **Significant** performance improvement for remote hosts. Previously,
  the average for `get_mac_address(ip='10.0.0.100')` was 1.71 seconds.
  Now, the average is `12.7 miliseconds`, with the special case of a unpopulated
  arp table being only slightly higher. This was brought about by changes in
  how the arp table is populated. The original method was to use the
  host's `ping` command to send an ICMP packet to the host. This took time,
  which heavily delayed the ability to actually get an address. The solution
  is to instead simply send a empty UDP packet to a high port. The port
  this packet is sent to can be configured using the module variable `getmac.PORT`.
  * "Fixed" resolution of localhost/127.0.0.1 by hardcoding the response.
  This should resolve a lot of problematic edge cases. I'm ok with this
  for now since I don't know of a case when it isn't all zeroes.
  * Greatly increased the reliability of getting host and interface MACs on Windows
  * Improved debugging output
  * Tightened up the size of `getmac.py`
  * Various minor stability and performance improvements
  * Add LICENSE to PyPI package


  * Support for Python 3.2 and 3.3. The total downloads from PyPI with
  those versions in August was ~53k and ~407K, respectfully. The majority
  of those are likely from automated testing (e.g. TravisCI) and not
  actual users. Therefore, I've decided to drop support to simplify
  development, especially since before 3.4 the 3.x series was still
  very much a  "work in progress".


  * Added automated tests for Windows using Appveyor
  * Tox runner for tests
  * Added github.io page
  * Improved TravisCI testing




  * Attempt to use Python modules if they're installed. This is useful
  for larger projects that already have them installed as dependencies,
  as they provide a more reliable means of getting information.
      * `psutil`: Interface MACs on all platforms
      * `scapy`: Interface MACs and Remote MACs on all platforms
      * `netifaces`: Interface MACs on Non-Windows platforms
  * New methods for remote MACs
      * POSIX: `ip neighbor show`, Abuse of `uuid._arp_getnode()`
  * New methods for Interface MACs
      * POSIX: `lanscan -ai` (HP-UX)


  * Certain critical failures that should never happen will now warn
  instead of failing silently.
  * Added a sanity check to the `ip6` argument (IPv6 addresses)
  * Improved performance in some areas
  * Improved debugging output


  * Major Bugfix: search of `proc/net/arp` would return shorter addresses in the
  same subnet if they came earlier in the sequence. Example: a search for
  `192.168.16.2` on Linux would instead return the MAC address of
  `192.168.16.254` with no errors or warning whatsoever.
  * Significantly improved default interface detection. Default
  interfaces are now properly detected on Linux and most other
  POSIX platforms with `ip` or `route` commands available, or the
  `netifaces` Python module.


  * Makefile
  * Vagrantfile to spin up testing VMs for various platforms using [Vagrant](https://www.vagrantup.com/docs/)
  * Added more samples of command output on platforms (Ubuntu 18.04 LTS)




  * Fixed identification of remote host on OSX
  * Resolved hangs and noticeable lag that occurred when "network_request"
  was True (the default)




  * Remote host for Python 3 on Windows




  * Short versions of CLI arguments (e.g. "-i" for "--interface")


  * Improved usage of "ping" across platforms and IP versions
  * Various minor tweaks for performance
  * Improved Windows detection


  * Use of ping command with hostname


  * Improvements to internal code



  Nothing changed. PyPI just won't let me push changes without a new version.




  * Checks for default interface on Linux systems
  * New methods of hunting for addresses on Windows, Mac OS X, and Linux


  * CLI will output nothing if it failed, instead of "None"
  * CLI will return with 1 on failure, 0 on success
  * No CLI arguments now implies the default host network interface
  * Added an argumnent for debugging: `--debug`
  * Removed `-d` option from `--no-network-requests`


  * Interfaces on Windows and Linux (including Bash for Windows)
  * Many bugs


  * Support for Python 2.6 on the CLI


  * Overhaul of internals




  * Addition of a terminal command: `get-mac`
  * Ability to run as a module from the command line: `python -m getmac`


  * `arp_request` argument was renamed to `network_request`
  * Updated docstring
  * Slight reduction in the size of getmac.py


  * Overhauled the README
  * Moved tests into their own folder
  * Added Python 3.7 to list of supported snakes



  * Python 2.6 compatibility



  * Fixed some addresses returning without colons
  * Added more rigorous checks on addresses before returning them



  * Remove print statements and other debugging output



  * Initial pre-alpha


pkgId: 310c9a634b516fcf449b2b04afc114a4336be30b25f0449d0e2cfb3307402da0
name: python-getmac
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: Get MAC addresses of remote hosts and local interfaces
url: https://github.com/GhostofGoes/getmac
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-404633c5-515a-4067-beaa-d65dfba120ac
location_href: 00007106-python-getmac/python-getmac-0.9.3-1.src.rpm
checksum_type: sha256
description:
  [![Latest version on PyPI](https://badge.fury.io/py/getmac.svg)](https://pypi.org/project/getmac/)
  [![Coverage Status](https://coveralls.io/repos/github/GhostofGoes/getmac/badge.svg?branch=main)](https://coveralls.io/github/GhostofGoes/getmac?branch=main)
  [![GitHub Actions Pipeline Status](https://github.com/ghostofgoes/getmac/actions/workflows/ci.yml/badge.svg)](https://github.com/GhostofGoes/getmac/actions)
  [![Weekly PyPI downloads](https://pepy.tech/badge/getmac/week)](https://pepy.tech/project/getmac)
  [![PyPI downloads](https://pepy.tech/badge/getmac)](https://pepy.tech/project/getmac)
  [![PyPI downloadss of the old name](https://pepy.tech/badge/get-mac)](https://pepy.tech/project/get-mac)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  Pure-Python package to get the MAC address of network interfaces and hosts on the local network.

  It provides a platform-independent interface to get the MAC addresses of:

  - System network interfaces (by interface name)
  - Remote hosts on the local network (by IPv4/IPv6 address or hostname)

  It provides one function: `get_mac_address()`

  [![asciicast](https://asciinema.org/a/rk6dUACUcZY18taCuIBE5Ssus.png)](https://asciinema.org/a/rk6dUACUcZY18taCuIBE5Ssus)

  [![asciicast](https://asciinema.org/a/n3insrxfyECch6wxtJEl3LHfv.png)](https://asciinema.org/a/n3insrxfyECch6wxtJEl3LHfv)



  If you only need the addresses of network interfaces, have a limited set of platforms to support, and are able to handle C-extension modules, then you should instead check out the excellent [netifaces](https://pypi.org/project/netifaces/) package by Alastair Houghton ([@al45tair](https://github.com/al45tair)). It's significantly faster (thanks to it being C-code) and has been around a long time and seen widespread usage. However, unfortunately it is no longer maintained as of [May 2021](https://github.com/al45tair/netifaces/commit/ec55b59e27542776f55e0f9e3213a75bf8e0f367), so it may not be a great choice for new projects. Another great option that fits these requirements is the well-known and battle-hardened [psutil](https://github.com/giampaolo/psutil) package by Giampaolo Rodola.

  If the only system you need to run on is Linux, you can run as root, and C-extensions modules are fine, then you should instead check out the [arpreq](https://pypi.org/project/arpreq/) package by Sebastian Schrader. In some cases it can be significantly faster.

  If you want to use `psutil`, `scapy`, or `netifaces`, I have examples of how to do so in a [GitHub Gist](https://gist.github.com/GhostofGoes/0a8e82930e75afcefbd879a825ba4c26).


  Stable release from PyPI

  ```bash
  pip install getmac
  ```

  Latest development version

  ```bash
  pip install https://github.com/ghostofgoes/getmac/archive/main.tar.gz
  ```


  ```python
  from getmac import get_mac_address
  eth_mac = get_mac_address(interface="eth0")
  win_mac = get_mac_address(interface="Ethernet 3")
  ip_mac = get_mac_address(ip="192.168.0.1")
  ip6_mac = get_mac_address(ip6="::1")
  host_mac = get_mac_address(hostname="localhost")
  updated_mac = get_mac_address(ip="10.0.0.1", network_request=True)


  from getmac import getmac
  getmac.DEBUG = 2  # DEBUG level 2
  print(getmac.get_mac_address(interface="Ethernet 3"))


  from getmac import getmac
  getmac.PORT = 44444  # Default is 55555
  print(getmac.get_mac_address(ip="192.168.0.1", network_request=True))
  ```


  **Python 2 users**: use `getmac2` or `python -m getmac` instead of `getmac`.
  ```bash
  getmac --help
  getmac --version


  getmac


  python3 -m getmac


  getmac --interface ens33
  getmac --ip 192.168.0.1
  getmac --ip6 ::1
  getmac --hostname home.router


  python -m getmac -i 'Ethernet 4'
  python -m getmac -4 192.168.0.1
  python -m getmac -6 ::1
  python -m getmac -n home.router




  getmac --no-network-request --ip 192.168.0.1
  python -m getmac --no-network-request -n home.router


  getmac --verbose


  getmac -v --debug
  python -m getmac -v -d -i enp11s4
  python -m getmac -v -dd -n home.router


  getmac --ip 192.168.0.1 --override-port 9001





  getmac -i eth0 --override-platform linux
  getmac --ip 192.168.0.1 --override-platform windows


  getmac -v -dddd --ip 192.168.0.1 --force-method ctypeshost
  ```


  - `interface`: Name of a network interface on the system
  - `ip`: IPv4 address of a remote host
  - `ip6`: IPv6 address of a remote host
  - `hostname`: Hostname of a remote host
  - `network_request`: If an network request should be made to update and populate the ARP/NDP table of remote hosts used to lookup MACs in most circumstances. Disable this if you want to just use what's already in the table, or if you have requirements to prevent network traffic. The network request is a empty UDP packet sent to a high port, `55555` by default. This can be changed by setting `getmac.PORT` to the desired integer value. Additionally, on Windows, this will send a UDP packet to `1.1.1.1:53` to attempt to determine the default interface (Note: the IP is [CloudFlare's DNS server](https://www.cloudflare.com/learning/dns/what-is-1.1.1.1/)).


  - `logging.getLogger("getmac")`: Runtime messages and errors are recorded to the `getmac` logger using Python's [logging](https://docs.python.org/3/library/logging.html) module. They can be configured by using [logging.basicConfig()](https://docs.python.org/3/library/logging.html#logging.basicConfig) or adding handlers to the `"getmac"` logger.
  - `getmac.getmac.DEBUG`: integer value that controls debugging output. The higher the value, the more output you get.
  - `getmac.getmac.PORT`: UDP port used to populate the ARP/NDP table (see the documentation of the `network_request` argument in `get_mac_address()` for details)
  - `getmac.getmac.OVERRIDE_PLATFORM`: Override the platform detection with the given value (e.g. `"linux"`, `"windows"`, `"freebsd"`, etc.'). Any values returned by `platform.system()` are valid.
  - `getmac.getmac.FORCE_METHOD`: Force a specific method to be used, e.g. 'IpNeighborShow'. This will be used regardless of it's method type or platform compatibility, and `Method.test()` will NOT be checked! The list of available methods is in `getmac.getmac.METHODS`.


  - Pure-Python (no compiled C-extensions required!)
  - Python 2.7 and 3.4+
  - Lightweight, with no dependencies and a small package size
  - Can be dropped into a project as a standalone .py file
  - Supports most interpreters: CPython, pypy, pypy3, IronPython 2.7, and Jython 2.7
  - Provides a simple command line tool (when installed as a package)
  - MIT licensed!


  If you are running a old Python (2.6/3.3 and older) or interpreter, then you can install an older version of `getmac` that supported that version. The wheels are available in the [GitHub releases](https://github.com/GhostofGoes/getmac/releases), or from PyPI with a current version of `pip` and some special arguments.

  - Python 2.5: get-mac 0.5.0
  - Python 2.6: getmac 0.6.0
  - Python 3.2: get-mac 0.3.0
  - Python 3.3: get-mac 0.3.0

  NOTE: these versions do not have many of the performance improvements, platform support, and bug fixes that came with later releases. They generally work, just not as well. However, if you're using such an old Python, you probably don't care about all that :)


  - Python 3.10 and 3.11 should work, but are not automatically tested at the moment due to having to support 2.7
  - If none of the arguments are selected, the default network interface for the system will be used. If the default network interface cannot be determined, then it will attempt to fallback to typical defaults for the platform (`Ethernet` on Windows, `em0` on BSD, `en0` on OSX/Darwin, and `eth0` otherwise). If that fails, then it will fallback to `lo` on POSIX systems.
  - "Remote hosts" refer to hosts in your local layer 2 network, also commonly referred to as a "broadcast domain", "LAN", or "VLAN". As far as I know, there is not a reliable method to get a MAC address for a remote host external to the LAN. If you know any methods otherwise, please [open a GitHub issue](https://github.com/GhostofGoes/getmac/issues) or shoot me an email, I'd love to be wrong about this.
  - The first four arguments are mutually exclusive. `network_request` does not have any functionality when the `interface` argument is specified, and can be safely set if using in a script.
  - The physical transport is assumed to be Ethernet (802.3). Others, such as Wi-Fi (802.11), are currently not tested or considered. I plan to address this in the future, and am definitely open to pull requests or issues related to this, including error reports.
  - **Exceptions will be handled silently and returned as a None.** If you run into problems, you can set `DEBUG` to true and get more     information about what's happening. If you're still having issues, please create an [issue on GitHub](https://github.com/GhostofGoes/getmac/issues) and include the output with `DEBUG` enabled.


  - Windows
      - Commands: `getmac.exe`, `ipconfig.exe`, `arp.exe`, `wmic.exe`
      - Libraries: `uuid`, `ctypes`, `socket`
  - Linux/Unix
      - Commands: `arp`, `ip`, `ifconfig`, `netstat`, `ip link`, `lanscan`
      - Libraries: `uuid`, `fcntl`, `socket`
      - Files: `/sys/class/net/{iface}/address`, `/proc/net/arp`
      - Default interfaces: `/proc/net/route`, `route`, `ip route list`
  - Mac OSX (Darwin)
      - `networksetup`
      - Same commands as Linux
  - WSL
      - Windows commands are used for remote hosts
      - Unix commands are used for interfaces
  - OpenBSD
      - Commands: `ifconfig`, `arp`
      - Default interfaces: `route`
  - FreeBSD
      - Commands: `ifconfig`, `arp`
      - Default interfaces: `netstat`
  - Android
      - Commands: `ip link`


  All or almost all features should work on "supported" platforms. While other versions of the same family or distro may work, they are untested and may have bugs or missing features.

  - Windows
      - Desktop: 7, 8, 8.1, 10, 11 (thanks @StevenLooman for testing Windows 11!)
      - Server: TBD
      - Partially supported (untested): 2000, XP, Vista
  - Linux distros
      - CentOS/RHEL 6+
      - Ubuntu 16.04+ (15.10 and older should work, but are untested)
      - Fedora (24+)
  - Mac OSX (Darwin)
      - The latest two versions probably (TBD)
  - Android (6+)
  - Windows Subsystem for Linux (WSL)
  - FreeBSD (11+)
  - OpenBSD
  - Docker


  Add `-v /proc/1/net/arp:/host/arp -e ARP_PATH=/host/arp` to access arp table of host inside container in bridge network mode.

  ```bash
  docker build -f packaging/Dockerfile -t getmac .
  docker run -it getmac:latest --help
  docker run -it getmac:latest --version
  docker run -it getmac:latest -n localhost
  docker run --rm -it -v /proc/1/net/arp:/host/arp -e ARP_PATH=/host/arp getmac:latest -n 192.168.0.1
  ```


  - Depending on the platform, there could be a performance detriment, due to heavy usage of regular expressions.
  - Platform test coverage is imperfect. If you're having issues, then you might be using a platform I haven't been able to test. Keep calm, open a GitHub issue, and I'd be more than happy to help.


  - Linux, WSL: Getting the mac of a local interface IP does not currently work (`getmac --ip 10.0.0.4` will fail if `10.0.0.4` is the IP address of a local interface). This issue may be present on other POSIX systems as well.
  - Hostnames for IPv6 devices are not yet supported.
  - Windows: the "default" (used when no arguments set or specified) of selecting the default route interface only works effectively if `network_request` is enabled. If not, `Ethernet` is used as the default.
  - IPv6 support is good but lags behind IPv4 in some places and isn't as well-tested across the supported platform set.


  The Python standard library has a robust set of networking functionality, such as `urllib`, `ipaddress`, `ftplib`, `telnetlib`, `ssl`, and more. Imagine my surprise, then, when I discovered there was not a way to get a seemingly simple piece of information: a MAC address. This package was born out of a need to get the MAC address of hosts on the network without needing admin permissions, and a cross-platform way get the addresses of local interfaces.

  In Fall 2018 the package name changed to `getmac` from `get-mac`. This affected the package name, the CLI script, and some of the documentation. There were no changes to the core library code. While both package names will updated on PyPI, the use of `getmac` is preferred.

  In Summer 2020, the code was significantly refactored, moving to a class-based structure and significantly improving performance and accuracy. See [docs/rewrite.md](docs/rewrite.md) for details.


  Contributors are more than welcome! See the [contribution guide](CONTRIBUTING.md) to get started, and checkout the [todo list](TODO.md) for a full list of tasks and bugs.

  Before submitting a PR, please make sure you've completed the [pull request checklist](CONTRIBUTING.md#Code_requirements)!

  The [Python Discord server](https://discord.gg/python) is a good place to ask questions or discuss the project (Handle: @KnownError#0001).


  - Christopher Goes (@ghostofgoes) - Author and maintainer
  - Calvin Tran (@cyberhobbes) - Windows interface detection improvements
  - Daniel Flanagan (@FlantasticDan) - Code cleanup
  - @emadmahdi - Android fixes
  - Izra Faturrahman (@Frizz925) - Unit tests using the platform samples
  - Jose Gonzalez (@Komish) - Docker container and Docker testing
  - @fortunate-man - Awesome usage videos
  - @martmists - legacy Python compatibility improvements
  - @hargoniX - scripts and specfiles for RPM packaging
  - Ville Skyttä (@scop) - arping lookup support
  - Tomasz Duda (@tomaszduda23) - support for docker in network bridge mode
  - Steven Looman (@StevenLooman) - Windows 11 testing


  Many of the methods used to acquire an address and the core logic framework are attributed to the CPython project's UUID implementation.

  - https://github.com/python/cpython/blob/master/Lib/uuid.py
  - https://github.com/python/cpython/blob/2.7/Lib/uuid.py


  - [_unix_fcntl_by_interface](https://stackoverflow.com/a/4789267/2214380)
  - [_windows_get_remote_mac_ctypes](goo.gl/ymhZ9p)
  - [String joining](https://stackoverflow.com/a/3258612/2214380)


  MIT. Feel free to copy, modify, and use to your heart's content. Enjoy :)




  **NOTE**: if any changes significantly impact your project or use case, please open an issue on [GitHub](https://github.com/GhostofGoes/getmac/issues) or email me (see git commit author info for address).

  **Announcement**: Compatibility with Python versions older than 3.7 (2.7, 3.4, 3.5, and 3.6) is deprecated and will be removed in getmac 1.0.0. If you are stuck on an unsupported Python, consider loosely pinning the version of this package in your dependency list, e.g. `getmac<1.0.0` or `getmac~=0.9.0`.




  * Fix `ArpFile` method being used for IPv6 (`/proc/net/arp`, and ARP in general, is IPv4-only)




  * Fix flakiness with UuidArpGetNode on MacOS by making it the last method attempted (Fixes issue [#82](https://github.com/GhostofGoes/getmac/issues/82))




  * Deprecate Python 3.6 support (support will be removed in getmac 1.0.0)


  * Fix links in README and PyPI metadata to use "main" instead of "master" for primary branch
  * Remove "Documentation" link from PyPI (the ReadTheDocs site is broken and hasn't been updated since 0.5.0)
  * Add PyPI classifiers for 3.10 and 3.11
  * Some cleanup of CHANGELOG



  This release is a *complete rewrite of getmac from the ground up*. The public API of `getmac` is **unchanged** as part of this rewrite. `get_mac_address()` is still the primary way of getting a MAC address, it's just the "under the hood" internals that have changed completely.

   It's passing tests and seems to be operable. However, with a change this large there are inevitably issues that the tests or I don't catch, so I'm doing a series of pre-releases until I'm 99% confident in it's stability. Refer to `docs/rewrite.md` for a in-depth explanation of the rewrite changes.

  The new system has a number of benefits
  - Reduction of false-positives and false-negatives by improving method selection accuracy (platform, validity, etc.)
  - *Significantly* faster overall
  - "Misses" have the same performance as "Hits"
  - Easier to test, since each method can be tested directly via it's class
  - Easier to type annotate and analyze with mypy
  - Easier to read, improving reviewability and ease of contributing for newcomers
  - Extensible! Custom methods can be defined and added at runtime (which is perfect if you have some particular edge case but aren't able to open-source it).


  * Fully support Python 3.9 (automated tests in CI)
  * Tentatively support Python 3.10 and 3.11 (unable to test due to the need to be able to still test 2.7)
  * Added default interface detection for MacOS (command: `route get default`)
  * Added initial support for Solaris/SunOS. There were a few existing methods that worked as-is, so just added indicators that those methods support `sunos` (Which applies to any system where `platform.system() == SunOS`).
  * `arping` (POSIX) or `SendARP` (Windows) will now *always* be used instead of sending a UDP packet when looking for the MAC of a IPv4 host, if they're available and operable (otherwise, UDP + ARP table check will be used like before).
  * The amount of time taken to get a result (in seconds) will now be recorded and logged if debugging is enabled (`DEBUG>=1` or `-d`)
  * Added command line argument to override the UDP port for network requests: `--override-port` (this was already possible in Python via `getmac.getmac.PORT`, but wasn't configurable via the CLI. Now it is!).
  * Added ability to override the detected platform via `--override-platform` argument (CLI) or `getmac.getmac.OVERRIDE_PLATFORM` variable (Python). This will force methods for that platform to be used, regardless of the actual platform. Here's an example forcing `linux` to be used as the platform: `getmac -i eth0 --override-platform linux`. In version 1.0.0, this feature will added as an argument to `get_mac_address()`.
  * Added ability to force a specific method to be used via `--force-method` argument (CLI) or `getmac.getmac.FORCE_METHOD` variable (Python). This is useful for troubleshooting issues, general debugging, and testing changes. Example: `getmac -v -dddd --ip 192.168.0.1 --force-method ctypeshost`


  * **Complete rewrite of `getmac` from the ground up. Refer to `docs/rewrite.md` for a in-depth explanation of the rewrite changes**
  * Fixed a failure to look up a hostname now returns `None`, as expected, instead of raising an exception (`socket.gaierror`).
  * Fixed numerous false-negative and false-positive bugs
  * Improved overall performance
  * Performance for cases where no MAC is found is now the same as cases where a MAC is found (speed of "misses" now equals that of "hits")
  * Improved the reliability and performance of many methods
  * Fixed `netstat` on older Linux distros (such as Ubuntu 12.04)
  * Overhauled `ifconfig` parsing. It should now be far more reliable and accurate across all platforms.
  * Improved Android support. Note that newer devices are locked down and the amount of information that's obtainable by an unprivileged process is quite limited (Android 7/9 and newer, not sure exactly when they changed this, I'm not an Android guy). That being said, the normal Linux methods should work fine, provided you have the proper permissions (usually, `root`).
  * Fixed bug with `/proc/net/route` parsing (this affected Android and potentially other platforms)
  * Improve default interface detection for FreeBSD (command: `route get default`)


  * Removed man pages from distribution (`getmac.1`/`getmac2.1`). They were severely out of date and unused. May re-add at a later date.


  * Migrate CI to GitHub Actions, remove TravisCI and Appveyor
  * Add flake8 plugins: `flake8-pytest-style` and `flake8-annotations`
  * Add additional samples and tests for WSL1 (with the Ubuntu 18.04 distro)
  * Add additional samples for Windows 10
  * Add additional samples for MacOS
  * Add samples and tests for Ubuntu 12.04
  * Add samples for NetBSD 8 (support coming in a future release)
  * Add samples for Solaris 10 (support TBD)
  * Add samples for several versions of Android
  * Add new tests
  * Improve existing tests
  * Consolidate everything related to RPM packaging to `packaging/rpm/`. This stuff hasn't been updated since 0.6.0, may remove in the future and leave distro packaging to distro maintainers.





  * Added support for Thomas Habets' version of `arping` in addition to the existing iputils one (contributed by Ville Skyttä (@scop) in [#52](https://github.com/GhostofGoes/getmac/pull/52) and [#54](https://github.com/GhostofGoes/getmac/pull/54))
  * Added support for docker in network bridge mode (contributed by Tomasz Duda (@tomaszduda23) in [#57](https://github.com/GhostofGoes/getmac/pull/57))
  * Add CHANGELOG URL to PyPI metadata (contributed by Ville Skyttä (@scop) in [#58](https://github.com/GhostofGoes/getmac/pull/58))
  * Fixed code quality test suite errors (includes changes by Daniel Flanagan (@FlantasticDan) in [#67](https://github.com/GhostofGoes/getmac/pull/67))
  * Improved Android support (contributed by @emadmahdi in [#71](https://github.com/GhostofGoes/getmac/pull/71))
  * Minor code quality fixes (2 years of neglecting master branch)
  * Add [Code of Conduct](https://github.com/GhostofGoes/getmac/blob/main/CODE_OF_CONDUCT.md) for project contributors
  * Add [SECURITY.md](https://github.com/GhostofGoes/getmac/blob/main/SECURITY.md) for reporting security issues (e.g. vulnerabilities)
  * Deprecate Python 3.4 and 3.5
  * Issue deprecation message as a warning in addition to a log message





  * Added warning about Python 2 compatibility being dropped in 1.0.0
  * Officially support Python 3.8
  * Documented a known issue with looking up IP of a local interface on Linux/WSL (See the "Known Issues" section in the README)
  * Added remote host lookup using `arping` as last resort


  * Standardized formatting on [Black](https://github.com/psf/black)
  * Lint additions: `vulture`, several Flake8 plugins
  * Pinned test dependencies (pytest 5 dropped Python 2 support)
  * Various quality-of-life improvements for contributors/developers





  * Fixed sockets being opened and not closed when `ip` or `ip6` were used,
  which could lead to a `ResourceWarning` (GH-42)





  * OpenBSD support
  * FreeBSD support
  * Python logging is now used instead of `print` (logger: `getmac`)
  * Include tests in the source distribution
  * (CLI) Added aliases for `--no-network-requests`: `-N` and `--no-net`
  * (CLI) New argument: `-v`/`--verbose`


  * Errors are now logged instead of raising a `RuntimeWarning`
  * Improved Ubuntu support
  * Performance improvements


  * Significant increase in overall test coverage
  * Fixed and migrated the sample tests to `pytest`
  * Added tests for the CLI





  * Type annotations (PEP 484)


  * Dropped support for Python 2.6
  * Removed the usage of third-party packages (`netifaces`, `psutil`, `scapy`, and `arpreq`).
  This should improve the performance of lookups of non-existent interfaces
  or hosts, since this feature was punishing that path without providing much value.
  If you want to use these packages directly, I have a guide on how to do so on a
  [GitHub Gist](https://gist.github.com/GhostofGoes/0a8e82930e75afcefbd879a825ba4c26).


  * Significantly improved the performance of the common cases on Linux
  for interfaces and remote hosts
  * Improved POSIX interface performance. Commands specific to OSX
  will be run only on that platform, and vice-versa.
  * Significantly improved the speed and accuracy of determining
  the default interface on Linux
  * Python 2 will install an executor named getmac2 and Python 3 an
  executor named getmac so they do not conflict when both RPMs are
  installed on the same system (Credit: @hargoniX)
  * The `warnings` module will only be imported if a error/warning
  occurs (improve compatibility with some freezers, notably PyInstaller)
  * Improved system platform detection
  * Various other minor performance improvements


  * Added unit tests for the samples (Credit: @Frizz925)
  * Scripts for building RPMs in the /scripts directory (Credit: @hargoniX)
  * Improved code quality and health checks
  * Include the CHANGELOG on the PyPI project page
  * Using `pytest` for all tests now instead of `unittest`


  * Added instructions on how to build a Debian package (Credit: @kofrezo)




  * Windows default interface detection if `network_request` is enabled (Credit: @cyberhobbes)
  * Docker container (Credit: @Komish)


  * Changed project name to `getmac`. This applies to the
  command line tool, GitHub, and the documentation.
  * Use proper Python 2-compatible print functions (Credit: @martmists)


  * Support for Python 2.5. It is not feasible to test, and potentially
  breaks some useful language features, such as `__future__`
  * Variables PORT and DEBUG from top-level package imports, since changing
  them would have no actual effect on execution. Instead, use `getmac.getmac.DEBUG`.


  * Added example videos demonstrating usage (Credit: @fortunate-man)
  * Added contribution guide
  * Added documentation on ReadTheDocs
  * Added a manpage




  * Full support for Windows Subsystem for Linux (WSL). This is working for
  all features, including default interface selection! The only edge case
  is lookup of remote host IP addresses that are actually local interfaces
  will not resolve to a MAC (which should be ff-ff-ff-ff-ff-ff).

  * Require `argparse` if Python version is 2.6 or older

  * Updated tox tests: added Jython and IronPython, removed 2.6




  * New methods for remote host MACs
      * Windows: `arp`
      * POSIX: `arpreq` package
  * New methods for interface MACs
      * Windows: `wmic nic`
  * DEBUG levels: DEBUG value is now an integer, and increasing it will
  increase the amount and verbosity of output. On the CLI, it can be
  configured by increasing the amount of characters for the debug argument,
  e.g. '-dd' for DEBUG level 2.
  * Jython support (Note: on Windows Jython currently only works with interfaces)
  * IronPython support


  * **Significant** performance improvement for remote hosts. Previously,
  the average for `get_mac_address(ip='10.0.0.100')` was 1.71 seconds.
  Now, the average is `12.7 miliseconds`, with the special case of a unpopulated
  arp table being only slightly higher. This was brought about by changes in
  how the arp table is populated. The original method was to use the
  host's `ping` command to send an ICMP packet to the host. This took time,
  which heavily delayed the ability to actually get an address. The solution
  is to instead simply send a empty UDP packet to a high port. The port
  this packet is sent to can be configured using the module variable `getmac.PORT`.
  * "Fixed" resolution of localhost/127.0.0.1 by hardcoding the response.
  This should resolve a lot of problematic edge cases. I'm ok with this
  for now since I don't know of a case when it isn't all zeroes.
  * Greatly increased the reliability of getting host and interface MACs on Windows
  * Improved debugging output
  * Tightened up the size of `getmac.py`
  * Various minor stability and performance improvements
  * Add LICENSE to PyPI package


  * Support for Python 3.2 and 3.3. The total downloads from PyPI with
  those versions in August was ~53k and ~407K, respectfully. The majority
  of those are likely from automated testing (e.g. TravisCI) and not
  actual users. Therefore, I've decided to drop support to simplify
  development, especially since before 3.4 the 3.x series was still
  very much a  "work in progress".


  * Added automated tests for Windows using Appveyor
  * Tox runner for tests
  * Added github.io page
  * Improved TravisCI testing




  * Attempt to use Python modules if they're installed. This is useful
  for larger projects that already have them installed as dependencies,
  as they provide a more reliable means of getting information.
      * `psutil`: Interface MACs on all platforms
      * `scapy`: Interface MACs and Remote MACs on all platforms
      * `netifaces`: Interface MACs on Non-Windows platforms
  * New methods for remote MACs
      * POSIX: `ip neighbor show`, Abuse of `uuid._arp_getnode()`
  * New methods for Interface MACs
      * POSIX: `lanscan -ai` (HP-UX)


  * Certain critical failures that should never happen will now warn
  instead of failing silently.
  * Added a sanity check to the `ip6` argument (IPv6 addresses)
  * Improved performance in some areas
  * Improved debugging output


  * Major Bugfix: search of `proc/net/arp` would return shorter addresses in the
  same subnet if they came earlier in the sequence. Example: a search for
  `192.168.16.2` on Linux would instead return the MAC address of
  `192.168.16.254` with no errors or warning whatsoever.
  * Significantly improved default interface detection. Default
  interfaces are now properly detected on Linux and most other
  POSIX platforms with `ip` or `route` commands available, or the
  `netifaces` Python module.


  * Makefile
  * Vagrantfile to spin up testing VMs for various platforms using [Vagrant](https://www.vagrantup.com/docs/)
  * Added more samples of command output on platforms (Ubuntu 18.04 LTS)




  * Fixed identification of remote host on OSX
  * Resolved hangs and noticeable lag that occurred when "network_request"
  was True (the default)




  * Remote host for Python 3 on Windows




  * Short versions of CLI arguments (e.g. "-i" for "--interface")


  * Improved usage of "ping" across platforms and IP versions
  * Various minor tweaks for performance
  * Improved Windows detection


  * Use of ping command with hostname


  * Improvements to internal code



  Nothing changed. PyPI just won't let me push changes without a new version.




  * Checks for default interface on Linux systems
  * New methods of hunting for addresses on Windows, Mac OS X, and Linux


  * CLI will output nothing if it failed, instead of "None"
  * CLI will return with 1 on failure, 0 on success
  * No CLI arguments now implies the default host network interface
  * Added an argumnent for debugging: `--debug`
  * Removed `-d` option from `--no-network-requests`


  * Interfaces on Windows and Linux (including Bash for Windows)
  * Many bugs


  * Support for Python 2.6 on the CLI


  * Overhaul of internals




  * Addition of a terminal command: `get-mac`
  * Ability to run as a module from the command line: `python -m getmac`


  * `arp_request` argument was renamed to `network_request`
  * Updated docstring
  * Slight reduction in the size of getmac.py


  * Overhauled the README
  * Moved tests into their own folder
  * Added Python 3.7 to list of supported snakes



  * Python 2.6 compatibility



  * Fixed some addresses returning without colons
  * Added more rigorous checks on addresses before returning them



  * Remove print statements and other debugging output



  * Initial pre-alpha


pkgId: f823eb11ad1dd13ac91364ca1ebc94dda01527b75c5a92971080da712afa8c84
name: python-gevent-debuginfo
arch: aarch64
version: 22.10.2
epoch: 0
release: 1
summary: Debug information for package python-gevent
url: http://www.gevent.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4bd4e930-b4c3-4ac9-b53e-53110ced9c14
rpm_sourcerpm: python-gevent-22.10.2-1.src.rpm
location_href: 00009114-python-gevent/python-gevent-debuginfo-22.10.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-gevent.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: acc78d385c0163fcd65990516ed447788f393382e58a5edb3770d8aafb5d3dfc
name: python-gevent-debugsource
arch: aarch64
version: 22.10.2
epoch: 0
release: 1
summary: Debug sources for package python-gevent
url: http://www.gevent.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4bd4e930-b4c3-4ac9-b53e-53110ced9c14
rpm_sourcerpm: python-gevent-22.10.2-1.src.rpm
location_href: 00009114-python-gevent/python-gevent-debugsource-22.10.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-gevent.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 94840ec6fceead0ea78c4c0883e01302f5daa01d2c0cdfa405c5b614ffa96dc9
name: python-gevent-websocket
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Websocket handler for the gevent pywsgi server, a Python network library
url: https://www.gitlab.com/noppo/gevent-websocket
rpm_license: Copyright 2011-2017 Jeffrey Gelens <jeffrey@noppo.pro>
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f5710f71-ce11-4e32-89c7-695decd66fe6
location_href: 00010304-python-gevent-websocket/python-gevent-websocket-0.10.1-1.src.rpm
checksum_type: sha256
description:
          `gevent-websocket`_ is a WebSocket library for the gevent_ networking library.
          Features include:
          - Integration on both socket level or using an abstract interface.
          - RPC and PubSub framework using `WAMP`_ (WebSocket Application
            Messaging Protocol).
          - Easily extendible using a simple WebSocket protocol plugin API
              from geventwebsocket import WebSocketServer, WebSocketApplication, Resource
              class EchoApplication(WebSocketApplication):
                  def on_open(self):
                      print "Connection opened"
                  def on_message(self, message):
                      self.ws.send(message)
                  def on_close(self, reason):
                      print reason
              WebSocketServer(
                  ('', 8000),
                  Resource({'/': EchoApplication})
              ).serve_forever()
          or a low level implementation::
              from gevent import pywsgi
              from geventwebsocket.handler import WebSocketHandler
              def websocket_app(environ, start_response):
                  if environ["PATH_INFO"] == '/echo':
                      ws = environ["wsgi.websocket"]
                      message = ws.receive()
                      ws.send(message)
              server = pywsgi.WSGIServer(("", 8000), websocket_app,
                  handler_class=WebSocketHandler)
              server.serve_forever()
          More examples can be found in the ``examples`` directory. Hopefully more
          documentation will be available soon.


pkgId: 6045c2851072a67dc6493832b8747641507d3207f00ea00ac2ba0cbb6ccff66f
name: python-geventhttpclient
arch: src
version: 2.0.9
epoch: 0
release: 1
summary: http client library for gevent
url: http://github.com/gwik/geventhttpclient
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ba510c57-aff1-4f8b-9000-0e41b760cf52
location_href: 00009958-python-geventhttpclient/python-geventhttpclient-2.0.9-1.src.rpm
checksum_type: sha256
description:
  A high performance, concurrent HTTP client library for python using gevent.

  gevent.httplib support was removed in gevent 1.0, geventhttpclient now
  provides that missing functionality.

  geventhttpclient uses a fast http parser, written in C, originating from
  nginx, extracted and modified by Joyent.

  geventhttpclient has been specifically designed for high concurrency,
  streaming and support HTTP 1.1 persistent connections. More generally it is
  designed for efficiently pulling from REST APIs and streaming APIs
  like Twitter's.

  Safe SSL support is provided by default. geventhttpclient depends on
  the certifi CA Bundle. This is the same CA Bundle which ships with the
  Requests codebase, and is derived from Mozilla Firefox's canonical set.

  As of 1.5, only Python 3.6+ is fully supported (with prebuilt wheels),
  but Python 2.7 and 3.5 *should* work too.

  Use of SSL/TLS with python 2.7.9 is not recommended and may be broken.


pkgId: bcd0a793490879d665a4f2ec26287332aa0198c9eeb06e2a8ef92a870630a504
name: python-geventhttpclient-debuginfo
arch: aarch64
version: 2.0.9
epoch: 0
release: 1
summary: Debug information for package python-geventhttpclient
url: http://github.com/gwik/geventhttpclient
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-ba510c57-aff1-4f8b-9000-0e41b760cf52
rpm_sourcerpm: python-geventhttpclient-2.0.9-1.src.rpm
location_href: 00009958-python-geventhttpclient/python-geventhttpclient-debuginfo-2.0.9-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-geventhttpclient.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: fa4bf38024f19d54f30e38ecd1d459e2d3fa67c7b2a11af8f4bf459fa33cfb20
name: python-geventhttpclient-debugsource
arch: aarch64
version: 2.0.9
epoch: 0
release: 1
summary: Debug sources for package python-geventhttpclient
url: http://github.com/gwik/geventhttpclient
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-ba510c57-aff1-4f8b-9000-0e41b760cf52
rpm_sourcerpm: python-geventhttpclient-2.0.9-1.src.rpm
location_href: 00009958-python-geventhttpclient/python-geventhttpclient-debugsource-2.0.9-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-geventhttpclient.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 53f94c312472043e9df020a071b40485efa53529b7677a7c9840f6893d0702d5
name: python-geventhttpclient-wheels
arch: src
version: 1.3.1.dev3
epoch: 0
release: 1
summary: Pre-built wheels for geventhttpclient
url: http://github.com/gwik/geventhttpclient
rpm_license: LICENSE-MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c4a7792-6850-4438-afad-184228551adb
location_href: 00011482-python-geventhttpclient-wheels/python-geventhttpclient-wheels-1.3.1.dev3-1.src.rpm
checksum_type: sha256
description:
  A high performance, concurrent HTTP client library for python using gevent.

  gevent.httplib support was removed in gevent 1.0, geventhttpclient now
  provides that missing functionality.

  geventhttpclient uses a fast http parser, written in C, originating from
  nginx, extracted and modified by Joyent.

  geventhttpclient has been specifically designed for high concurrency,
  streaming and support HTTP 1.1 persistent connections. More generally it is
  designed for efficiently pulling from REST APIs and streaming APIs
  like Twitter's.

  Safe SSL support is provided by default. geventhttpclient depends on
  the certifi CA Bundle. This is the same CA Bundle which ships with the
  Requests codebase, and is derived from Mozilla Firefox's canonical set.

  Python 2.7 and 3.4+ are supported.
  Python 2.6 is no longer supported.

  Use of SSL/TLS with python 2.7.9 is not recommended and may be broken.


pkgId: 41ef90067713333f7a84df9e1c06c2fb39e2f796de5384e28aecf816720f79b1
name: python-geventhttpclient-wheels-debuginfo
arch: aarch64
version: 1.3.1.dev3
epoch: 0
release: 1
summary: Debug information for package python-geventhttpclient-wheels
url: http://github.com/gwik/geventhttpclient
rpm_license: LICENSE-MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-1c4a7792-6850-4438-afad-184228551adb
rpm_sourcerpm: python-geventhttpclient-wheels-1.3.1.dev3-1.src.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-geventhttpclient-wheels.
  Debug information is useful when developing applications that use this
  package or when debugging this package.

location_href:
  00011482-python-geventhttpclient-wheels/python-geventhttpclient-wheels-debuginfo-1.3.1.dev3-1.aarch64.rpm


pkgId: 9715284642c0ef72c9f22da79bf7f3492a03bc948a0b88955c3607f6c387b42d
name: python-geventhttpclient-wheels-debugsource
arch: aarch64
version: 1.3.1.dev3
epoch: 0
release: 1
summary: Debug sources for package python-geventhttpclient-wheels
url: http://github.com/gwik/geventhttpclient
rpm_license: LICENSE-MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-1c4a7792-6850-4438-afad-184228551adb
rpm_sourcerpm: python-geventhttpclient-wheels-1.3.1.dev3-1.src.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-geventhttpclient-wheels.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.

location_href:
  00011482-python-geventhttpclient-wheels/python-geventhttpclient-wheels-debugsource-1.3.1.dev3-1.aarch64.rpm


pkgId: a41d31d878e224238ed9e34b8bb36b343021ce7047792f1210131bc41831d870
name: python-geventhttpclient-wheels-help
arch: aarch64
version: 1.3.1.dev3
epoch: 0
release: 1
summary: Development documents and examples for geventhttpclient-wheels
url: http://github.com/gwik/geventhttpclient
rpm_license: LICENSE-MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c4a7792-6850-4438-afad-184228551adb
rpm_sourcerpm: python-geventhttpclient-wheels-1.3.1.dev3-1.src.rpm
checksum_type: sha256
description:
  A high performance, concurrent HTTP client library for python using gevent.

  gevent.httplib support was removed in gevent 1.0, geventhttpclient now
  provides that missing functionality.

  geventhttpclient uses a fast http parser, written in C, originating from
  nginx, extracted and modified by Joyent.

  geventhttpclient has been specifically designed for high concurrency,
  streaming and support HTTP 1.1 persistent connections. More generally it is
  designed for efficiently pulling from REST APIs and streaming APIs
  like Twitter's.

  Safe SSL support is provided by default. geventhttpclient depends on
  the certifi CA Bundle. This is the same CA Bundle which ships with the
  Requests codebase, and is derived from Mozilla Firefox's canonical set.

  Python 2.7 and 3.4+ are supported.
  Python 2.6 is no longer supported.

  Use of SSL/TLS with python 2.7.9 is not recommended and may be broken.

location_href:
  00011482-python-geventhttpclient-wheels/python-geventhttpclient-wheels-help-1.3.1.dev3-1.aarch64.rpm


pkgId: f3e27985e3110b96d3e3cc703286a9900e0e432a60f7b3d38bd113f236d17c4e
name: python-ggplot
arch: src
version: 0.11.5
epoch: 0
release: 1
summary: ggplot for python
url: https://github.com/yhat/ggplot/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8aa7fcc6-2a6a-416e-90d1-b66937324d46
location_href: 00011507-python-ggplot/python-ggplot-0.11.5-1.src.rpm
checksum_type: sha256
description:
  What is it?
  ~~~~~~~~~~~
  ``ggplot`` is a Python implementation of the grammar of graphics. It is
  not intended to be a feature-for-feature port of
  ```ggplot2 for R`` <https://github.com/hadley/ggplot2>`__--though there
  is much greatness in ``ggplot2``, the Python world could stand to
  benefit from it. So there **will be feature overlap**, but not
  neccessarily mimicry (after all, R is a little weird).
  You can do cool things like this:
      ggplot(diamonds, aes(x='price', color='clarity')) + \
          geom_density() + \
          scale_color_brewer(type='div', palette=7) + \
          facet_wrap('cut')
  Installation
  ~~~~~~~~~~~~
      $ pip install -U ggplot
      
      $ conda install -c conda-forge ggplot
      
      pip install git+https://github.com/yhat/ggplot.git
  Examples
  ~~~~~~~~
  Examples are the best way to learn. There is a Jupyter Notebook full of
  them. There are also notebooks that show how to do particular things
  with ggplot (i.e. `make a scatter
  plot <./docs/how-to/Making%20a%20Scatter%20Plot.ipynb>`__ or `make a
  histogram <./docs/how-to/Making%20a%20Scatter%20Plot.ipynb>`__).
  -  `docs <./docs>`__
  -  `gallery <./docs/Gallery.ipynb>`__
  -  `various examples <./examples.md>`__
  What happened to the old version that didn't work?
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  It's gone--the windows, the doors,
  `everything <https://www.youtube.com/watch?v=YuxCKv_0GZc>`__. Just
  kidding, `you can find it
  here <https://github.com/yhat/ggplot/tree/v0.6.6>`__, though I'm not
  sure why you'd want to look at it. The data grouping and manipulation
  bits were re-written (so they actually worked) with things like facets
  in mind.
  Contributing
  ~~~~~~~~~~~~
  Thanks to all of the ggplot
  `contributors <./contributors.md#contributors>`__! See
  *`contributing.md <./contributing.md>`__*.


pkgId: b43e6d6e6dc06b4d4fb5422ea7ab88cd55ddfef0e8066952869d0604fa1bc630
name: python-ghapi
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A python client for the GitHub API
url: https://github.com/fastai/ghapi
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-37beb733-cfdc-490f-a839-0361834b0b33
location_href: 00010619-python-ghapi/python-ghapi-1.0.3-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
  [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi) provides 100%
  always-updated coverage of the entire [GitHub
  API](https://docs.github.com/rest). Because we automatically convert the
  [OpenAPI
  spec](https://docs.github.com/rest/overview/openapi-description) to a
  Pythonic API, [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi) is always
  up to date with the latest changes to GitHub APIs. Furthermore, because
  this is all done dynamically, the entire package is only 35kB in size!
  Using [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi), you can automate
  nearly anything that you can do through the GitHub web interface or
  through the `git` client, such as:
  - Open, list, comment on, or modify
    [issues](https://guides.github.com/features/issues/) or [pull
    requests](https://docs.github.com/github/collaborating-with-issues-and-pull-requests/about-pull-requests)
  - Create, list, or modify [git
    tags](https://git-scm.com/book/en/v2/Git-Basics-Tagging) or [GitHub
    releases](https://docs.github.com/github/administering-a-repository/managing-releases-in-a-repository),
    including uploading release assets
  - Configure and run GitHub
    [Actions](https://github.com/features/actions) and
    [webhooks](https://docs.github.com/developers/webhooks-and-events/about-webhooks)
  - Set up GitHub [users](https://docs.github.com/rest/reference/users)
    and
    [organizations](https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/about-organizations)
  - Manage your
    [deployments](https://docs.github.com/rest/guides/delivering-deployments)
  - …and much, much more.
  There are two ways to use
  [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi): either through Python,
  or from the command line. An overview of each is provided below.

  To install, run either `pip install ghapi` or
  `conda install -c fastai ghapi`.

  Throughout this documentation, you will see code inputs and outputs
  shown in this format:
  ``` python
  1+1
  ```
      2
  We recommend reading the documentation on the [official
  site](https://ghapi.fast.ai/), rather than on GitHub, since not all the
  functionality described on this page is available through the GitHub
  viewer.
  All of the documentation is available directly as Jupyter Notebooks, for
  instance the current page you’re reading is available as a notebook
  [here](https://github.com/fastai/ghapi/blob/master/index.ipynb). To open
  any page as an interactive notebook in Google Colab, click the *Colab*
  badge at the top of the page.
  To access the GitHub API, first create a
  [`GhApi`](https://ghapi.fast.ai/core.html#ghapi) object:
  ``` python
  from ghapi.all import GhApi
  api = GhApi()
  ```
  Every part of the API includes documentation directly in the `api`
  object itself. For instance, here’s how to explore the groups of
  functionality provided by the API by displaying the object:
  ``` python
  api
  ```
  - [actions](https://docs.github.com/rest/reference/actions)
  - [activity](https://docs.github.com/rest/reference/activity)
  - [apps](https://docs.github.com/rest/reference/apps)
  - [billing](https://docs.github.com/rest/reference/billing)
  - [checks](https://docs.github.com/rest/reference/checks)
  - [code_scanning](https://docs.github.com/rest/reference/code-scanning)
  - [codes_of_conduct](https://docs.github.com/rest/reference/codes-of-conduct)
  - [emojis](https://docs.github.com/rest/reference/emojis)
  - [enterprise_admin](https://docs.github.com/rest/reference/enterprise-admin)
  - [gists](https://docs.github.com/rest/reference/gists)
  - [git](https://docs.github.com/rest/reference/git)
  - [gitignore](https://docs.github.com/rest/reference/gitignore)
  - [interactions](https://docs.github.com/rest/reference/interactions)
  - [issues](https://docs.github.com/rest/reference/issues)
  - [licenses](https://docs.github.com/rest/reference/licenses)
  - [markdown](https://docs.github.com/rest/reference/markdown)
  - [meta](https://docs.github.com/rest/reference/meta)
  - [migrations](https://docs.github.com/rest/reference/migrations)
  - [oauth_authorizations](https://docs.github.com/rest/reference/oauth-authorizations)
  - [orgs](https://docs.github.com/rest/reference/orgs)
  - [projects](https://docs.github.com/rest/reference/projects)
  - [pulls](https://docs.github.com/rest/reference/pulls)
  - [rate_limit](https://docs.github.com/rest/reference/rate-limit)
  - [reactions](https://docs.github.com/rest/reference/reactions)
  - [repos](https://docs.github.com/rest/reference/repos)
  - [scim](https://docs.github.com/rest/reference/scim)
  - [search](https://docs.github.com/rest/reference/search)
  - [secret_scanning](https://docs.github.com/rest/reference/secret-scanning)
  - [teams](https://docs.github.com/rest/reference/teams)
  - [users](https://docs.github.com/rest/reference/users)
  Then we can explore the endpoints provided by the API in each group,
  e.g. for the `git` group:
  ``` python
  api.git
  ```
  - [git.create_blob](https://docs.github.com/rest/reference/git#create-a-blob)(owner,
    repo, content, encoding): *Create a blob*
  - [git.get_blob](https://docs.github.com/rest/reference/git#get-a-blob)(owner,
    repo, file_sha): *Get a blob*
  - [git.create_commit](https://docs.github.com/rest/reference/git#create-a-commit)(owner,
    repo, message, tree, parents, author, committer, signature): *Create a
    commit*
  - [git.get_commit](https://docs.github.com/rest/reference/git#get-a-commit)(owner,
    repo, commit_sha): *Get a commit*
  - [git.list_matching_refs](https://docs.github.com/rest/reference/git#list-matching-references)(owner,
    repo, ref, per_page, page): *List matching references*
  - [git.get_ref](https://docs.github.com/rest/reference/git#get-a-reference)(owner,
    repo, ref): *Get a reference*
  - [git.create_ref](https://docs.github.com/rest/reference/git#create-a-reference)(owner,
    repo, ref, sha, key): *Create a reference*
  - [git.update_ref](https://docs.github.com/rest/reference/git#update-a-reference)(owner,
    repo, ref, sha, force): *Update a reference*
  - [git.delete_ref](https://docs.github.com/rest/reference/git#delete-a-reference)(owner,
    repo, ref): *Delete a reference*
  - [git.create_tag](https://docs.github.com/rest/reference/git#create-a-tag-object)(owner,
    repo, tag, message, object, type, tagger): *Create a tag object*
  - [git.get_tag](https://docs.github.com/rest/reference/git#get-a-tag)(owner,
    repo, tag_sha): *Get a tag*
  - [git.create_tree](https://docs.github.com/rest/reference/git#create-a-tree)(owner,
    repo, tree, base_tree): *Create a tree*
  - [git.get_tree](https://docs.github.com/rest/reference/git#get-a-tree)(owner,
    repo, tree_sha, recursive): *Get a tree*
  Here’s how to learn about an endpoint you want to use, e.g.:
  ``` python
  api.git.get_ref
  ```
  [git.get_ref](https://docs.github.com/rest/reference/git#get-a-reference)(owner,
  repo, ref): *Get a reference*
  In Jupyter Notebook full tab completion, parameter lists, etc are
  provided for all endpoints. Endpoints are called as standard Python
  methods:
  ``` python
  api.git.get_ref(owner='fastai', repo='fastcore', ref='heads/master')
  ```
  - ref: refs/heads/master
  - node_id: MDM6UmVmMjI1NDYwNTk5OnJlZnMvaGVhZHMvbWFzdGVy
  - url:
    https://api.github.com/repos/fastai/fastcore/git/refs/heads/master
  - object:
    - sha: 0e3084ed009baa51db38a640ae7c23d638af2756
    - type: commit
    - url:
      https://api.github.com/repos/fastai/fastcore/git/commits/0e3084ed009baa51db38a640ae7c23d638af2756
  To use [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi) to access
  authenticated operations (other than when running through GitHub
  Actions), you will need a GitHub [personal access
  token](https://docs.github.com/github/authenticating-to-github/creating-a-personal-access-token),
  which is a secret code used to access your account. If you don’t have
  one, [click here](https://github.com/settings/tokens/new) to create one.
  You’ll be asked to enter a name – choose anything you like, for instance
  “*ghapi*”. You’ll also be asked to choose “scopes”; this limits what
  you’ll be able to do with the API using this token. If you’re not sure,
  click “*repo*” “*gist*”, “*notifications*”, and “*workflow*”. Then click
  “Generate Token” at the bottom of the screen, and copy the token (the
  long string of letters and numbers shown). You can easily do that by
  clicking the little clipboard icon next to the token.
  Rather than pasting that token into every script, it’s easiest to save
  it as an environment variable. If you save it as `$GITHUB_TOKEN` then it
  will be most convenient, so add this to the end of your `.bashrc` or
  `.zshrc` file:
      export GITHUB_TOKEN=xxx
  …replacing the `xxx` with the token you just copied. (Don’t forget to
  `source` that file after you change it.), pass a \[GitHub token\].
  As well as your `token`, you can also pass any parameters you want
  auto-inserted into relevant methods, such as `owner` and `repo`:
  ``` python
  api = GhApi(owner='fastai', repo='fastcore', token=github_token)
  ```
  We can now repeat the previous method, but only need to pass `ref`:
  ``` python
  api.git.get_ref('heads/master')
  ```
  - ref: refs/heads/master
  - node_id: MDM6UmVmMjI1NDYwNTk5OnJlZnMvaGVhZHMvbWFzdGVy
  - url:
    https://api.github.com/repos/fastai/fastcore/git/refs/heads/master
  - object:
    - sha: 0e3084ed009baa51db38a640ae7c23d638af2756
    - type: commit
    - url:
      https://api.github.com/repos/fastai/fastcore/git/commits/0e3084ed009baa51db38a640ae7c23d638af2756
  Now that we’ve provided our token, we can use authenticated endpoints
  such as creating an issue:
  ``` python
  issue = api.issues.create("Remember to check out GhApi!")
  ```
  Since we’ve now checked out GhApi, let’s close this issue. 😎
  ``` python
  api.issues.update(issue.number, state='closed')
  ```

  You can use [`GhApi`](https://ghapi.fast.ai/core.html#ghapi) via the
  command line, and can access nearly everything in the [GitHub
  API](https://docs.github.com/rest). We provide an overview here of one
  of the command line programs,
  [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi) – see the full CLI docs
  page for details on all the programs available.
  We strongly recommend enabling tab completion for
  [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi), which you can do by
  placing the following command at the end of your `~/.bashrc` or
  `~/.zshrc` file:
  ``` bash
  eval "$(completion-ghapi --install)"
  ```
  To get started with the [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi)
  command, first find the name of the operation you wish to perform, for
  instance by searching the [full API
  reference](https://ghapi.fast.ai/fullapi.html).
  To use [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi), pass the method
  name (exactly the same as you’d use in the Python API) as the first
  parameter, followed by any positional parameters required, and then
  keyword arguments with “`--`” before each parameter name.
  For instance, [git.get_ref](https://ghapi.fast.ai/fullapi.html#git)
  takes three parameters: `owner`, `repo`, and `ref`. If we wish to pass
  the first two as positional parameters, and the last as a named
  argument, then we’d call:
  ``` bash
  ghapi git.get_ref fastai ghapi-test --ref heads/master
  ```
  If you have enabled tab completion, then after you’ve typed `ghapi g`
  try pressing <kbd>Tab</kbd>, and you’ll see all the operation groups
  available in the GitHub API that start with `g`. If you keep typing,
  e.g. `ghapi git.`, and hit <kbd>Tab</kbd> again, you’ll now see all the
  operations available in the `git` group, i.e:
      git.create_blob git.create_commit git.create_ref git.create_tag git.create_tree git.delete_ref git.get_blob git.get_commit git.get_ref git.get_tag git.get_tree git.list_matching_refs git.name git.update_ref git.verbs
  If you pass just `--help` after the operation name, you’ll see a full
  list of all parameters accepted, and a link to the official GitHub
  documentation.
  ``` bash
  ghapi git.get_ref --help
  >>> git.get_ref(owner, repo, ref)
  >>> https://docs.github.com/rest/reference/git#get-a-reference
  ```
  In addition to `--help` and the GitHub operation parameters, you can
  also pass the following:
  - `--headers`: A list of extra headers to pass, JSON-encoded
  - `--token`: A GitHub authentation token
  - `--debug`: Print requests before sending them


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: 9858eaf1b4e8f014c851078db63d0de243327a2f220f4f104538ace65e751406
name: python-google-cloud-happybase
arch: src
version: 0.33.0
epoch: 0
release: 1
summary: Client library for Google Cloud Bigtable: HappyBase layer
url: https://github.com/googleapis/google-cloud-python-happybase
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b180c13-9787-4b1b-b1ee-8967775144bc
location_href: 00013702-python-google-cloud-happybase/python-google-cloud-happybase-0.33.0-1.src.rpm
checksum_type: sha256
description:
      Python idiomatic client for `Google Cloud Platform`_ HappyBase emulation.
  |pypi| |versions|
  -  `Documentation`_
  This client is provided as a `HappyBase`_ emulation layer which uses
  Google Cloud Bigtable as the underlying storage layer.
  If you need support for other Google APIs, check out the
  `Google APIs Python Client library`_.


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: 562d9407aafb2ea0d99bf8c34710947f60a39068b700c5d5edd5a7607daed94b
name: python-googletransx
arch: src
version: 2.4.2
epoch: 0
release: 1
summary: Free Google Translate API for Python. Translates totally free of charge.
url: https://github.com/x0rkov/py-googletrans
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a80f8ec-4c30-480d-b718-ddb5240d1199
location_href: 00013600-python-googletransx/python-googletransx-2.4.2-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 2.7+ and 3.4+. (Note: Python 2 support will be dropped in the
  next major release.)
  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: 6b0bd643249f227f9bcb4f2642459b636a54575113e63d2fa606c59afbb53b54
name: python-graphene-django-optimizer
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Optimize database access inside graphene queries.
url: https://github.com/tfoxy/graphene-django-optimizer
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e3b668b-db57-4123-a75c-1005b1f06956
location_href: 00014025-python-graphene-django-optimizer/python-graphene-django-optimizer-0.9.1-1.src.rpm
checksum_type: sha256
description:
  [![build status](https://img.shields.io/travis/tfoxy/graphene-django-optimizer.svg)](https://travis-ci.com/github/tfoxy/graphene-django-optimizer)
  [![coverage](https://img.shields.io/codecov/c/github/tfoxy/graphene-django-optimizer.svg)](https://codecov.io/gh/tfoxy/graphene-django-optimizer)
  [![PyPI version](https://img.shields.io/pypi/v/graphene-django-optimizer.svg)](https://pypi.org/project/graphene-django-optimizer/)
  ![python version](https://img.shields.io/pypi/pyversions/graphene-django-optimizer.svg)
  ![django version](https://img.shields.io/pypi/djversions/graphene-django-optimizer.svg)

  Optimize queries executed by [graphene-django](https://github.com/graphql-python/graphene-django) automatically, using [`select_related`](https://docs.djangoproject.com/en/2.0/ref/models/querysets/#select-related), [`prefetch_related`](https://docs.djangoproject.com/en/2.0/ref/models/querysets/#prefetch-related) and [`only`](https://docs.djangoproject.com/en/2.0/ref/models/querysets/#only) methods of Django QuerySet.





  ```bash
  pip install graphene-django-optimizer
  ```

  *Note: If you are using Graphene V2, please install version `0.8`. v0.9 and forward will support only Graphene V3*



  Having the following schema based on [the tutorial of graphene-django](http://docs.graphene-python.org/projects/django/en/latest/tutorial-plain/#hello-graphql-schema-and-object-types) (notice the use of `gql_optimizer`)

  ```py

  import graphene

  from graphene_django.types import DjangoObjectType
  import graphene_django_optimizer as gql_optimizer

  from cookbook.ingredients.models import Category, Ingredient


  class CategoryType(DjangoObjectType):
      class Meta:
          model = Category


  class IngredientType(DjangoObjectType):
      class Meta:
          model = Ingredient


  class Query(graphene.ObjectType):
      all_categories = graphene.List(CategoryType)
      all_ingredients = graphene.List(IngredientType)

      def resolve_all_categories(root, info):
          return gql_optimizer.query(Category.objects.all(), info)

      def resolve_all_ingredients(root, info):
          return gql_optimizer.query(Ingredient.objects.all(), info)
  ```


  We will show some graphql queries and the queryset that will be executed.

  Fetching all the ingredients with the related category:

  ```graphql
  {
    allIngredients {
      id
      name
      category {
          id
          name
      }
    }
  }
  ```

  ```py

  ingredients = (
      Ingredient.objects
      .select_related('category')
      .only('id', 'name', 'category__id', 'category__name')
  )
  ```

  Fetching all the categories with the related ingredients:

  ```graphql
  {
    allCategories {
      id
      name
      ingredients {
          id
          name
      }
    }
  }
  ```

  ```py

  categories = (
      Category.objects
      .only('id', 'name')
      .prefetch_related(Prefetch(
          'ingredients',
          queryset=Ingredient.objects.only('id', 'name'),
      ))
  )
  ```




  Sometimes we need to have a custom resolver function. In those cases, the field can't be auto optimized.
  So we need to use `gql_optimizer.resolver_hints` decorator to indicate the optimizations.

  If the resolver returns a model field, we can use the `model_field` argument:

  ```py
  import graphene
  import graphene_django_optimizer as gql_optimizer


  class ItemType(gql_optimizer.OptimizedDjangoObjectType):
      product = graphene.Field('ProductType')

      @gql_optimizer.resolver_hints(
          model_field='product',
      )
      def resolve_product(root, info):
          
          if info.context.user.is_anonymous():
              return None
          return root.product
  ```

  This will automatically optimize any subfield of `product`.

  Now, if the resolver uses related fields, you can use the `select_related` argument:

  ```py
  import graphene
  import graphene_django_optimizer as gql_optimizer


  class ItemType(gql_optimizer.OptimizedDjangoObjectType):
      name = graphene.String()

      @gql_optimizer.resolver_hints(
          select_related=('product', 'shipping'),
          only=('product__name', 'shipping__name'),
      )
      def resolve_name(root, info):
          return '{} {}'.format(root.product.name, root.shipping.name)
  ```

  Notice the usage of the type `OptimizedDjangoObjectType`, which enables
  optimization of any single node queries.

  Finally, if your field has an argument for filtering results,
  you can use the `prefetch_related` argument with a function
  that returns a `Prefetch` instance as the value.

  ```py
  from django.db.models import Prefetch
  import graphene
  import graphene_django_optimizer as gql_optimizer


  class CartType(gql_optimizer.OptimizedDjangoObjectType):
      items = graphene.List(
          'ItemType',
          product_id=graphene.ID(),
      )

      @gql_optimizer.resolver_hints(
          prefetch_related=lambda info, product_id: Prefetch(
              'items',
              queryset=gql_optimizer.query(Item.objects.filter(product_id=product_id), info),
              to_attr='gql_product_id_' + product_id,
          ),
      )
      def resolve_items(root, info, product_id):
          return getattr(root, 'gql_product_id_' + product_id)
  ```

  With these hints, any field can be optimized.




  Sometimes we need to have a custom non model fields. In those cases, the optimizer would not optimize with the Django `.only()` method.
  So if we still want to optimize with the `.only()` method, we need to use `disable_abort_only` option:

  ```py

  class IngredientType(gql_optimizer.OptimizedDjangoObjectType):
      calculated_calories = graphene.String()

      class Meta:
          model = Ingredient

      def resolve_calculated_calories(root, info):
          return get_calories_for_ingredient(root.id)


  class Query(object):
      all_ingredients = graphene.List(IngredientType)

      def resolve_all_ingredients(root, info):
          return gql_optimizer.query(Ingredient.objects.all(), info, disable_abort_only=True)
  ```


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
  ```


