# packages

pkgId: 831d708c1a207848e74cd5cb9f5432bccefe524bd1e2af4d29c4ab90741cf813
name: python-django-test-without-migrations
arch: src
version: 0.6
epoch: 0
release: 1
summary: Disable migrations when running your Django tests.
url: http://github.com/henriquebastos/django-test-without-migrations/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02268ea3-84d9-40fc-a7c5-78e568524582
location_href: 00012295-python-django-test-without-migrations/python-django-test-without-migrations-0.6-1.src.rpm
checksum_type: sha256
description:
  *Test Without Migrations* is a `manage.py test` command extension.
  The new Django 1.7 and 1.8 migration backend demands that you create a migration every time you change a model.
  This can be inconvenient when you're just trying to explore your models code.
  In older Django versions, with `South` we could use the `SOUTH_TEST_MIGRATIONS` settings to tell Django to simply create all model tables without running migrations.
  This app adds this capability to Django by extending the `manage.py test` command with a `--nomigrations` option.


pkgId: 825c4a500ecd9a364c64f270154fa74ccd5326e010b37ec88041fc22eec06a88
name: python-django-test-without-migrations-help
arch: noarch
version: 0.6
epoch: 0
release: 1
summary: Development documents and examples for django-test-without-migrations
url: http://github.com/henriquebastos/django-test-without-migrations/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02268ea3-84d9-40fc-a7c5-78e568524582
rpm_sourcerpm: python-django-test-without-migrations-0.6-1.src.rpm
checksum_type: sha256
description:
  *Test Without Migrations* is a `manage.py test` command extension.
  The new Django 1.7 and 1.8 migration backend demands that you create a migration every time you change a model.
  This can be inconvenient when you're just trying to explore your models code.
  In older Django versions, with `South` we could use the `SOUTH_TEST_MIGRATIONS` settings to tell Django to simply create all model tables without running migrations.
  This app adds this capability to Django by extending the `manage.py test` command with a `--nomigrations` option.

location_href:
  00012295-python-django-test-without-migrations/python-django-test-without-migrations-help-0.6-1.noarch.rpm


pkgId: 4f1348469d7734fba4bf89b2429b06e26a7452dcb06953d331fb4f28f431f1ca
name: python-django-threadedcomments
arch: src
version: 2.0
epoch: 0
release: 1
summary: A simple yet flexible threaded commenting system.
url: https://github.com/HonzaKral/django-threadedcomments
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2daad724-ca12-44f0-8a50-223178c0a167
location_href: 00003501-python-django-threadedcomments/python-django-threadedcomments-2.0-1.src.rpm
checksum_type: sha256
description:
  *threadedcomments* is a Django application which allows for the simple creation of a threaded commenting system.
  Commenters can reply both to the original item, and reply to other comments as well.
  The application is built on top of django_comments_,
  which allows it to be easily extended by other modules.


pkgId: eaec86ebc0571e8fdca437c93ec834946ff4e29dcae83c70728153802f915454
name: python-django-tinymce
arch: src
version: 3.6.1
epoch: 0
release: 1
summary: A Django application that contains a widget to render a form field as a TinyMCE editor.
url: https://github.com/jazzband/django-tinymce
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-34ef1e24-4066-4bb9-9beb-14e286e03fda
location_href: 00011606-python-django-tinymce/python-django-tinymce-3.6.1-1.src.rpm
checksum_type: sha256
description:
  **django-tinymce** is a Django application that contains a widget to render a form field as a TinyMCE editor.


pkgId: e80abfb4cb8d6f7cc379ad9171c43e7db1988c8966d851bf968f6086afe8cf7c
name: python-django-treebeard
arch: src
version: 4.6.1
epoch: 0
release: 1
summary: Efficient tree implementations for Django
url: https://github.com/django-treebeard/django-treebeard/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-54aef02b-6128-434d-8c8d-8d65125b62a2
location_href: 00010614-python-django-treebeard/python-django-treebeard-4.6.1-1.src.rpm
checksum_type: sha256
description:
  **django-treebeard** is a library that implements efficient tree
  implementations for the Django Web Framework 2.2 and later.

  It is written by Gustavo Picón and licensed under the Apache License
  2.0.



  [![Documentation Status](https://readthedocs.org/projects/django-treebeard/badge/?version=latest)](https://django-treebeard.readthedocs.io/en/latest/?badge=latest)
  [![Tests](https://github.com/django-treebeard/django-treebeard/workflows/Tests/badge.svg)]()
  [![App Veyor](https://ci.appveyor.com/api/projects/status/mwbf062v68lhw05c?svg=true)](https://ci.appveyor.com/project/mvantellingen/django-treebeard)
  [![PyPI](https://img.shields.io/pypi/pyversions/django-treebeard.svg)]()
  [![PyPI version](https://img.shields.io/pypi/v/django-treebeard.svg)](https://pypi.org/project/django-treebeard/)




  django-treebeard is:

  -   **Flexible**: Includes 3 different tree implementations with the
      same API:
      1.  Adjacency List
      2.  Materialized Path
      3.  Nested Sets
  -   **Fast**: Optimized non-naive tree operations
  -   **Easy**: Uses Django Model Inheritance with abstract classes to
      define your own models.
  -   **Clean**: Testable and well tested code base. Code/branch test
      coverage is above 96%.

  You can find the documentation in

  > <http://django-treebeard.readthedocs.io/en/latest/>



  **django-treebeard** officially supports

  -   Django 3.2, 4.0, 4.1
  -   Python 3.8 - 3.11
  -   PostgreSQL, MySQL, MSSQL, SQLite database back-ends.


pkgId: a09ce36bd5ca1e0b53e8a568f29a6a8bca18d4833a597a8fa5e47f5cba5eeb95
name: python-django-uuslug
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A Django slugify application that also handles Unicode
url: https://github.com/un33k/django-uuslug
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e06fc4ea-e4b0-4fc9-99b2-b6ca6d1aa168
location_href: 00003503-python-django-uuslug/python-django-uuslug-2.0.0-1.src.rpm
checksum_type: sha256
description:
  **A Django slugify application that guarantees `Uniqueness` and handles `Unicode`**

  [![status-image]][status-link]
  [![version-image]][version-link]
  [![coverage-image]][coverage-link]



  In short: UUSlug == (`U`nique + `U`nicode) Slug



      1. easy_install django-uuslug
      2. pip install django-uuslug
      3. git clone http://github.com/un33k/django-uuslug
          a. cd django-uuslug
          b. run python setup.py
      4. wget https://github.com/un33k/django-uuslug/zipball/master
          a. unzip the downloaded file
          b. cd into django-uuslug-* directory
          c. run python setup.py
      5. pip install -e git+https://github.com/un33k/django-uuslug#egg=django-uuslug



  ```python

   

   from uuslug import slugify

   txt = "This is a test ---"
   r = slugify(txt)
   self.assertEqual(r, "this-is-a-test")

   txt = "___This is a test ---"
   r = slugify(txt)
   self.assertEqual(r, "this-is-a-test")

   txt = "___This is a test___"
   r = slugify(txt)
   self.assertEqual(r, "this-is-a-test")

   txt = "This -- is a ## test ---"
   r = slugify(txt)
   self.assertEqual(r, "this-is-a-test")

   txt = '影師嗎'
   r = slugify(txt)
   self.assertEqual(r, "ying-shi-ma")

   txt = 'C\'est déjà l\'été.'
   r = slugify(txt)
   self.assertEqual(r, "c-est-deja-l-ete")

   txt = 'Nín hǎo. Wǒ shì zhōng guó rén'
   r = slugify(txt)
   self.assertEqual(r, "nin-hao-wo-shi-zhong-guo-ren")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt)
   self.assertEqual(r, "jaja-lol-mememeoo-a")

   txt = 'Компьютер'
   r = slugify(txt)
   self.assertEqual(r, "kompiuter")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=9)
   self.assertEqual(r, "jaja-lol")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=15)
   self.assertEqual(r, "jaja-lol-mememe")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=50)
   self.assertEqual(r, "jaja-lol-mememeoo-a")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=15, word_boundary=True)
   self.assertEqual(r, "jaja-lol-a")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=17, word_boundary=True)
   self.assertEqual(r, "jaja-lol-mememeoo")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=18, word_boundary=True)
   self.assertEqual(r, "jaja-lol-mememeoo")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=19, word_boundary=True)
   self.assertEqual(r, "jaja-lol-mememeoo-a")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=20, word_boundary=True, separator=".")
   self.assertEqual(r, "jaja.lol.mememeoo.a")

   txt = 'jaja---lol-méméméoo--a'
   r = slugify(txt, max_length=20, word_boundary=True, separator="ZZZZZZ")
   self.assertEqual(r, "jajaZZZZZZlolZZZZZZmememeooZZZZZZa")

   txt = 'one two three four five'
   r = slugify(txt, max_length=13, word_boundary=True, save_order=True)
   self.assertEqual(r, "one-two-three")

   txt = 'one two three four five'
   r = slugify(txt, max_length=13, word_boundary=True, save_order=False)
   self.assertEqual(r, "one-two-three")

   txt = 'one two three four five'
   r = slugify(txt, max_length=12, word_boundary=True, save_order=False)
   self.assertEqual(r, "one-two-four")

   txt = 'one two three four five'
   r = slugify(txt, max_length=12, word_boundary=True, save_order=True)
   self.assertEqual(r, "one-two")

   txt = 'this has a stopword'
   r = slugify(txt, stopwords=['stopword'])
   self.assertEqual(r, 'this-has-a')

   txt = 'the quick brown fox jumps over the lazy dog'
   r = slugify(txt, stopwords=['the'])
   self.assertEqual(r, 'quick-brown-fox-jumps-over-lazy-dog')

   txt = 'Foo A FOO B foo C'
   r = slugify(txt, stopwords=['foo'])
   self.assertEqual(r, 'a-b-c')

   txt = 'Foo A FOO B foo C'
   r = slugify(txt, stopwords=['FOO'])
   self.assertEqual(r, 'a-b-c')

   txt = 'the quick brown fox jumps over the lazy dog in a hurry'
   r = slugify(txt, stopwords=['the', 'in', 'a', 'hurry'])
   self.assertEqual(r, 'quick-brown-fox-jumps-over-lazy-dog')


   

   from django.db import models
   from uuslug import uuslug

   
   class CoolSlug(models.Model):
       name = models.CharField(max_length=100)
       slug = models.CharField(max_length=200)

       def __unicode__(self):
           return self.name

       def save(self, *args, **kwargs):
           self.slug = uuslug(self.name, instance=self)
           super(CoolSlug, self).save(*args, **kwargs)

   
   
       self.slug = uuslug(self.name, instance=self, start_no=2)
       

   name = "john"
   c = CoolSlug.objects.create(name=name)
   c.save()
   print(c.slug) # => "john"

   c1 = CoolSlug.objects.create(name=name)
   c1.save()
   print(c1.slug) # => "john-1"

   c2 = CoolSlug.objects.create(name=name)
   c2.save()
   print(c2.slug) # => "john-2"


   
   class SmartTruncatedSlug(models.Model):
       name = models.CharField(max_length=19)
       slug = models.CharField(max_length=10)

       def __unicode__(self):
           return self.name

       def save(self, *args, **kwargs):
           self.slug = uuslug(self.name, instance=self, max_length=10)
           super(SmartTruncatedSlug, self).save(*args, **kwargs)

   
   class AutoTruncatedSlug(models.Model):
       name = models.CharField(max_length=19)
       slug = models.CharField(max_length=19)

       def __unicode__(self):
           return self.name

       def save(self, *args, **kwargs):
           self.slug = uuslug(self.name, instance=self)
           super(SmartTruncatedSlug, self).save(*args, **kwargs)
  ```



  To run the tests against the current environment:

      python manage.py test



  Released under a ([BSD](LICENSE.md)) license.



  X.Y.Z Version

      `MAJOR` version -- when you make incompatible API changes,
      `MINOR` version -- when you add functionality in a backwards-compatible manner, and
      `PATCH` version -- when you make backwards-compatible bug fixes.

  [status-image]: https://github.com/un33k/django-uuslug/actions/workflows/main.yml/badge.svg
  [status-link]: https://github.com/un33k/django-uuslug/actions/workflows/main.yml
  [status-image]: https://github.com/un33k/django-uuslug/actions/workflows/main.yml/badge.svg
  [version-image]: https://img.shields.io/pypi/v/django-uuslug.svg
  [version-link]: https://pypi.python.org/pypi/django-uuslug
  [coverage-image]: https://coveralls.io/repos/un33k/django-uuslug/badge.svg
  [coverage-link]: https://coveralls.io/r/un33k/django-uuslug
  [download-image]: https://img.shields.io/pypi/dm/django-uuslug.svg
  [download-link]: https://pypi.python.org/pypi/django-uuslug



  [Neekware Inc.](https://github.com/neekware)


pkgId: 0f4889b7b5e6d3979932ca8cc40f5fb507df64bd34c8196d9649391be9eec62b
name: python-django-versatileimagefield
arch: src
version: 3.0
epoch: 0
release: 1
url: http://github.com/respondcreate/django-versatileimagefield/
rpm_license: MIT License, see LICENSE
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d1e57b65-bd5c-4206-9935-b0e4ae2902ff
location_href: 00012169-python-django-versatileimagefield/python-django-versatileimagefield-3.0-1.src.rpm
checksum_type: sha256
summary:
  A drop-in replacement for django's ImageField that provides a flexible, intuitive and easily-extensible interface for creating new images from the one assigned to the field.


pkgId: 1abd9a99b28563c675dc0066b25db7978637cb55ae4d1dac9582cfc495d1fa46
name: python-django-webpack-loader
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: Transparently use webpack with django
url: https://github.com/django-webpack/django-webpack-loader
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c78734c2-f40d-4d2a-a19f-09e65ee5836c
location_href: 00010439-python-django-webpack-loader/python-django-webpack-loader-1.8.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://circleci.com/gh/django-webpack/django-webpack-loader/tree/master.svg?style=svg)](https://circleci.com/gh/django-webpack/django-webpack-loader/tree/master)
  [![Coverage Status](https://coveralls.io/repos/github/django-webpack/django-webpack-loader/badge.svg?branch=master)](https://coveralls.io/github/django-webpack/django-webpack-loader?branch=master)
  ![pyversions](https://img.shields.io/pypi/pyversions/django-webpack-loader)
  ![djversions](https://img.shields.io/pypi/djversions/django-webpack-loader)


  Use webpack to generate your static bundles without django's staticfiles or opaque wrappers.


  Django webpack loader consumes the output generated by [webpack-bundle-tracker](https://github.com/owais/webpack-bundle-tracker) and lets you use the generated bundles in django.

  A [changelog](CHANGELOG.md) is also available.




  Test cases cover Django>=2.0 on Python>=3.5. 100% code coverage is the target so we can be sure everything works anytime. It should probably work on older version of django as well but the package does not ship any test cases for them.




  ```bash
  npm install --save-dev webpack-bundle-tracker

  pip install django-webpack-loader
  ```




  Before configuring `django-webpack-loader`, let's first configure what's necessary on `webpack-bundle-tracker` side. Update your Webpack configuration file (it's usually on `webpack.config.js` in the project root). Make sure your file looks like this (adapt to your needs):

  ```javascript
  const path = require('path');
  const webpack = require('webpack');
  const BundleTracker = require('webpack-bundle-tracker');

  module.exports = {
    context: __dirname,
    entry: './assets/js/index',
    output: {
      path: path.resolve('./assets/webpack_bundles/'),
      filename: "[name]-[hash].js"
    },
    plugins: [
      new BundleTracker({filename: './webpack-stats.json'})
    ],
  }
  ```

  The configuration above expects the `index.js` (the app entrypoint file) to live inside the `/assets/js/` directory (this guide going forward will assume that all front-end related files are placed inside the `/assets/` directory, with the different kinds of files arranged within its subdirectories).

  The generated compiled files will be placed inside the `/assets/webpack_bundles/` directory and the file with the information regarding the bundles and assets (`webpack-stats.json`) will be stored in the project root.



  You must generate the front-end bundle using `webpack-bundle-tracker` before using `django-webpack-loader`. You can compile the assets and generate the bundles by running:

  ```bash
  npx webpack --config webpack.config.js --watch
  ```

  This will also generate the stats file. You can also refer to how `django-react-boilerplate` configure the [package.json](https://github.com/vintasoftware/django-react-boilerplate/blob/master/package.json) scripts for different situations.

  > ⚠️ Hot reload is available through a specific config. Check [this section](#hot-reload).

  > ⚠️ This is the recommended usage for the development environment. For **usage in production**, please refer to [this section](#usage-in-production)


  First of all, add `webpack_loader` to `INSTALLED_APPS`.
  ```python
  INSTALLED_APPS = (
    ...
    'webpack_loader',
    ...
  )
  ```

  Below is the recommended setup for the Django settings file when using `django-webpack-loader`.

  ```python
  WEBPACK_LOADER = {
    'DEFAULT': {
      'CACHE': not DEBUG,
      'STATS_FILE': os.path.join(BASE_DIR, 'webpack-stats.json'),
      'POLL_INTERVAL': 0.1,
      'IGNORE': [r'.+\.hot-update.js', r'.+\.map'],
    }
  }
  ```

  For that setup, we're using the `DEBUG` variable provided by Django. Since in a production environment (`DEBUG = False`) the assets files won't constantly change, we can safely cache the results (`CACHE=True`) and optimize our flow, as `django-webpack-loader` will read the stats file only once and store the assets files paths in memory. From that point onwards, it will use these stored paths as the source of truth. If `CACHE=False`, we'll always read the stats file to get the assets paths.
  > ⚠️ If `CACHE=True`, any changes made in the assets files will only be read when the web workers are restarted.

  During development, when the stats file changes a lot, we want to always poll for its updated version (in our case, we'll fetch it every 0.1s, as defined on `POLL_INTERVAL`).
  > ⚠️ In production (`DEBUG=False`), we'll only fetch the stats file once, so `POLL_INTERVAL` is ignored.

  While `CACHE` isn't directly related to `POLL_INTERVAL`, it's interesting to keep `CACHE` binded to the `DEBUG` logic value (in this case, the negation of the logic value) in order to only cache the assets in production, as we'd not continuously poll the stats file in that environment.

  The `STATS_FILE` parameter represents the output file produced by `webpack-bundle-tracker`. Since in the Webpack configuration file we've named it `webpack-stats.json` and stored it on the project root, we must replicate that setting on the back-end side.

  `IGNORE` is a list of regular expressions. If a file generated by Webpack matches one of the expressions, the file will not be included in the template.



  - `TIMEOUT` is the number of seconds webpack_loader should wait for webpack to finish compiling before raising an exception. `0`, `None` or leaving the value out of settings disables timeouts

  - `INTEGRITY` is flag enabling [Subresource Integrity](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity) on rendered `<script>` and `<link>` tags.  Integrity hash is get from stats file and configuration on side of `BundleTracker`, where configuration option `integrity: true` is required.

  - `LOADER_CLASS` is the fully qualified name of a python class as a string that holds the custom webpack loader. This is where behavior can be customized as to how the stats file is loaded. Examples include loading the stats file from a database, cache, external url, etc. For convenience, `webpack_loader.loader.WebpackLoader` can be extended. The `load_assets` method is likely where custom behavior will be added. This should return the stats file as an object.

  - `SKIP_COMMON_CHUNKS` is a flag which prevents already generated chunks from being included again in the same page. This should only happen if you use more than one entrypoint per Django template (multiple `render_bundle` calls). By enabling this, you can get the same default behavior of the [HtmlWebpackPlugin](https://webpack.js.org/plugins/html-webpack-plugin/). The same caveats apply as when using `skip_common_chunks` on `render_bundle`, see that section below for more details.

  Here's a simple example of loading from an external url:

    ```py
    import requests
    from webpack_loader.loader import WebpackLoader

    class ExternalWebpackLoader(WebpackLoader):
      def load_assets(self):
        url = self.config['STATS_URL']
        return requests.get(url).json()
    ```


  In order to render the front-end code into the Django templates, we use the `render_bundle` template tag.

  Its behavior is to accept a string with the name of an entrypoint from the stats file (in our case, we're using `main`, which is [the default](https://webpack.js.org/concepts/entry-points/#single-entry-shorthand-syntax)) and it'll proceed to include all files under that entrypoint. You can read more about the entrypoints concept [here](https://webpack.js.org/concepts/entry-points/).

  > ⚠️ You can also check an example on how to use multiple `entry` values [here](https://github.com/django-webpack/django-webpack-loader/tree/master/examples/code-splitting).

  Below is the basic usage for `render_bundle` within a template:

  ```HTML+Django
  {% load render_bundle from webpack_loader %}

  {% render_bundle 'main' %}
  ```

  That will render the proper `<script>` and `<link>` tags needed in your template.


  For `django-webpack-loader` to work, you must run the webpack pipeline. Please refer to [this section](#compiling-the-front-end-assets).

  In summary, you should do the following:

  ```bash

  npx webpack --config webpack.config.js --watch


  python manage.py runserver
  ```

  > ⚠️ You can also check [this example](https://github.com/django-webpack/django-webpack-loader/tree/master/examples/simple) on how to run a project with `django-webpack-loader` and `webpack-bundle-track`.


  We recommend that you keep your local bundles and the stats file outside the version control, having a production pipeline that will compile and collect the assets during the deployment phase.

  You must add `STATICFILES_DIRS` to your settings file, pointing to the directory where the static files are located. This will let `collectstatic` know where it should look at:
  ```python
  STATICFILES_DIRS = (
    os.path.join(BASE_DIR, 'assets'),
  )
  ```

  Below are the commands that should be run to compile and collect the static files (please note this may change from platform to platform):
  ```
  npm run build
  python manage.py collectstatic --noinput
  ```

  First we build the assets and, since we have `webpack-bundle-tracker` in our front-end building pipeline, the stats file will be populated. Then, we manually run collecstatic to collect the compiled assets.

  > ⚠️ Heroku is one platform that automatically runs collectstatic for you, so you need to set `DISABLE_COLLECTSTATIC=1` environment var. Instead, you must manually run collectstatic after running webpack. In Heroku, this is achieved with a `post_compile` hook. You can see an example on how to implement this flow on [django-react-boilerplate](https://github.com/vintasoftware/django-react-boilerplate/tree/master/bin).

  However, production usage for this package is **fairly flexible**. Other approaches may include keeping the production bundles in the version control and take that responsibility from the automatic pipeline. However, you must remember to always build the frontend and generate the bundle before pushing to remote.


  To run tests where `render_bundle` shows up, since we don't have `webpack-bundle-tracker` at that point to generate the stats file, the calls to render the bundle will fail. The solution is to use the `FakeWebpackLoader` in your test settings:

  ```python
  WEBPACK_LOADER['DEFAULT']['LOADER_CLASS'] = 'webpack_loader.loader.FakeWebpackLoader'
  ```




  `render_bundle` also takes a second argument which can be a file extension to match. This is useful when you want to render different types for files in separately. For example, to render CSS in head and JS at bottom we can do something like this,

  ```HTML+Django
  {% load render_bundle from webpack_loader %}

  <html>
    <head>
      {% render_bundle 'main' 'css' %}
    </head>
    <body>
      ....
      {% render_bundle 'main' 'js' %}
    </body>
  </head>
  ```


  The `is_preload=True` option in the `render_bundle` template tag can be used to add `rel="preload"` link tags.

  ```HTML+Django
  {% load render_bundle from webpack_loader %}

  <html>
    <head>
      {% render_bundle 'main' 'css' is_preload=True %}
      {% render_bundle 'main' 'js' is_preload=True %}

      {% render_bundle 'main' 'css' %}
    </head>

    <body>
      {% render_bundle 'main' 'js' %}
    </body>
  </html>
  ```


  `webpack_static` template tag provides facilities to load static assets managed by webpack in Django templates. It is like Django's built in `static` tag but for webpack assets instead.

  In the below example, `logo.png` can be any static asset shipped with any npm package.

  ```HTML+Django
  {% load webpack_static from webpack_loader %}

  <!-- render full public path of logo.png -->
  <img src="{% webpack_static 'logo.png' %}"/>
  ```
  The public path is based on `webpack.config.js` [output.publicPath](https://webpack.js.org/configuration/output/#output-publicpath).

  Please note that this approach will use the original asset file, and not a post-processed one from the Webpack pipeline, in case that file had gone through such flow (i.e.: You've imported an image on the React side and used it there, the file used within the React components will probably have a hash string on its name, etc. This processed file will be different than the one you'll grab with `webpack_static`).


  You can use the parameter `skip_common_chunks=True` or `skip_common_chunks=False` to override the global `SKIP_COMMON_CHUNKS` setting for a specific bundle.

  In order for this option to work, `django-webpack-loader` requires the `request` object to be in the context, to be able to keep track of the generated chunks.

  The `request` object is passed by default via the `django.template.context_processors.request` middleware with using the Django built-in templating system, and also with using Jinja2.

  If you don't have `request` in the context for some reason (e.g. using `Template.render` or `render_to_string` directly without passing the request), you'll get warnings on the console and the common chunks will remain duplicated.


  The `suffix` option can be used to append a string at the end of the file URL. For instance, it can be used if your webpack configuration emits compressed `.gz` files.
  qwe
  ```HTML+Django
  {% load render_bundle from webpack_loader %}
  <html>
    <head>
      <meta charset="UTF-8">
      <title>Example</title>
      {% render_bundle 'main' 'css' %}
    </head>
    <body>
      {% render_bundle 'main' 'js' suffix='.gz' %}
    </body>
  </html>
  ```


  Version 1.0 and up of `django-webpack-loader` also supports multiple Webpack configurations. The following configuration defines 2 Webpack stats files in settings and uses the `config` argument in the template tags to influence which stats file to load the bundles from.

  ```python
  WEBPACK_LOADER = {
      'DEFAULT': {
          'BUNDLE_DIR_NAME': 'bundles/',
          'STATS_FILE': os.path.join(BASE_DIR, 'webpack-stats.json'),
      },
      'DASHBOARD': {
          'BUNDLE_DIR_NAME': 'dashboard_bundles/',
          'STATS_FILE': os.path.join(BASE_DIR, 'webpack-stats-dashboard.json'),
      }
  }
  ```

  ```HTML+Django
  {% load render_bundle from webpack_loader %}

  <html>
    <body>
      ....
      {% render_bundle 'main' 'js' 'DEFAULT' %}
      {% render_bundle 'main' 'js' 'DASHBOARD' %}

      <!-- or render all files from a bundle -->
      {% render_bundle 'main' config='DASHBOARD' %}

      <!-- the following tags do the same thing -->
      {% render_bundle 'main' 'css' 'DASHBOARD' %}
      {% render_bundle 'main' extension='css' config='DASHBOARD' %}
      {% render_bundle 'main' config='DASHBOARD' extension='css' %}

      <!-- add some extra attributes to the tag -->
      {% render_bundle 'main' 'js' 'DEFAULT' attrs='async charset="UTF-8"'%}
    </body>
  </head>
  ```



  If you need the URL to an asset without the HTML tags, the `get_files` template tag can be used. A common use case is specifying the URL to a custom css file for a Javascript plugin.

  `get_files` works exactly like `render_bundle` except it returns a list of matching files and lets you assign the list to a custom template variable.

  Each object in the returned list has 2 properties:
  1. `name`, which is the name of a chunk from the stats file;
  2. `url`, which can be:
    1. The `publicPath` if the asset has one;
    2. The `path` to the asset in the static files storage, if the asset doesn't have a `publicPath`.

  For example:

  ```HTML+Django
  {% load get_files from webpack_loader %}

  {% get_files 'editor' 'css' as editor_css_files %}
  CKEDITOR.config.contentsCss = '{{ editor_css_files.0.url }}';

  <!-- or list down name and url for every file -->
  <ul>
  {% for css_file in editor_css_files %}
      <li>{{ css_file.name }} : {{ css_file.url }}</li>
  {% endfor %}
  </ul>
  ```


  In case you wish to use [code-splitting](https://webpack.js.org/guides/code-splitting/), follow the recipe below on the Javascript side.

  Create your entrypoint file and add elements to the DOM, while leveraging the lazy imports.
  ```js
  // src/principal.js
  function getComponent() {
    return import(/* webpackChunkName: "lodash" */ 'lodash').then(({ default: _ }) => {
      const element = document.createElement('div');

      element.innerHTML = _.join(['Hello', 'webpack'], ' ');

      return element;
    }).catch(error => 'An error occurred while loading the component');
  }

  getComponent().then((component) => {
    document.body.appendChild(component);
  })
  ```

  On your configuration file, do the following:
  ```js
  // webpack.config.js
  module.exports = {
    context: __dirname,
    entry: {
      principal: './src/principal',
    },
    output: {
      path: path.resolve('./dist/'),
      // publicPath should match your STATIC_URL config.
      // This is required otherwise webpack will try to fetch
      // our chunk generated by the dynamic import from "/" instead of "/dist/".
      publicPath: '/dist/',
      chunkFilename: '[name].bundle.js',
      filename: "[name]-[hash].js"
    },
    plugins: [
      new BundleTracker({ filename: './webpack-stats.json' })
    ]
  }
  ```

  If you're using Webpack 5 instead of 4, do the following:
  - Change `filename: "[name]-[hash].js"` to `filename: "[name]-[fullhash].js"`;
  - Remove `/* webpackChunkName: "lodash" */`, which is not needed anymore.

  On your template, render the bundle as usual:

  ```HTML+Django
  <!-- index.html -->
  {% load render_bundle from webpack_loader %}

  <!DOCTYPE html>
  <html>
    <head>
      <meta charset="utf-8">
      <title>My test page</title>
    </head>
    <body>
      <p>This is my page</p>

      {% render_bundle 'principal' 'js' %}
    </body>
  </html>
  ```


  In case you wish to enable hot reload for your project using `django-webpack-loader` and `webpack-bundle-tracker`, please check out [this example](https://github.com/django-webpack/django-webpack-loader/tree/master/examples/hot-reload), in particular how [server.js](https://github.com/django-webpack/django-webpack-loader/blob/master/examples/hot-reload/server.js) and [webpack.config.js](https://github.com/django-webpack/django-webpack-loader/blob/master/examples/hot-reload/webpack.config.js) are configured.



  If you need to output your assets in a jinja template, we provide a Jinja2 extension that's compatible with [django-jinja](https://github.com/niwinz/django-jinja).

  To install the extension, add it to the `TEMPLATES` configuration in the `["OPTIONS"]["extension"]` list.

  ```python
  from django_jinja.builtins import DEFAULT_EXTENSIONS
  TEMPLATES = [
    {
      "BACKEND": "django_jinja.backend.Jinja2",
      "OPTIONS": {
        "extensions": DEFAULT_EXTENSIONS + [
          "webpack_loader.contrib.jinja2ext.WebpackExtension",
        ],
      }
    }
  ]
  ```

  Then in your base jinja template, do:

  ```HTML
  {{ render_bundle('main') }}
  ```



  In order to use `django-webpack-loader>=1.0.0`, you must ensure that `webpack-bundle-tracker@1.0.0` is being used on the JavaScript side. It's recommended that you always keep at least minor version parity across both packages, for full compatibility.

  This is necessary because the formatting of `webpack-stats.json` that `webpack-bundle-tracker` outputs has changed starting at version `1.0.0-alpha.1`. Starting at `django-webpack-loader==1.0.0`, this is the only formatting accepted here, meaning that other versions of that package don't output compatible files anymore, thereby breaking compatibility with older `webpack-bundle-tracker` releases.



  [![alt text](https://avatars2.githubusercontent.com/u/5529080?s=80&v=4 "Vinta Logo")](https://www.vinta.com.br/)

  This project is maintained by [Vinta Software](https://www.vinta.com.br/) and is used in products of Vinta's clients. We are always looking for exciting work, so if you need any commercial support, feel free to get in touch: contact@vinta.com.br


pkgId: 83f360d9e15294788bd68727a5185e3efaaa46d52af3a3c763ab0548ad02d7b3
name: python-django-webtest
arch: src
version: 1.9.10
epoch: 0
release: 1
url: https://github.com/django-webtest/django-webtest
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4a9928c8-aaa0-4e0a-b56f-43f431a2301d
location_href: 00012322-python-django-webtest/python-django-webtest-1.9.10-1.src.rpm
checksum_type: sha256
summary:
  Instant integration of Ian Bicking's WebTest (http://docs.pylonsproject.org/projects/webtest/) with Django's testing framework.


pkgId: 467ee7a3185c87186c225df10eb0d7c439caefa4e05bf152576ce4a31688d551
name: python-djangoql
arch: src
version: 0.17.1
epoch: 0
release: 1
summary: DjangoQL: Advanced search language for Django
url: https://github.com/ivelum/djangoql/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0450f26c-f6b4-4da4-8f9e-6e0e11039a0a
location_href: 00003504-python-djangoql/python-djangoql-0.17.1-1.src.rpm
checksum_type: sha256
description:
  Advanced search language for Django, with auto-completion. Supports logical
  operators, parenthesis, table joins, and works with any Django model. Tested on
  Python 2.7, 3.5 - 3.10, Django 1.8 - 4.0. The auto-completion feature has been
  tested in Chrome, Firefox, Safari, IE9+.
  See a video: `DjangoQL demo <https://youtu.be/oKVff4dHZB8>`_
  DjangoQL is used by:
  |logo1| |logo2| |logo3| |logo4|
  Is your project using DjangoQL? Please submit a PR and let us know!


pkgId: d288a967b96c6b372b61a6ccf4d0893746d7d3c64a6ccbada36f7d9e320b6cb2
name: python-djangorestframework
arch: src
version: 3.14.0
epoch: 0
release: 1
summary: Web APIs for Django, made easy.
url: https://www.django-rest-framework.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c164ab3-9d17-4c95-bdee-2ec43978855a
location_href: 00009219-python-djangorestframework/python-djangorestframework-3.14.0-1.src.rpm
checksum_type: sha256
description:
  REST framework is a *collaboratively funded project*. If you use
  REST framework commercially we strongly encourage you to invest in its
  continued development by [signing up for a paid plan][funding].
  The initial aim is to provide a single full-time position on REST framework.
  *Every single sign-up makes a significant impact towards making that possible.*
  [![][sentry-img]][sentry-url]
  [![][stream-img]][stream-url]
  [![][spacinov-img]][spacinov-url]
  [![][retool-img]][retool-url]
  [![][bitio-img]][bitio-url]
  [![][posthog-img]][posthog-url]
  [![][cryptapi-img]][cryptapi-url]
  [![][fezto-img]][fezto-url]


pkgId: 4e083ac7046c31314d3693f4ec0b8008bce22cc03aecb34189faa83efc8f5a96
name: python-djangorestframework-api-key
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: API key permissions for the Django REST Framework
url: http://github.com/florimondmanca/djangorestframework-api-key
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-138cdd62-c69c-4c7c-912a-763f16b6d936
location_href: 00011655-python-djangorestframework-api-key/python-djangorestframework-api-key-2.3.0-1.src.rpm
checksum_type: sha256
description:
  API key permissions for the [Django REST Framework](https://www.django-rest-framework.org).

  <div>
    <a href="https://dev.azure.com/florimondmanca/public/_build/latest?definitionId=7&branchName=master">
        <img src="https://dev.azure.com/florimondmanca/public/_apis/build/status/florimondmanca.djangorestframework-api-key?branchName=master" alt="build status"/>
    </a>
    <a href="https://codecov.io/gh/florimondmanca/djangorestframework-api-key">
        <img src="https://codecov.io/gh/florimondmanca/djangorestframework-api-key/branch/master/graph/badge.svg" alt="coverage">
    </a>
    <a href="https://pypi.org/project/djangorestframework-api-key">
        <img src="https://badge.fury.io/py/djangorestframework-api-key.svg" alt="package version"/>
    </a>
  </div>
  <div>
    <img src="https://img.shields.io/pypi/pyversions/djangorestframework-api-key.svg" alt="python versions"/>
    <img src="https://img.shields.io/pypi/djversions/djangorestframework-api-key.svg?colorB=44b78b" alt="django versions"/>
    <img src="https://img.shields.io/badge/drf-3.8+-7f2d2d.svg" alt="drf versions"/>
  </div>



  **Django REST Framework API Key is a library for allowing server-side clients to safely use your API.** These clients are typically third-party backends and services (i.e. _machines_) which do not have a user account but still need to interact with your API in a secure way.



  - ✌️ **Simple to use**: create, view and revoke API keys via the admin site, or use built-in helpers to create API keys programmatically.
  - 🔒 **As secure as possible**: API keys are treated with the same level of care as user passwords. They are hashed using the default password hasher before being stored in the database, and only visible at creation.
  - 🎨 **Customizable**: satisfy specific business requirements by building your own customized API key models, permission classes and admin panels.



  There are important security aspects you need to consider before switching to an API key access control scheme. We've listed some of these in [Security caveats](docs/security.md#caveats), including serving your API over HTTPS.

  Besides, see [Why and when to use API keys](https://cloud.google.com/endpoints/docs/openapi/when-why-api-key#top_of_page) for hints on whether API keys can fit your use case.

  API keys are ideal in the following situations:

  - Blocking anonymous traffic.
  - Implementing API key-based [throttling](https://www.django-rest-framework.org/api-guide/throttling/). (Note that Django REST Framework already has may built-in utilities for this use case.)
  - Identifying usage patterns by logging request information along with the API key.

  They can also present enough security for authorizing internal services, such as your API server and an internal frontend application.

  > Please note that this package is NOT meant for authentication. You should NOT use this package to identify individual users, either directly or indirectly.
  >
  > If you need server-to-server authentication, you may want to consider OAuth instead. Libraries such as [django-oauth-toolkit](https://django-oauth-toolkit.readthedocs.io/en/latest/index.html) can help.



  Install with `pip`:

  ```bash
  pip install "djangorestframework-api-key==2.*"
  ```

  _**Note**: It is highly recommended to **pin your dependency** to the latest major version (as depicted above), as breaking changes may and will happen between major releases._

  Add the app to your `INSTALLED_APPS`:

  ```python


  INSTALLED_APPS = [
    
    "rest_framework",
    "rest_framework_api_key",
  ]
  ```

  Run the included migrations:

  ```bash
  python manage.py migrate
  ```

  To learn how to configure permissions and manage API keys, head to the [Documentation](https://florimondmanca.github.io/djangorestframework-api-key).



  See [CHANGELOG.md](https://github.com/florimondmanca/djangorestframework-api-key/tree/master/CHANGELOG.md).



  See [CONTRIBUTING.md](https://github.com/florimondmanca/djangorestframework-api-key/tree/master/CONTRIBUTING.md).



  MIT




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

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).





  - Drop support for Python 3.6, which has reached EOL. (Pull #210)



  - Fix migration 0004 when run against a non default database. (Pull #215)





  - Added support for Django config detection for different versions (PR #187)



  - Add official support for Django 3.2 and Python 3.9 and 3.10 (PR #189)
  - Bumped `hashed_key` field's `max_length` from 100 to 150 to address length issue with `argon2-cffi` (PR #193)





  - Add support for custom API `keyword`. (Pull #175)



  **NOTE**: this release drops compatibility with certain Python and Django versions, but contains no other breaking changes. See [Upgrade to 2.0](https://florimondmanca.github.io/djangorestframework-api-key/upgrade/2.0/) for detailed migration steps.



  - Dropped support for Django 2.0 and Django 2.1. (Pull #126)
  - Dropped support for Python 3.5. (Pull #84)



  - Add support for Django 3.0. (Pull #82)
  - Add support for Python 3.8. (Pull #81)
  - Add `BaseAPIKeyManager.get_from_key()` to allow retrieving API keys from views. (Pull #93)
  - Add type annotations, and partial support for `django-stubs` and `djangorestframework-stubs`. (Pull #88, Pull #122)





  - Now ships with type annotations ([PEP 561](https://www.python.org/dev/peps/pep-0561/)). (Pull #73)



  **NOTE**: this release contains migrations. See [Upgrade to v1.4](https://florimondmanca.github.io/djangorestframework-api-key/upgrade/1.4/) for detailed instructions.



  - The `prefix` and `hashed_key` are now stored in dedicated fields on the `APIKey` model. (Pull #62)



  **NOTE**: this release contains migrations. In your Django project, run them using:

  ```python
  python manage.py migrate rest_framework_api_key
  ```



  - Add abstract API key model (`AbstractAPIKey`) and base manager (`BaseAPIKeyManager`). (Pull #36)
  - Add base permissions (`BaseHasAPIKey`). (Pull #46)



  - The `id` field of `APIKey` is now non-`editable`.
  - `APIKeyModelAdmin` does not define `fieldsets` anymore. This allows subclasses to benefit from Django's automatic fieldsets. (Pull #52)



  - Explicitly use `utf-8` encoding in `setup.py`, which could previously lead to issues when installing on certain systems. (Pull #58)





  - Fixed a critical bug in `APIKeyModelAdmin` that prevented `rest_framework_api_key` from passing Django system checks. (Pull #39)



  **NOTE**: this release contains migrations. In your Django project, run them using:

  ```python
  python manage.py migrate rest_framework_api_key
  ```



  - API keys can now have an optional `expiry_date`. (Pull #33) `HasAPIKey` denies access if the API key has expired, i.e. if `expiry_date`, if set, is in the past.
  - It is now possible to search by `prefix` in the API key admin panel.
  - The `prefix` is now displayed in the edit view of the API key admin panel.





  - Improve documentation on which password hasher is used.
  - Add tests against the Argon2, BcryptSHA256 and PBKDF2SHA1 hashers. (Pull #32)



  - Fix support for password hashers that generate hashes that contain dots. (Pull #31)



  **This release is incompatible with 0.x**. See [Upgrade to 1.0](https://florimondmanca.github.io/djangorestframework-api-key/upgrade/1.4/) for migration steps.



  - Remove `HasAPIKeyOrIsAuthenticated` permission class. You should use bitwise composition now, e.g. `HasAPIKey | IsAuthenticated`.
  - Drop the `DRF_API_KEY_*` settings. (Pull #19)



  - Switch to a new API key generation and validation scheme. Clients must now authorize using a single API key header (Pull #19). The header is `Authorization` by default. It can be customized using the `API_KEY_CUSTOM_HEADER` setting (Pull #26). Use the `name` field to identify clients.



  - Add support for Django 2.2. (Pull #27)
  - Add programmatic API key creation using `APIKey.objects.create_key()`. (Pull #19)



  - Improved API key storage using Django's password hashing helpers. (Uses the default Django password hasher.) (Pull #19)





  - Drop support for Python 3.4. Only 3.5, 3.6 and 3.7 are supported now.
  - Drop support for Django < 2.0. Only 2.0 and 2.1 are supported now.



  - `HasAPIKey` now implements `.has_object_permissions()`, which allows to compose it with other permission classes and perform object-level permission checks. (Pull #25)



  _Initial changelog entry._



  - `APIKey` model.
  - `HasAPIKey` and `HasAPIKeyOrIsAuthenticated` permission classes.
  - Generate, view and revoke API keys from the Django admin.
  - Authenticate requests using the `Api-Token` and `Api-Secret-Key` headers. Customizable via the `DRF_API_KEY_TOKEN_HEADER` and `DRF_API_KEY_SECRET_KEY_HEADER` settings.


pkgId: 8851e15d667f7960e2cdc36bc5ed86338fa4a849f418b2e44a13ce5450f066f1
name: python-djangorestframework-api-key-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for djangorestframework-api-key
url: http://github.com/florimondmanca/djangorestframework-api-key
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-138cdd62-c69c-4c7c-912a-763f16b6d936
rpm_sourcerpm: python-djangorestframework-api-key-2.3.0-1.src.rpm
checksum_type: sha256
description:
  API key permissions for the [Django REST Framework](https://www.django-rest-framework.org).

  <div>
    <a href="https://dev.azure.com/florimondmanca/public/_build/latest?definitionId=7&branchName=master">
        <img src="https://dev.azure.com/florimondmanca/public/_apis/build/status/florimondmanca.djangorestframework-api-key?branchName=master" alt="build status"/>
    </a>
    <a href="https://codecov.io/gh/florimondmanca/djangorestframework-api-key">
        <img src="https://codecov.io/gh/florimondmanca/djangorestframework-api-key/branch/master/graph/badge.svg" alt="coverage">
    </a>
    <a href="https://pypi.org/project/djangorestframework-api-key">
        <img src="https://badge.fury.io/py/djangorestframework-api-key.svg" alt="package version"/>
    </a>
  </div>
  <div>
    <img src="https://img.shields.io/pypi/pyversions/djangorestframework-api-key.svg" alt="python versions"/>
    <img src="https://img.shields.io/pypi/djversions/djangorestframework-api-key.svg?colorB=44b78b" alt="django versions"/>
    <img src="https://img.shields.io/badge/drf-3.8+-7f2d2d.svg" alt="drf versions"/>
  </div>



  **Django REST Framework API Key is a library for allowing server-side clients to safely use your API.** These clients are typically third-party backends and services (i.e. _machines_) which do not have a user account but still need to interact with your API in a secure way.



  - ✌️ **Simple to use**: create, view and revoke API keys via the admin site, or use built-in helpers to create API keys programmatically.
  - 🔒 **As secure as possible**: API keys are treated with the same level of care as user passwords. They are hashed using the default password hasher before being stored in the database, and only visible at creation.
  - 🎨 **Customizable**: satisfy specific business requirements by building your own customized API key models, permission classes and admin panels.



  There are important security aspects you need to consider before switching to an API key access control scheme. We've listed some of these in [Security caveats](docs/security.md#caveats), including serving your API over HTTPS.

  Besides, see [Why and when to use API keys](https://cloud.google.com/endpoints/docs/openapi/when-why-api-key#top_of_page) for hints on whether API keys can fit your use case.

  API keys are ideal in the following situations:

  - Blocking anonymous traffic.
  - Implementing API key-based [throttling](https://www.django-rest-framework.org/api-guide/throttling/). (Note that Django REST Framework already has may built-in utilities for this use case.)
  - Identifying usage patterns by logging request information along with the API key.

  They can also present enough security for authorizing internal services, such as your API server and an internal frontend application.

  > Please note that this package is NOT meant for authentication. You should NOT use this package to identify individual users, either directly or indirectly.
  >
  > If you need server-to-server authentication, you may want to consider OAuth instead. Libraries such as [django-oauth-toolkit](https://django-oauth-toolkit.readthedocs.io/en/latest/index.html) can help.



  Install with `pip`:

  ```bash
  pip install "djangorestframework-api-key==2.*"
  ```

  _**Note**: It is highly recommended to **pin your dependency** to the latest major version (as depicted above), as breaking changes may and will happen between major releases._

  Add the app to your `INSTALLED_APPS`:

  ```python


  INSTALLED_APPS = [
    
    "rest_framework",
    "rest_framework_api_key",
  ]
  ```

  Run the included migrations:

  ```bash
  python manage.py migrate
  ```

  To learn how to configure permissions and manage API keys, head to the [Documentation](https://florimondmanca.github.io/djangorestframework-api-key).



  See [CHANGELOG.md](https://github.com/florimondmanca/djangorestframework-api-key/tree/master/CHANGELOG.md).



  See [CONTRIBUTING.md](https://github.com/florimondmanca/djangorestframework-api-key/tree/master/CONTRIBUTING.md).



  MIT




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

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).





  - Drop support for Python 3.6, which has reached EOL. (Pull #210)



  - Fix migration 0004 when run against a non default database. (Pull #215)





  - Added support for Django config detection for different versions (PR #187)



  - Add official support for Django 3.2 and Python 3.9 and 3.10 (PR #189)
  - Bumped `hashed_key` field's `max_length` from 100 to 150 to address length issue with `argon2-cffi` (PR #193)





  - Add support for custom API `keyword`. (Pull #175)



  **NOTE**: this release drops compatibility with certain Python and Django versions, but contains no other breaking changes. See [Upgrade to 2.0](https://florimondmanca.github.io/djangorestframework-api-key/upgrade/2.0/) for detailed migration steps.



  - Dropped support for Django 2.0 and Django 2.1. (Pull #126)
  - Dropped support for Python 3.5. (Pull #84)



  - Add support for Django 3.0. (Pull #82)
  - Add support for Python 3.8. (Pull #81)
  - Add `BaseAPIKeyManager.get_from_key()` to allow retrieving API keys from views. (Pull #93)
  - Add type annotations, and partial support for `django-stubs` and `djangorestframework-stubs`. (Pull #88, Pull #122)





  - Now ships with type annotations ([PEP 561](https://www.python.org/dev/peps/pep-0561/)). (Pull #73)



  **NOTE**: this release contains migrations. See [Upgrade to v1.4](https://florimondmanca.github.io/djangorestframework-api-key/upgrade/1.4/) for detailed instructions.



  - The `prefix` and `hashed_key` are now stored in dedicated fields on the `APIKey` model. (Pull #62)



  **NOTE**: this release contains migrations. In your Django project, run them using:

  ```python
  python manage.py migrate rest_framework_api_key
  ```



  - Add abstract API key model (`AbstractAPIKey`) and base manager (`BaseAPIKeyManager`). (Pull #36)
  - Add base permissions (`BaseHasAPIKey`). (Pull #46)



  - The `id` field of `APIKey` is now non-`editable`.
  - `APIKeyModelAdmin` does not define `fieldsets` anymore. This allows subclasses to benefit from Django's automatic fieldsets. (Pull #52)



  - Explicitly use `utf-8` encoding in `setup.py`, which could previously lead to issues when installing on certain systems. (Pull #58)





  - Fixed a critical bug in `APIKeyModelAdmin` that prevented `rest_framework_api_key` from passing Django system checks. (Pull #39)



  **NOTE**: this release contains migrations. In your Django project, run them using:

  ```python
  python manage.py migrate rest_framework_api_key
  ```



  - API keys can now have an optional `expiry_date`. (Pull #33) `HasAPIKey` denies access if the API key has expired, i.e. if `expiry_date`, if set, is in the past.
  - It is now possible to search by `prefix` in the API key admin panel.
  - The `prefix` is now displayed in the edit view of the API key admin panel.





  - Improve documentation on which password hasher is used.
  - Add tests against the Argon2, BcryptSHA256 and PBKDF2SHA1 hashers. (Pull #32)



  - Fix support for password hashers that generate hashes that contain dots. (Pull #31)



  **This release is incompatible with 0.x**. See [Upgrade to 1.0](https://florimondmanca.github.io/djangorestframework-api-key/upgrade/1.4/) for migration steps.



  - Remove `HasAPIKeyOrIsAuthenticated` permission class. You should use bitwise composition now, e.g. `HasAPIKey | IsAuthenticated`.
  - Drop the `DRF_API_KEY_*` settings. (Pull #19)



  - Switch to a new API key generation and validation scheme. Clients must now authorize using a single API key header (Pull #19). The header is `Authorization` by default. It can be customized using the `API_KEY_CUSTOM_HEADER` setting (Pull #26). Use the `name` field to identify clients.



  - Add support for Django 2.2. (Pull #27)
  - Add programmatic API key creation using `APIKey.objects.create_key()`. (Pull #19)



  - Improved API key storage using Django's password hashing helpers. (Uses the default Django password hasher.) (Pull #19)





  - Drop support for Python 3.4. Only 3.5, 3.6 and 3.7 are supported now.
  - Drop support for Django < 2.0. Only 2.0 and 2.1 are supported now.



  - `HasAPIKey` now implements `.has_object_permissions()`, which allows to compose it with other permission classes and perform object-level permission checks. (Pull #25)



  _Initial changelog entry._



  - `APIKey` model.
  - `HasAPIKey` and `HasAPIKeyOrIsAuthenticated` permission classes.
  - Generate, view and revoke API keys from the Django admin.
  - Authenticate requests using the `Api-Token` and `Api-Secret-Key` headers. Customizable via the `DRF_API_KEY_TOKEN_HEADER` and `DRF_API_KEY_SECRET_KEY_HEADER` settings.

location_href:
  00011655-python-djangorestframework-api-key/python-djangorestframework-api-key-help-2.3.0-1.noarch.rpm


pkgId: f4999e99e4a958cfab19b764696fea7ae5bbb69aa3c41fe1fce8e93ec405fe78
name: python-djangorestframework-camel-case
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Camel case JSON support for Django REST framework.
url: https://github.com/vbabiy/djangorestframework-camel-case
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd53c8d2-6cc6-4a92-981a-9b01e8845977
checksum_type: sha256
location_href:
  00011030-python-djangorestframework-camel-case/python-djangorestframework-camel-case-1.4.2-1.src.rpm


pkgId: 465c489382e8bc12cd2b3e6914bad8e48b5d3350bd18fd59cb008b9df1c2433b
name: python-djangorestframework-camel-case-help
arch: noarch
version: 1.4.2
epoch: 0
release: 1
summary: Development documents and examples for djangorestframework-camel-case
url: https://github.com/vbabiy/djangorestframework-camel-case
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd53c8d2-6cc6-4a92-981a-9b01e8845977
rpm_sourcerpm: python-djangorestframework-camel-case-1.4.2-1.src.rpm
checksum_type: sha256
location_href:
  00011030-python-djangorestframework-camel-case/python-djangorestframework-camel-case-help-1.4.2-1.noarch.rpm


pkgId: ce182d1e20a201f13c7252cf3a03182d549344e4a0438204751a68741438aa9b
name: python-djangorestframework-gis
arch: src
version: 1.0
epoch: 0
release: 1
summary: Geographic add-ons for Django Rest Framework
url: https://github.com/openwisp/django-rest-framework-gis
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-60926072-8e7b-448e-8729-cd1829498e9d
location_href: 00012166-python-djangorestframework-gis/python-djangorestframework-gis-1.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage Status| |Requirements Status| |PyPI version| |PyPI downloads| |Black|
  Geographic add-ons for Django Rest Framework - `Mailing
  List <http://bit.ly/1M4sLTp>`__.


pkgId: d6af3cd5b2a1645bf962fda3b92b9b9cceb13334c4b9aa6c5a764def61afb39d
name: python-djangorestframework-jwt
arch: src
version: 1.11.0
epoch: 0
release: 1
summary: JSON Web Token based authentication for Django REST framework
url: https://github.com/GetBlimp/django-rest-framework-jwt
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5b229784-8fef-4c1b-9057-1e3a6beef9a9
location_href: 00010320-python-djangorestframework-jwt/python-djangorestframework-jwt-1.11.0-1.src.rpm
checksum_type: sha256
description:
  |build-status-image| |pypi-version|
  **JSON Web Token Authentication support for Django REST Framework**
  Full documentation for the project is available at `docs`_.


pkgId: dd2e680c572e36f0cbdc1c1a9d7d44f9245abf7a207befc36dca7c1b801c4171
name: python-djangorestframework-recursive-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for djangorestframework-recursive
url: https://github.com/heywbj/django-rest-framework-recursive
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f78dec55-3fae-4b73-b519-4a60e93ff0e3
rpm_sourcerpm: python-djangorestframework-recursive-0.1.2-1.src.rpm
checksum_type: sha256
location_href:
  00012856-python-djangorestframework-recursive/python-djangorestframework-recursive-help-0.1.2-1.noarch.rpm


pkgId: d539a373df719adef7e02bc289af9401df339765557b05ce8208098e2605f5e3
name: python-djangorestframework-stubs
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: PEP-484 stubs for django-rest-framework
url: https://github.com/typeddjango/djangorestframework-stubs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5b2f42c7-c489-4c90-8cb6-a63caefdc168
location_href: 00010934-python-djangorestframework-stubs/python-djangorestframework-stubs-1.10.0-1.src.rpm
checksum_type: sha256
description:
  <img src="http://mypy-lang.org/static/mypy_light.svg" alt="mypy logo" width="300px"/>



  [![Build Status](https://travis-ci.com/typeddjango/djangorestframework-stubs.svg?branch=master)](https://travis-ci.com/typeddjango/djangorestframework-stubs)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![Gitter](https://badges.gitter.im/mypy-django/Lobby.svg)](https://gitter.im/mypy-django/Lobby)


  Mypy stubs for [Django REST Framework](https://pypi.org/project/djangorestframework/).
  Supports Python 3.7 and up.



  ```bash
  pip install djangorestframework-stubs[compatible-mypy]
  ```

  To make mypy aware of the plugin, you need to add

  ```ini
  [mypy]
  plugins =
      mypy_drf_plugin.main
  ```

  in your `mypy.ini` file.




  We have Gitter here: <https://gitter.im/mypy-django/Lobby>
  If you think you have more generic typing issue, please refer to <https://github.com/python/mypy> and their Gitter.



  This project is open source and community driven. As such we encourage contributions big and small. You can contribute by doing any of the following:

  1. Contribute code (e.g. improve stubs, add plugin capabilities, write tests etc) - to do so please follow the [contribution guide](./CONTRIBUTING.md).
  2. Assist in code reviews and discussions in issues.
  3. Identify bugs and issues and report these

  You can always also reach out in gitter to discuss your contributions!


pkgId: a1c023f2c240822e2424f68af115c0736b0ffd2b9ea5a02c212fcf95922b42d5
name: python-djangorestframework-xml
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: XML support for Django REST Framework
url: https://github.com/jpadilla/django-rest-framework-xml
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-be107584-7542-48a7-888e-8f9c4d3bb8b3
location_href: 00011662-python-djangorestframework-xml/python-djangorestframework-xml-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![build-status-image]][github-action]
  [![pypi-version]][pypi]

  **XML support for Django REST Framework**

  Full documentation for the project is available at [http://jpadilla.github.io/django-rest-framework-xml][docs].



  XML support extracted as a third party package directly from the official Django REST Framework implementation. It requires the [defusedxml][defusedxml] package only because it safeguards against some security issues that were discovered.

  **Note**: XML output provided is an ad-hoc format that isn't formally described. If you have specific XML requirements you'll need to write your own XML parsers/renderers in order to fully control the representation.



  * Python 3.5+
  * Django 2.2+
  * Django REST Framework 3.11+



  Install using `pip`...

  ```bash
  $ pip install djangorestframework-xml
  ```



  ```python
  REST_FRAMEWORK = {
      'DEFAULT_PARSER_CLASSES': (
          'rest_framework_xml.parsers.XMLParser',
      ),
      'DEFAULT_RENDERER_CLASSES': (
          'rest_framework_xml.renderers.XMLRenderer',
      ),
  }
  ```

  You can also set the renderer and parser used for an individual view, or viewset, using the APIView class based views.

  ```python
  from rest_framework import routers, serializers, viewsets
  from rest_framework_xml.parsers import XMLParser
  from rest_framework_xml.renderers import XMLRenderer


  class UserSerializer(serializers.HyperlinkedModelSerializer):
      class Meta:
          model = User
          fields = ('url', 'username', 'email', 'is_staff')


  class UserViewSet(viewsets.ModelViewSet):
      queryset = User.objects.all()
      serializer_class = UserSerializer
      parser_classes = (XMLParser,)
      renderer_classes = (XMLRenderer,)
  ```



  ```xml
  <?xml version="1.0" encoding="utf-8"?>
  <root>
      <list-item>
          <url>http://127.0.0.1:8000/users/1/.xml</url>
          <username>jpadilla</username>
          <email>jpadilla@example.com</email>
          <is_staff>True</is_staff>
      </list-item>
  </root>
  ```



  Full documentation for the project is available at [http://jpadilla.github.io/django-rest-framework-xml][docs].

  You may also want to follow the [author][jpadilla] on Twitter.


  [build-status-image]: https://github.com/jpadilla/django-rest-framework-xml/workflows/CI/badge.svg
  [github-action]: https://github.com/jpadilla/django-rest-framework-xml/actions?query=workflow%3ACI
  [pypi-version]: https://img.shields.io/pypi/v/djangorestframework-xml.svg
  [pypi]: https://pypi.python.org/pypi/djangorestframework-xml
  [defusedxml]: https://pypi.python.org/pypi/defusedxml
  [docs]: http://jpadilla.github.io/django-rest-framework-xml
  [jpadilla]: https://twitter.com/jpadilla_


pkgId: 74d2abf20834a7b77e5ecee687d2659e05b19ee4c74e2623237c079f7e3df91f
name: python-djangosaml2
arch: src
version: 1.5.6
epoch: 0
release: 1
summary: pysaml2 integration for Django
url: https://github.com/IdentityPython/djangosaml2
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fde56863-c9a5-4577-9748-511fb8a2287d
location_href: 00012581-python-djangosaml2/python-djangosaml2-1.5.6-1.src.rpm
checksum_type: sha256
description:
  ![CI build](https://github.com/peppelinux/djangosaml2/workflows/djangosaml2/badge.svg)
  ![pypi](https://img.shields.io/pypi/v/djangosaml2.svg)
  [![Downloads](https://pepy.tech/badge/djangosaml2/month)](https://pepy.tech/project/djangosaml2)
  ![Python version](https://img.shields.io/badge/license-Apache%202-blue.svg)
  ![Django versions](https://img.shields.io/pypi/djversions/djangosaml2)
  ![Documentation Status](https://readthedocs.org/projects/djangosaml2/badge/?version=latest)
  ![License](https://img.shields.io/badge/python-3.7%20%7C%203.8%20%7C%203.9%20%7C%203.10-blue.svg)
  A Django application that builds a Fully Compliant SAML2 Service Provider on top of PySAML2 library.
   Djangosaml2 protects your project with a SAML2 SSO Authentication.
  Features:
  - HTTP-REDIRECT SSO Binding
  - HTTP-POST SSO Binding
  - SLO POST and HTTP-REDIRECT Binding
  - Discovery Service
  - embedded Wayf page with customizable html template
  - IdP Hinting
  - IdP Scoping
  - Samesite cookie
  Please consult the [official Documentation of djangosaml2](https://djangosaml2.readthedocs.io) to get started.


pkgId: c11032825e4afa19c06394f75dcd429120c049a0b45a5a6c118ae44d69ea2bb4
name: python-djangosaml2idp
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: SAML 2.0 Identity Provider for Django
url: https://github.com/OTA-Insight/djangosaml2idp/
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b12e1b1-645c-4710-9342-470424f3da3a
location_href: 00012062-python-djangosaml2idp/python-djangosaml2idp-0.7.2-1.src.rpm
checksum_type: sha256
description:
  djangosaml2idp implements the Identity Provider side of the SAML2 protocol for Django.
  It builds on top of `PySAML2 <https://github.com/IdentityPython/pysaml2>`_, and is production-ready.
  Any contributions, feature requests, proposals, ideas ... are welcome! See the `CONTRIBUTING document <https://github.com/OTA-Insight/djangosaml2idp/blob/master/CONTRIBUTING.md>`_ for some info.


pkgId: 1acb6c4736cbef7eb66b8b6e83bd221b9a3049fb2c8db1d38ee4e90cd906c2db
name: python-dlipower
arch: src
version: 1.0.176
epoch: 0
release: 1
summary: Control digital loggers web power switch
url: https://github.com/dwighthubbard/python-dlipower/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4352ccd5-5aec-4f26-ae47-33fdfde8e342
location_href: 00010695-python-dlipower/python-dlipower-1.0.176-1.src.rpm
checksum_type: sha256
description:
  This is a python module and a script to mange the
  Digital Loggers Web Power switch.
  The module provides a python class named
  PowerSwitch that allows managing the web power
  switch from python programs.
  When run as a script this acts as a command
  line utility to manage the DLI Power switch.


pkgId: bd8d22380d3c866ba166e13a9c71842ca388442db6f6abeb4ce79c060ef45555
name: python-dnsgen
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Generates DNS possibilities from existing domain names.
url: https://github.com/me/myproject
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d3b2f2d0-e8e6-4088-916e-ee24b05f8a6e
location_href: 00003525-python-dnsgen/python-dnsgen-1.0.4-1.src.rpm
checksum_type: sha256
description:
  This tool generates a combination of domain names from the provided input. Combinations are created based on wordlist. Custom words are extracted per execution. Refer to [Techniques](#techniques) section to learn more.

  `dnsgen` is very similar to [altdns](https://github.com/infosec-au/altdns). It does not contain DNS resolver. You should use [massdns](https://github.com/blechschmidt/massdns) for DNS resolution.

  ![dnsgen](https://0xpatrik.com/content/images/2019/09/dnsgen-1.png)



  ```pip3 install dnsgen```

  ..or from GitHub directly:

  ```
  git clone https://github.com/ProjectAnte/dnsgen
  cd dnsgen
  pip3 install -r requirements.txt
  python3 setup.py install
  ```



  ```$ dnsgen domains.txt``` (`domains.txt` contains a list of active domain names)

  * `-l` / `--wordlen`: minimum size of custom words to be extracted
  * `-w` / `--wordlist`: path to custom wordlist
  * `-f` / `--fast`: Generate lower amount of domains with most probable words only
  * `filename`: required parameter for an input list of domains. The input file should contain domain names separated by newline character (`\n`). You can also use STDIN as an input method, providing `-` to this argument.

  **Combination with massdns:**

  `$ cat domains.txt | dnsgen - | massdns -r /path/to/resolvers.txt -t A -o J --flush 2>/dev/null`



  *(For demo purposes, let's say that wordlist contains just one word: `stage`)*

  * **Insert word on every index** — Creates new subdomain levels by inserting the words between existing levels. `foo.example.com` -> `stage.foo.example.com`, `foo.stage.example.com`

  * **Increase/Decrease num found** — *(In development)* If number is found in an existing subdomain, increase/decrease this number without any other alteration. `foo01.example.com` -> `foo02.example.com`, `foo03.example.com`, `...`

  * **Prepend word on every index** — On every subdomain level, prepend existing content with `WORD` and `WORD-`. `foo.example.com` -> `stagefoo.example.com`, `stage-foo.example.com`

  * **Append word on every index** — On every subdomain level, append existing content with `WORD` and `WORD-`. `foo.example.com` -> `foostage.example.com`, `foo-stage.example.com`

  * **Replace the word with word** — If word longer than 3 is found in an existing subdomain, replace it with other words from the wordlist. *(If we have more words than one in our wordlist)*. `stage.foo.example.com` -> `otherword.foo.example.com`, `anotherword.foo.example.com`, `...`

  * **Extract custom words** — Extend the wordlist based on target's domain naming conventions. Such words are either whole subdomain levels, or `-` is used for a split on some subdomain level. For instance `mapp1-current.datastream.example.com` has `mapp1`, `current`, `datastream` words. To prevent the overflow, user-defined *word length* is used for word extraction. The default value is set to **6**. This means that only words strictly longer than **5** characters are included (from the previous example, `mapp1` does not satisfy this condition).



  - [Subdomain Enumeration: 2019 Workflow](https://0xpatrik.com/subdomain-enumeration-2019/)
  - [Subdomain Enumeration: Doing it a Bit Smarter](https://0xpatrik.com/subdomain-enumeration-smarter/)



  - Improve README
  - Tests


pkgId: 4a248aba0bce85f772c5a9f1b1c20b93c5932b1c230ce92f26a0a04f0ffa4374
name: python-dnslib
arch: src
version: 0.9.23
epoch: 0
release: 1
summary: Simple library to encode/decode DNS wire-format packets
url: https://github.com/paulc/dnslib
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02e75a01-4815-4d98-a114-e99d40cc6c6a
location_href: 00003526-python-dnslib/python-dnslib-0.9.23-1.src.rpm
checksum_type: sha256
description:
  A library to encode/decode DNS wire-format packets supporting both
  Python 2.7 and Python 3.2+.
  The library provides:
   * Support for encoding/decoding DNS packets between wire format,
     python objects, and Zone/DiG textual representation (dnslib.dns)
   * A server framework allowing the simple creation of custom DNS
     resolvers (dnslib.server) and a number of example servers
     created using this framework
   * A number of utilities for testing (dnslib.client, dnslib.proxy,
     dnslib.intercept)
  Python 3 support was added in Version 0.9.0 which represented a fairly
  major update to the library - the key changes include:
   * Python 2.7/3.2+ support (the last version supporting Python 2.6
     or earlier was version 0.8.3)
   * The 'Bimap' interface was changed significantly to explicitly
     split forward (value->text) lookups via __getitem__ and
     reverse (text->value) lookups via __getattr__. Applications
     using the old interface will need to be updated.
   * Hostnames are now returned with a trailing dot by default (in
     line with RFC)
   * Most object attributes are now typed in line with the record
     definitions to make it harder to generate invalid packets
   * Support for encoding/decoding resource records in 'Zone' (BIND)
     file format
   * Support for encoding/decoding packets in 'DiG' format
   * Server framework allowing (in most cases) custom resolvers to
     be created by just subclassing the DNSResolver class and
     overriding the 'resolve' method
   * A lot of fixes to error detection/handling which should make
     the library much more robust to invalid/unsupported data. The
     library should now either return a valid DNSRecord instance
     when parsing a packet or raise DNSError (tested via fuzzing)
   * Improved utilities (dnslib.client, dnslib.proxy, dnslib.intercept)
   * Improvements to encoding/decoding tests including the ability
     to generate test data automatically in test_decode.py (comparing
     outputs against DiG)
   * Ability to compare and diff DNSRecords


pkgId: 5740fa3850c2bdede22730e3109d9a3c82944a3ecd779cbe1ee3914dcc08fb1e
name: python-docker
arch: src
version: 6.0.1
epoch: 0
release: 1
summary: A Python library for the Docker Engine API.
url: https://github.com/docker/docker-py
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6bab1986-cb32-48f5-92c9-a6b4619d63d9
location_href: 00008942-python-docker/python-docker-6.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/docker/docker-py/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/docker/docker-py/actions/workflows/ci.yml/)

  A Python library for the Docker Engine API. It lets you do anything the `docker` command does, but from within Python apps – run containers, manage containers, manage Swarms, etc.



  The latest stable version [is available on PyPI](https://pypi.python.org/pypi/docker/). Either add `docker` to your `requirements.txt` file or install with pip:

      pip install docker

  > Older versions (< 6.0) required installing `docker[tls]` for SSL/TLS support.
  > This is no longer necessary and is a no-op, but is supported for backwards compatibility.



  Connect to Docker using the default socket or the configuration in your environment:

  ```python
  import docker
  client = docker.from_env()
  ```

  You can run containers:

  ```python
  >>> client.containers.run("ubuntu:latest", "echo hello world")
  'hello world\n'
  ```

  You can run containers in the background:

  ```python
  >>> client.containers.run("bfirsh/reticulate-splines", detach=True)
  <Container '45e6d2de7c54'>
  ```

  You can manage containers:

  ```python
  >>> client.containers.list()
  [<Container '45e6d2de7c54'>, <Container 'db18e4f20eaa'>, ...]

  >>> container = client.containers.get('45e6d2de7c54')

  >>> container.attrs['Config']['Image']
  "bfirsh/reticulate-splines"

  >>> container.logs()
  "Reticulating spline 1...\n"

  >>> container.stop()
  ```

  You can stream logs:

  ```python
  >>> for line in container.logs(stream=True):
  ...   print(line.strip())
  Reticulating spline 2...
  Reticulating spline 3...
  ...
  ```

  You can manage images:

  ```python
  >>> client.images.pull('nginx')
  <Image 'nginx'>

  >>> client.images.list()
  [<Image 'ubuntu'>, <Image 'nginx'>, ...]
  ```

  [Read the full documentation](https://docker-py.readthedocs.io) to see everything you can do.


pkgId: c0e2938cb26f2fd9507f63808be167dd029d1fa77977ca78f2b833c5fb451bb1
name: python-docker-py
arch: src
version: 1.10.6
epoch: 0
release: 1
summary: Python client for Docker.
url: https://github.com/docker/docker-py/
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5bc2efac-5ef5-45dc-b18b-e539e5b3b6a7
location_href: 00010774-python-docker-py/python-docker-py-1.10.6-1.src.rpm
checksum_type: sha256
description:
  |Build Status|
  A Python library for the Docker Remote API. It does everything the
  ``docker`` command does, but from within Python – run containers, manage
  them, pull/push images, etc.


pkgId: 02ac63436f4929d00bcb4a9770d0577004c8b4db069134d6818039eec472fad4
name: python-docker-pycreds
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Python bindings for the docker credentials store API
url: https://github.com/shin-/dockerpy-creds
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-adc3de19-19d0-448a-8e4a-b9e6e34cb19e
location_href: 00009402-python-docker-pycreds/python-docker-pycreds-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/shin-/dockerpy-creds/tree/master.svg?style=svg)](https://circleci.com/gh/shin-/dockerpy-creds/tree/master)

  Python bindings for the docker credentials store API



  [Docker documentation page](https://docs.docker.com/engine/reference/commandline/login/#/credentials-store)



  On top of the dependencies in `requirements.txt`, the `docker-credential`
  executable for the platform must be installed on the user's system.



  ```python

  import dockerpycreds

  store = dockerpycreds.Store('secretservice')
  store.store(
      server='https://index.docker.io/v1/', username='johndoe',
      secret='hunter2'
  )

  print(store.list())

  print(store.get('https://index.docker.io/v1/'))


  store.erase('https://index.docker.io/v1/')
  ```


pkgId: 8640934cd10a7197a631f49dcbb7313ec13ea0d00b05f0a6048fda2995718e9b
name: python-dockerfile-parse
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Python library for Dockerfile manipulation
url: https://github.com/containerbuildsystem/dockerfile-parse
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f18ff7da-e28f-4b83-9d08-d90bfc0209ed
location_href: 00003529-python-dockerfile-parse/python-dockerfile-parse-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![unittests status badge]][unittests status link]
  [![coveralls status badge]][coveralls status link]
  [![lgtm python badge]][lgtm python link]
  [![lgtm alerts badge]][lgtm alerts link]
  [![linters status badge]][linters status link]

  Python library for parsing Dockerfile files.





  ```shell
  pip install dockerfile-parse
  ```



  Clone this git repo and install using the python installer

  ```shell
  git clone https://github.com/containerbuildsystem/dockerfile-parse.git
  cd dockerfile-parse
  sudo pip install .
  ```



  ```python
  from pprint import pprint
  from dockerfile_parse import DockerfileParser

  dfp = DockerfileParser()
  dfp.content = """\
  From  base
  LABEL foo="bar baz"
  USER  me"""


  pprint(dfp.structure)
  pprint(dfp.json)
  pprint(dfp.labels)


  dfp.baseimage = 'centos:7'


  print(dfp.content)
  ```

  [coveralls status badge]: https://coveralls.io/repos/containerbuildsystem/dockerfile-parse/badge.svg?branch=master
  [coveralls status link]: https://coveralls.io/r/containerbuildsystem/dockerfile-parse?branch=master
  [lgtm python badge]: https://img.shields.io/lgtm/grade/python/g/containerbuildsystem/dockerfile-parse.svg?logo=lgtm&logoWidth=18
  [lgtm python link]: https://lgtm.com/projects/g/containerbuildsystem/dockerfile-parse/context:python
  [lgtm alerts badge]: https://img.shields.io/lgtm/alerts/g/containerbuildsystem/dockerfile-parse.svg?logo=lgtm&logoWidth=18
  [lgtm alerts link]: https://lgtm.com/projects/g/containerbuildsystem/dockerfile-parse/alerts
  [linters status badge]: https://github.com/containerbuildsystem/dockerfile-parse/workflows/Linters/badge.svg?branch=master&event=push
  [linters status link]: https://github.com/containerbuildsystem/dockerfile-parse/actions?query=event%3Apush+branch%3Amaster+workflow%3A%22Linters%22
  [unittests status badge]: https://github.com/containerbuildsystem/dockerfile-parse/workflows/Unittests/badge.svg?branch=master&event=push
  [unittests status link]: https://github.com/containerbuildsystem/dockerfile-parse/actions?query=event%3Apush+branch%3Amaster+workflow%3A%22Unittests%22


pkgId: 6d07859295527b2e6e25dbdd6a52e48ec4c6794dc1229de4658757921cf94225
name: python-dockerpty
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Python library to use the pseudo-tty of a docker container
url: https://github.com/d11wtq/dockerpty
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-30f3b365-dba1-48d6-9327-f81b2a15c43f
location_href: 00009453-python-dockerpty/python-dockerpty-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Provides the functionality needed to operate the pseudo-tty (PTY) allocated to
  a docker container, using the Python client.

  [![Build Status](https://travis-ci.org/d11wtq/dockerpty.svg?branch=master)]
  (https://travis-ci.org/d11wtq/dockerpty)



  Via pip:

  ```
  pip install dockerpty
  ```

  Dependencies:

    * docker-py>=0.3.2

  However, this library does not explicitly declare this dependency in PyPi for a
  number of reasons. It is assumed you have it installed.



  The following example will run busybox in a docker container and place the user
  at the shell prompt via Python.

  This obviously only works when run in a terminal.

  ``` python
  import docker
  import dockerpty

  client = docker.Client()
  container = client.create_container(
      image='busybox:latest',
      stdin_open=True,
      tty=True,
      command='/bin/sh',
  )

  dockerpty.start(client, container)
  ```

  Keyword arguments passed to `start()` will be forwarded onto the client to
  start the container.

  When the dockerpty is started, control is yielded to the container's PTY until
  the container exits, or the container's PTY is closed.

  This is a safe operation and all resources are restored back to their original
  states.

  > **Note:** dockerpty does support attaching to non-tty containers to stream
  container output, though it is obviously not possible to 'control' the
  container if you do not allocate a pseudo-tty.

  If you press `C-p C-q`, the container's PTY will be closed, but the container
  will keep running. In other words, you will have detached from the container
  and can re-attach with another `dockerpty.start()` call.



  If you want to hack on dockerpty and send a PR, you'll need to run the tests.
  In the features/ directory, are features/user stories for how dockerpty is
  supposed to work. To run them:

  ```
  -bash$ pip install -r requirements-dev.txt
  -bash$ behave features/
  ```

  You'll need to have docker installed and running locally. The tests use busybox
  container as a test fixture, so are not too heavy.

  Step definitions are defined in features/steps/.

  There are also unit tests for the parts of the code that are not inherently
  dependent on controlling a TTY. To run those:

  ```
  -bash$ pip install -r requirements-dev.txt
  -bash$ py.test tests/
  ```

  Travis CI runs this build inside a UML kernel that is new enough to run docker.
  Your PR will need to pass the build before I can merge it.

    - Travis CI build: https://travis-ci.org/d11wtq/dockerpty



  In a terminal, the three file descriptors stdin, stdout and stderr are all
  connected to the controlling terminal (TTY). When you pass the `tty=True` flag
  to docker's `create_container()`, docker allocates a fake TTY inside the
  container (a PTY) to which the container's stdin, stdout and stderr are all
  connected.

  The docker API provides a way to access the three sockets connected to the PTY.
  If with access to the host system's TTY file descriptors and the container's
  PTY file descriptors, it is trivial to simply 'pipe' data written to these file
  descriptors between the host and the container. Doing this makes the user's
  terminal effectively become the pseudo-terminal from inside the container.

  In reality it's a bit more complicated than this, since care must be taken to
  put the host terminal into raw mode (where keys such as enter are not
  interpreted with any special meaning) and restore it on exit. Additionally, the
  container's stdout and stderr streams along with `sys.stdin` must be made
  non-blocking so that they can be used with `select()` without blocking the main
  process. These attributes are restored on exit.

  The size of a terminal cannot be controlled by sending data to stdin and can
  only be controlled by the terminal program itself. Since the pseudo-terminal is
  running inside a real terminal, it is import that the size of the PTY be kept
  the same as that of the presenting TTY. For this reason, docker provides an API
  call to resize the allocated PTY. A SIGWINCH handler is used to detect window
  size changes and resize the pseudo-terminal as needed.



    - Primary author: [Chris Corbyn](https://github.com/d11wtq)
    - Collaborator: [Daniel Nephin](https://github.com/dnephin)
    - Contributor: [Stephen Moore](https://github.com/delfick)
    - Contributor: [Ben Firshman](https://github.com/bfirsh)



  Copyright &copy; 2014 Chris Corbyn. See the LICENSE.txt file for details.


pkgId: 0f8f81855280adabc8b3995acad4744c37844e954b2c9a18380accbc49d089c0
name: python-docopt
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Pythonic argument parser, that will make you smile
url: http://docopt.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5e661d3-5d76-4ea1-aa89-d4b292acf9cf
location_href: 00009110-python-docopt/python-docopt-0.6.2-1.src.rpm
checksum_type: sha256
description:
  Video introduction to **docopt**: `PyCon UK 2012: Create *beautiful*
  command-line interfaces with Python <http://youtu.be/pXhcPJK5cMc>`_
      New in version 0.6.1:
      - Fix issue `#85 <https://github.com/docopt/docopt/issues/85>`_
        which caused improper handling of ``[options]`` shortcut
        if it was present several times.
      New in version 0.6.0:
      - New argument ``options_first``, disallows interspersing options
        and arguments.  If you supply ``options_first=True`` to
        ``docopt``, it will interpret all arguments as positional
        arguments after first positional argument.
      - If option with argument could be repeated, its default value
        will be interpreted as space-separated list. E.g. with
        ``[default: ./here ./there]`` will be interpreted as
        ``['./here', './there']``.
      Breaking changes:
      - Meaning of ``[options]`` shortcut slightly changed. Previously
        it ment *"any known option"*. Now it means *"any option not in
        usage-pattern"*.  This avoids the situation when an option is
        allowed to be repeated unintentionaly.
      - ``argv`` is ``None`` by default, not ``sys.argv[1:]``.
        This allows ``docopt`` to always use the *latest* ``sys.argv``,
        not ``sys.argv`` during import time.
  Isn't it awesome how ``optparse`` and ``argparse`` generate help
  messages based on your code?!
  *Hell no!*  You know what's awesome?  It's when the option parser *is*
  generated based on the beautiful help message that you write yourself!
  This way you don't need to write this stupid repeatable parser-code,
  and instead can write only the help message--*the way you want it*.
  **docopt** helps you create most beautiful command-line interfaces
  *easily*:
      """Naval Fate.
      Usage:
        naval_fate.py ship new <name>...
        naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
        naval_fate.py ship shoot <x> <y>
        naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
        naval_fate.py (-h | --help)
        naval_fate.py --version
      Options:
        -h --help     Show this screen.
        --version     Show version.
        --speed=<kn>  Speed in knots [default: 10].
        --moored      Moored (anchored) mine.
        --drifting    Drifting mine.
      """
      from docopt import docopt
      if __name__ == '__main__':
          arguments = docopt(__doc__, version='Naval Fate 2.0')
          print(arguments)
  Beat that! The option parser is generated based on the docstring above
  that is passed to ``docopt`` function.  ``docopt`` parses the usage
  pattern (``"Usage: ..."``) and option descriptions (lines starting
  with dash "``-``") and ensures that the program invocation matches the
  usage pattern; it parses options, arguments and commands based on
  that. The basic idea is that *a good help message has all necessary
  information in it to make a parser*.
  Also, `PEP 257 <http://www.python.org/dev/peps/pep-0257/>`_ recommends
  putting help message in the module docstrings.


pkgId: a3080bebdfd247eb76f8b4f0d10f0883a3f3ef156990e8c5bc1303691040951f
name: python-docplex
arch: src
version: 2.25.236
epoch: 0
release: 1
summary: The IBM Decision Optimization CPLEX Modeling for Python
url: https://www.ibm.com/cloud/decision-optimization-for-watson-studio
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72632b92-a5b6-4d4f-a8ab-da17d76126a4
location_href: 00012331-python-docplex/python-docplex-2.25.236-1.src.rpm
checksum_type: sha256
description:
  Welcome to the IBM Decision Optimization CPLEX Modeling for Python.
  Licensed under the Apache License v2.0.
  With this library, you can quickly and easily add the power of optimization to
  your application. You need IBM ILOG CPLEX Optimization Studio to solve the models.
  This library is composed of 2 modules:
      * IBM Decision Optimization CPLEX Optimizer Modeling for Python - with namespace docplex.mp
      * IBM Decision Optimization CP Optimizer Modeling for Python - with namespace docplex.cp
  Solving with CPLEX locally requires that IBM ILOG CPLEX Optimization Studio V12.8 or later
  is installed on your machine.
  This library is `numpy` friendly.
  `Documentation <http://ibmdecisionoptimization.github.io/docplex-doc/>`_
  `Examples <https://github.com/IBMDecisionOptimization/docplex-examples>`_


pkgId: 1d9cb1dd26c89bd3e169a447c9ba3152ef8fe7003f1e736a9448098c7194cfc3
name: python-docutils
arch: src
version: 0.19
epoch: 0
release: 1
summary: Docutils -- Python Documentation Utilities
url: https://docutils.sourceforge.io/
rpm_license: public domain, Python, 2-Clause BSD, GPL 3 (see COPYING.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a47dd5c7-387a-4373-9336-9859ff02e21f
location_href: 00008908-python-docutils/python-docutils-0.19-1.src.rpm
checksum_type: sha256
description:
  Docutils is a modular system for processing documentation
  into useful formats, such as HTML, XML, and LaTeX.  For
  input Docutils supports reStructuredText, an easy-to-read,
  what-you-see-is-what-you-get plaintext markup syntax.


pkgId: cb344c2de50ccc95182597b01849dc53ff1b327df1f8d57c4edfb27679513c99
name: python-docx
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: The docx module creates, reads and writes Microsoft Office Word 2007 docx files
url: http://github.com/mikemaccana/python-docx
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5816f25f-bcd5-4214-addc-92ce846aac44
location_href: 00003531-python-docx/python-docx-0.2.4-1.src.rpm
checksum_type: sha256
description:
  The docx module creates, reads and writes Microsoft Office Word 2007 docx
  files.
  These are referred to as 'WordML', 'Office Open XML' and 'Open XML' by
  Microsoft.
  These documents can be opened in Microsoft Office 2007 / 2010, Microsoft Mac
  Office 2008, Google Docs, OpenOffice.org 3, and Apple iWork 08.
  They also `validate as well formed XML <http://validator.w3.org/check>`_.
  The module was created when I was looking for a Python support for MS Word
  .docx files, but could only find various hacks involving COM automation,
  calling .Net or Java, or automating OpenOffice or MS Office.
  The docx module has the following features:


pkgId: 039b9ac8b99319a244f3e58487dad014402ae91e4bb2dae6abea39f0b3e3b69d
name: python-dogpile.cache
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: A caching front-end based on the Dogpile lock.
url: https://github.com/sqlalchemy/dogpile.cache
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-27b96b45-09a6-44ec-9fee-34d50770e924
location_href: 00003532-python-dogpile-cache/python-dogpile.cache-1.1.8-1.src.rpm
checksum_type: sha256
description:
  Dogpile consists of two subsystems, one building on top of the other.
  ``dogpile`` provides the concept of a "dogpile lock", a control structure
  which allows a single thread of execution to be selected as the "creator" of
  some resource, while allowing other threads of execution to refer to the previous
  version of this resource as the creation proceeds; if there is no previous
  version, then those threads block until the object is available.
  ``dogpile.cache`` is a caching API which provides a generic interface to
  caching backends of any variety, and additionally provides API hooks which
  integrate these cache backends with the locking mechanism of ``dogpile``.
  Overall, dogpile.cache is intended as a replacement to the `Beaker
  <https://pypi.org/project/Beaker/>`_ caching system, the internals of which are
  written by the same author.   All the ideas of Beaker which "work" are re-
  implemented in dogpile.cache in a more efficient and succinct manner, and all
  the cruft (Beaker's internals were first written in 2005) relegated to the
  trash heap.


pkgId: 7e7621caaca8396c421731c078704e5c393ae251545ebe69c7752c9ead365dd4
name: python-doit
arch: src
version: 0.36.0
epoch: 0
release: 1
summary: doit - Automation Tool
url: http://pydoit.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8d76fe8b-2f2f-44f2-87bd-9b5e5d9275eb
location_href: 00003534-python-doit/python-doit-0.36.0-1.src.rpm
checksum_type: sha256
description:
  Define functions returning python dict with task's meta-data.
  Snippet from `tutorial <http://pydoit.org/tutorial-1.html>`_:
    def task_imports():
        """find imports from a python module"""
        for name, module in PKG_MODULES.by_name.items():
            yield {
                'name': name,
                'file_dep': [module.path],
                'actions': [(get_imports, (PKG_MODULES, module.path))],
            }
    def task_dot():
        """generate a graphviz's dot graph from module imports"""
        return {
            'targets': ['requests.dot'],
            'actions': [module_to_dot],
            'getargs': {'imports': ('imports', 'modules')},
            'clean': True,
        }
    def task_draw():
        """generate image from a dot file"""
        return {
            'file_dep': ['requests.dot'],
            'targets': ['requests.png'],
            'actions': ['dot -Tpng s -o s'],
            'clean': True,
        }
  Run from terminal::
    $ doit list
    dot       generate a graphviz's dot graph from module imports
    draw      generate image from a dot file
    imports   find imports from a python module
    $ doit
    .  imports:requests.models
    .  imports:requests.__init__
    .  imports:requests.help
    (...)
    .  dot
    .  draw


pkgId: 66cda193f7e748f248defee6138caf7ecc275ec9fc128b1924688c2bd55d5d26
name: python-dotmap
arch: src
version: 1.3.30
epoch: 0
release: 1
summary: ordered, dynamically-expandable dot-access dictionary
url: https://github.com/drgrib/dotmap
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d7594d60-c4d9-4c54-96a4-da34299f9c86
location_href: 00010423-python-dotmap/python-dotmap-1.3.30-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/drgrib/dotmap.svg?branch=master)](https://travis-ci.com/drgrib/dotmap)

  [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/donate?business=N2GLXLS5KBFBY&item_name=Chris+Redford&currency_code=USD)



  ```
  pip3 install dotmap
  ```



  Get updates for current installation

  ```
  pip3 install --upgrade dotmap
  ```



  `DotMap` is a dot-access `dict` subclass that

  -   has dynamic hierarchy creation (autovivification)
  -   can be initialized with keys
  -   easily initializes from `dict`
  -   easily converts to `dict`
  -   is ordered by insertion

  The key feature is exactly what you want: dot-access

  ```python
  from dotmap import DotMap
  m = DotMap()
  m.name = 'Joe'
  print('Hello ' + m.name)

  ```

  However, `DotMap` is a `dict` and you can treat it like a `dict` as needed

  ```python
  print(m['name'])

  m.name += ' Smith'
  m['name'] += ' Jr'
  print(m.name)

  ```

  It also has fast, automatic hierarchy (which can be deactivated by initializing with `DotMap(_dynamic=False)`)

  ```python
  m = DotMap()
  m.people.steve.age = 31
  ```

  And key initialization

  ```python
  m = DotMap(a=1, b=2)
  ```

  You can initialize it from `dict` and convert it to `dict`

  ```python
  d = {'a':1, 'b':2}

  m = DotMap(d)
  print(m)


  print(m.toDict())

  ```

  And it has iteration that is ordered by insertion

  ```python
  m = DotMap()

  m.people.john.age = 32
  m.people.john.job = 'programmer'
  m.people.mary.age = 24
  m.people.mary.job = 'designer'
  m.people.dave.age = 55
  m.people.dave.job = 'manager'

  for k, v in m.people.items():
  	print(k, v)
  print




  ```

  It also has automatic counter initialization

  ```python
  m = DotMap()
  for i in range(7):
  	m.counter += 1
  print(m.counter)

  ```

  And automatic addition initializations of any other type

  ```python
  m = DotMap()
  m.quote += 'lions'
  m.quote += ' and tigers'
  m.quote += ' and bears'
  m.quote += ', oh my'
  print(m.quote)

  ```

  There is also built-in `pprint` as `dict` or `json` for debugging a large `DotMap`

  ```python
  m.pprint()



  m.pprint(pformat='json')
















  ```

  And many other features involving dots and dictionaries that will be immediately intuitive when used.


pkgId: b9453a19c7083ef0a6282424d64351d414f548aea64ae5258ab23fa59862d16f
name: python-dpath
arch: src
version: 2.1.4
epoch: 0
release: 1
summary: Filesystem-like pathing and searching for dictionaries
url: https://github.com/dpath-maintainers/dpath-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c215feef-a2fd-40cb-af59-17eaff3f60c7
location_href: 00003539-python-dpath/python-dpath-2.1.4-1.src.rpm
checksum_type: sha256
description:
  |PyPI|
  |Python Version|
  |Build Status|
  |Gitter|
  A python library for accessing and searching dictionaries via
  /slashed/paths ala xpath
  Basically it lets you glob over a dictionary as if it were a filesystem.
  It allows you to specify globs (ala the bash eglob syntax, through some
  advanced fnmatch.fnmatch magic) to access dictionary elements, and
  provides some facility for filtering those results.
  sdists are available on pypi: http://pypi.python.org/pypi/dpath


pkgId: 221f0eb813fb61e30803fc1ec5883cf1fc5e1552ce857cd5ce3d7e2edf101278
name: python-dpkt
arch: src
version: 1.9.8
epoch: 0
release: 1
summary: fast, simple packet creation / parsing, with definitions for the basic TCP/IP protocols
url: https://github.com/kbandla/dpkt
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-93c2d07b-bef3-46d1-b349-464f788050f5
location_href: 00003540-python-dpkt/python-dpkt-1.9.8-1.src.rpm
checksum_type: sha256
description:
  ![Python package](https://github.com/kbandla/dpkt/workflows/Python%20package/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/kbandla/dpkt/badge.svg?branch=master)](https://coveralls.io/github/kbandla/dpkt?branch=master)
  [![supported-versions](https://img.shields.io/pypi/pyversions/dpkt.svg)](https://pypi.python.org/pypi/dpkt)
  [![supported-versions](https://img.shields.io/pypi/implementation/dpkt.svg)](https://pypi.python.org/pypi/dpkt)

  The dpkt project is a python module for fast, simple packet parsing, with definitions for the basic TCP/IP protocols.


  ```
  pip install dpkt
  ```


  - [Main Docs for DPKT](https://kbandla.github.io/dpkt)


pkgId: 920844877e16587365d8b6e5e5013bf340cbebbd20de8c986eb92094c59ac389
name: python-dput
arch: src
version: 1.6
epoch: 0
release: 1
summary: dput-ng -- like dput, but better
url: UNKNOWN
rpm_license: GPL-2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd703c4b-dfd5-47cf-a33b-c79c4a638ab0
location_href: 00003541-python-dput/python-dput-1.6-1.src.rpm
checksum_type: sha256
description:
  dput-ng is a from-scratch refresh of the old `dput(1)` command. This tool is
  used (at some point) to aid with the act of uploading a package to an archive.
  dput-ng aims to be compatible with the old `dput(1)` config files, while
  adding additional features for better sanity checking, and designed in an
  extensible way.
  Check the [docs](http://dput.rtfd.org) for more on topics that might
  interest you.


pkgId: fa2476cf4dc7cb14c05bbc77fbdf046e8d596e8c4f30f9788dc824f518035912
name: python-dragonfly-energy
arch: src
version: 1.22.114
epoch: 0
release: 1
summary: Dragonfly extension for energy simulation.
url: https://github.com/ladybug-tools/dragonfly-energy
rpm_license: AGPL-3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8cfd552b-99da-4606-89c7-2d176d64a318
location_href: 00013278-python-dragonfly-energy/python-dragonfly-energy-1.22.114-1.src.rpm
checksum_type: sha256
description:
  ![Dragonfly](https://www.ladybug.tools/assets/img/dragonfly.png)

  [![Build Status](https://github.com/ladybug-tools/dragonfly-energy/workflows/CI/badge.svg)](https://github.com/ladybug-tools/dragonfly-energy/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/dragonfly-energy/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/dragonfly-energy)

  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Dragonfly extension for energy simulation.



  `pip install dragonfly-energy`



  ```python
  import dragonfly_energy
  ```




  Since the building geometry in dragonfly is fundamentally 2D, creating a model of
  a building and assigning energy model properties can be done with a few lines of
  code. Here is an example:

  ```python
  from dragonfly.model import Model
  from dragonfly.building import Building
  from dragonfly.story import Story
  from dragonfly.room2d import Room2D
  from dragonfly.windowparameter import SimpleWindowRatio
  from honeybee_energy.lib.programtypes import office_program


  pts_1 = (Point3D(0, 0, 3), Point3D(0, 10, 3), Point3D(10, 10, 3), Point3D(10, 0, 3))
  pts_2 = (Point3D(10, 0, 3), Point3D(10, 10, 3), Point3D(20, 10, 3), Point3D(20, 0, 3))
  pts_3 = (Point3D(0, 10, 3), Point3D(0, 20, 3), Point3D(10, 20, 3), Point3D(10, 10, 3))
  pts_4 = (Point3D(10, 10, 3), Point3D(10, 20, 3), Point3D(20, 20, 3), Point3D(20, 10, 3))
  room2d_1 = Room2D('Office1', Face3D(pts_1), 3)
  room2d_2 = Room2D('Office2', Face3D(pts_2), 3)
  room2d_3 = Room2D('Office3', Face3D(pts_3), 3)
  room2d_4 = Room2D('Office4', Face3D(pts_4), 3)
  story = Story('OfficeFloor', [room2d_1, room2d_2, room2d_3, room2d_4])
  story.solve_room_2d_adjacency(0.01)
  story.set_outdoor_window_parameters(SimpleWindowRatio(0.4))
  story.multiplier = 4
  building = Building('OfficeBuilding', [story])


  for room in story.room_2ds:
      room.properties.energy.program_type = office_program
      room.properties.energy.add_default_ideal_air()


  model = Model('NewDevelopment', [building])
  ```

  Once a Dragonfly Model has been created, it can be converted to a honeybee Model,
  which can then be converted to IDF format like so:

  ```python

  model = Model('NewDevelopment', [building])


  hb_models = model.to_honeybee('Building', use_multiplier=False, tolerance=0.01)
  idfs = [hb_model.to.idf(hb_model) for hb_model in hb_models]
  ```

  The dragonfly model can also be serialized to a geoJSON to be simulated with URBANopt.

  ```python
  from ladybug.location import Location


  model = Model('NewDevelopment', [building])


  location = Location('Boston', 'MA', 'USA', 42.366151, -71.019357)
  sim_folder = './tests/urbanopt_model'
  geojson, hb_model_jsons, hb_models = model.to.urbanopt(model, location, folder=sim_folder)
  ```



  1. Clone this repo locally
  ```
  git clone git@github.com:ladybug-tools/dragonfly-energy



  git clone https://github.com/ladybug-tools/dragonfly-energy
  ```
  2. Install dependencies:
  ```
  cd dragonfly-energy
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```
  python -m pytest tests/
  ```

  4. Generate Documentation:
  ```
  sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly_energy
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: badcc777f94ab43b5fc69d68b09dc923fe47cc8ea8add55c869c1ce380b76384
name: python-dramatiq
arch: src
version: 1.14.2
epoch: 0
release: 1
summary: Background Processing for Python 3.
url: https://pypi.org/project/dramatiq/
rpm_license: GNU Lesser General Public License v3 or later (LGPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1cda68e0-ee94-4ba6-a8e4-ed581fa63a4f
location_href: 00012593-python-dramatiq/python-dramatiq-1.14.2-1.src.rpm
checksum_type: sha256
description:
  <img src="https://dramatiq.io/_static/logo.png" align="right" width="131" />



  [![Build Status](https://github.com/Bogdanp/dramatiq/workflows/CI/badge.svg)](https://github.com/Bogdanp/dramatiq/actions?query=workflow%3A%22CI%22)
  [![PyPI version](https://badge.fury.io/py/dramatiq.svg)](https://badge.fury.io/py/dramatiq)
  [![Documentation](https://img.shields.io/badge/doc-latest-brightgreen.svg)](http://dramatiq.io)
  [![Discuss](https://img.shields.io/badge/discuss-online-orange.svg)](https://groups.io/g/dramatiq-users)

  *A fast and reliable distributed task processing library for Python 3.*

  <hr/>

  **Changelog**: https://dramatiq.io/changelog.html <br/>
  **Community**: https://groups.io/g/dramatiq-users <br/>
  **Documentation**: https://dramatiq.io <br/>

  <hr/>

  <h3 align="center">Sponsors</h3>

  <p align="center">
    <a href="https://franz.defn.io" target="_blank">
      <img width="64px" src="docs/source/_static/franz-logo.png">
      <br/>
      Franz: macOS Kafka Client
    </a>
    <br/>
    <br/>
    <a href="https://www.sendcloud.com/jobs/?utm_source=dramatiq.io&utm_medium=Banner&utm_campaign=Sponsored%20Banner&utm_content=V1" target="_blank">
      <img width="222px" src="docs/source/_static/sendcloud-logo.png">
    </a>
  </p>




  If you want to use it with [RabbitMQ]

      pip install 'dramatiq[rabbitmq, watch]'

  or if you want to use it with [Redis]

      pip install 'dramatiq[redis, watch]'




  Make sure you've got [RabbitMQ] running, then create a new file called
  `example.py`:

  ``` python
  import dramatiq
  import requests
  import sys


  @dramatiq.actor
  def count_words(url):
      response = requests.get(url)
      count = len(response.text.split(" "))
      print(f"There are {count} words at {url!r}.")


  if __name__ == "__main__":
      count_words.send(sys.argv[1])
  ```

  In one terminal, run your workers:

      dramatiq example

  In another, start enqueueing messages:

      python example.py http://example.com
      python example.py https://github.com
      python example.py https://news.ycombinator.com

  Check out the [user guide] to learn more!




  dramatiq is licensed under the LGPL.  Please see [COPYING] and
  [COPYING.LESSER] for licensing details.


  [COPYING.LESSER]: https://github.com/Bogdanp/dramatiq/blob/master/COPYING.LESSER
  [COPYING]: https://github.com/Bogdanp/dramatiq/blob/master/COPYING
  [RabbitMQ]: https://www.rabbitmq.com/
  [Redis]: https://redis.io
  [user guide]: https://dramatiq.io/guide.html


pkgId: f3bb1f17f13fefacf8f54d3f6e34654b849e9c407f4fa40ff2daa25cef2cc5b7
name: python-drat
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A reading text analysis tool
url: https://github.com/riverrun/drat
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1a3eaa57-abdf-41aa-9f8f-2362eedcdc4f
location_href: 00003542-python-drat/python-drat-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Text (readability) analysis tool written in Python (2.7 and 3).
  Features
  ~~~~~~~~
  Drat is a tool that analyzes reading texts and produces a brief report
  which provides the following information:
  - the Dale-Chall readability score.
  - the Coleman-Liau Readability Index.
  - the number of uncommon words (based on the General Service List).
  - a list of all of these uncommon words (if you choose the verbose option).
  Drat supports **docx**, **odt**, **ods**, **odp** files as well as text
  files and urls.
  You can also analyze multiple texts / links by creating a text file
  with the filenames / links written in it.
  A simple example of how drat can be used in a web application is provided in the
  webapp directory.
  Use
  ~~~
  Please read the `wiki <https://github.com/riverrun/drat/wiki>`_ for information about how to use drat.
  Dependencies
  ~~~~~~~~~~~~
  Python (2.7 or 3), click and requests.
  Name
  ~~~~
  Drat is a recursive acronym which either stands for Drat is a Readability
  Analysis Tool or Drat is a Rabid Assessor of Texts.
  Author
  ~~~~~~
  This program has been developed by David Whitlock.
  License
  ~~~~~~~
  Drat is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free
  Software Foundation, either version 3 of the License, or (at your
  option) any later version.


pkgId: 12284ef704a19282875155773b02c6fdbcc2d3d04146203b56b4860c7a9176a6
name: python-drf-extra-fields
arch: src
version: 3.4.1
epoch: 0
release: 1
summary: Additional fields for Django Rest Framework.
url: https://github.com/Hipo/drf-extra-fields
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b94c850-ff13-4df8-8a82-d1c23ba023b5
location_href: 00013448-python-drf-extra-fields/python-drf-extra-fields-3.4.1-1.src.rpm
checksum_type: sha256
description:
  Extra Fields for Django Rest Framework
  [![Build Status](https://github.com/Hipo/drf-extra-fields/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/Hipo/drf-extra-fields/actions)
  [![codecov](https://codecov.io/gh/Hipo/drf-extra-fields/branch/master/graph/badge.svg)](https://codecov.io/gh/Hipo/drf-extra-fields)
  [![PyPI Version](https://img.shields.io/pypi/v/drf-extra-fields.svg)](https://pypi.org/project/drf-extra-fields)
  [![Python Versions](https://img.shields.io/pypi/pyversions/drf-extra-fields.svg)](https://pypi.org/project/drf-extra-fields)


pkgId: 30df15653303ec561638e5977a5090814191a9221d838ba54c291c0a5460b2a8
name: python-drf-flex-fields
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Flexible, dynamic fields and nested resources for Django REST Framework serializers.
url: https://github.com/rsinger86/drf-flex-fields
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0e88bb94-7fb8-49c5-8fe0-8d864e8caa40
location_href: 00013437-python-drf-flex-fields/python-drf-flex-fields-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Package version](https://badge.fury.io/py/drf-flex-fields.svg)](https://pypi.python.org/pypi/drf-flex-fields)
  [![Python versions](https://img.shields.io/pypi/status/drf-flex-fields.svg)](https://img.shields.io/pypi/status/django-lifecycle.svg/)

  Flexible, dynamic fields and nested models for Django REST Framework serializers.



  FlexFields (DRF-FF) for [Django REST Framework](https://django-rest-framework.org) is a package designed to provide a common baseline of functionality for dynamically setting fields and nested models within DRF serializers. This package is designed for simplicity, with minimal magic and entanglement with DRF's foundational classes.

  Key benefits:

  - Easily set up fields that be expanded to their fully serialized counterparts via query parameters (`users/?expand=organization,friends`)
  - Select a subset of fields by either:
    - specifying which ones should be included (`users/?fields=id,first_name`)
    - specifying which ones should be excluded (`users/?omit=id,first_name`)
  - Use dot notation to dynamically modify fields at arbitrary depths (`users/?expand=organization.owner.roles`)
  - Flexible API - options can also be passed directly to a serializer: `UserSerializer(obj, expand=['organization'])`



  ```python
  from rest_flex_fields import FlexFieldsModelSerializer

  class StateSerializer(FlexFieldsModelSerializer):
      class Meta:
          model = State
          fields = ('id', 'name')

  class CountrySerializer(FlexFieldsModelSerializer):
      class Meta:
          model = Country
          fields = ('id', 'name', 'population', 'states')
          expandable_fields = {
            'states': (StateSerializer, {'many': True})
          }

  class PersonSerializer(FlexFieldsModelSerializer):
      class Meta:
          model = Person
          fields = ('id', 'name', 'country', 'occupation')
          expandable_fields = {'country': CountrySerializer}
  ```

  ```
  GET /people/142/
  ```

  ```json
  {
    "id": 142,
    "name": "Jim Halpert",
    "country": 1
  }
  ```

  ```
  GET /people/142/?expand=country.states
  ```

  ```json
  {
    "id": 142,
    "name": "Jim Halpert",
    "country": {
      "id": 1,
      "name": "United States",
      "states": [
        {
          "id": 23,
          "name": "Ohio"
        },
        {
          "id": 2,
          "name": "Pennsylvania"
        }
      ]
    }
  }
  ```



  - [Django REST - FlexFields](#django-rest---flexfields)
  - [Overview](#overview)
  - [Quick Start](#quick-start)
  - [Table of Contents:](#table-of-contents)
  - [Setup](#setup)
  - [Usage](#usage)
    - [Dynamic Field Expansion](#dynamic-field-expansion)
    - [Deferred Fields](#deferred-fields)
    - [Deep, Nested Expansion](#deep-nested-expansion)
    - [Field Expansion on "List" Views <a id="list-views"></a>](#field-expansion-on-list-views-)
    - [Expanding a "Many" Relationship <a id="expanding-many"></a>](#expanding-a-many-relationship-)
    - [Dynamically Setting Fields (Sparse Fields) <a id="dynamically-setting-fields"></a>](#dynamically-setting-fields-sparse-fields-)
    - [Reference serializer as a string (lazy evaluation) <a id="lazy-ref"></a>](#reference-serializer-as-a-string-lazy-evaluation-)
    - [Increased re-usability of serializers <a id="increased-reuse"></a>](#increased-re-usability-of-serializers-)
  - [Serializer Options](#serializer-options)
  - [Advanced](#advanced)
    - [Customization](#customization)
    - [Serializer Introspection](#serializer-introspection)
    - [Use Wildcards to Match Multiple Fields](#wildcards)
    - [Combining Sparse Fields and Field Expansion <a id="combining-sparse-and-expanded"></a>](#combining-sparse-fields-and-field-expansion-)
    - [Utility Functions <a id="utils"></a>](#utility-functions-)
      - [rest_flex_fields.is_expanded(request, field: str)](#rest_flex_fieldsis_expandedrequest-field-str)
      - [rest_flex_fields.is_included(request, field: str)](#rest_flex_fieldsis_includedrequest-field-str)
    - [Query optimization (experimental)](#query-optimization-experimental)
  - [Changelog <a id="changelog"></a>](#changelog-)
  - [Testing](#testing)
  - [License](#license)



  First install:

  ```
  pip install drf-flex-fields
  ```

  Then have your serializers subclass `FlexFieldsModelSerializer`:

  ```python
  from rest_flex_fields import FlexFieldsModelSerializer

  class StateSerializer(FlexFieldsModelSerializer):
      class Meta:
          model = Country
          fields = ('id', 'name')

  class CountrySerializer(FlexFieldsModelSerializer):
      class Meta:
          model = Country
          fields = ('id', 'name', 'population', 'states')
          expandable_fields = {
            'states': (StateSerializer, {'many': True})
          }
  ```

  Alternatively, you can add the `FlexFieldsSerializerMixin` mixin to a model serializer.





  To define expandable fields, add an `expandable_fields` dictionary to your serializer's `Meta` class. Key the dictionary with the name of the field that you want to dynamically expand, and set its value to either the expanded serializer or a tuple where the first element is the serializer and the second is a dictionary of options that will be used to instantiate the serializer.

  ```python
  class CountrySerializer(FlexFieldsModelSerializer):
      class Meta:
          model = Country
          fields = ['name', 'population']


  class PersonSerializer(FlexFieldsModelSerializer):
      country = serializers.PrimaryKeyRelatedField(read_only=True)

      class Meta:
          model = Person
          fields = ['id', 'name', 'country', 'occupation']

          expandable_fields = {
              'country': CountrySerializer
          }
  ```

  If the default serialized response is the following:

  ```json
  {
    "id": 13322,
    "name": "John Doe",
    "country": 12,
    "occupation": "Programmer"
  }
  ```

  When you do a `GET /person/13322?expand=country`, the response will change to:

  ```json
  {
    "id": 13322,
    "name": "John Doe",
    "country": {
      "name": "United States",
      "population": 330000000
    },
    "occupation": "Programmer"
  }
  ```



  Alternatively, you could treat `country` as a "deferred" field by not defining it among the default fields. To make a field deferred, only define it within the serializer's `expandable_fields`.



  Let's say you add `StateSerializer` as a serializer nested inside the country serializer above:

  ```python
  class StateSerializer(FlexFieldsModelSerializer):
      class Meta:
          model = State
          fields = ['name', 'population']


  class CountrySerializer(FlexFieldsModelSerializer):
      class Meta:
          model = Country
          fields = ['name', 'population']

          expandable_fields = {
              'states': (StateSerializer, {'many': True})
          }

  class PersonSerializer(FlexFieldsModelSerializer):
      country = serializers.PrimaryKeyRelatedField(read_only=True)

      class Meta:
          model = Person
          fields = ['id', 'name', 'country', 'occupation']

          expandable_fields = {
              'country': CountrySerializer
          }
  ```

  Your default serialized response might be the following for `person` and `country`, respectively:

  ```json
  {
    "id" : 13322,
    "name" : "John Doe",
    "country" : 12,
    "occupation" : "Programmer",
  }

  {
    "id" : 12,
    "name" : "United States",
    "states" : "http://www.api.com/countries/12/states"
  }
  ```

  But if you do a `GET /person/13322?expand=country.states`, it would be:

  ```json
  {
    "id": 13322,
    "name": "John Doe",
    "occupation": "Programmer",
    "country": {
      "id": 12,
      "name": "United States",
      "states": [
        {
          "name": "Ohio",
          "population": 11000000
        }
      ]
    }
  }
  ```

  Please be kind to your database, as this could incur many additional queries. Though, you can mitigate this impact through judicious use of `prefetch_related` and `select_related` when defining the queryset for your viewset.



  If you request many objects, expanding fields could lead to many additional database queries. Subclass `FlexFieldsModelViewSet` if you want to prevent expanding fields by default when calling a ViewSet's `list` method. Place those fields that you would like to expand in a `permit_list_expands` property on the ViewSet:

  ```python
  from rest_flex_fields import is_expanded

  class PersonViewSet(FlexFieldsModelViewSet):
      permit_list_expands = ['employer']
      serializer_class = PersonSerializer

      def get_queryset(self):
          queryset = models.Person.objects.all()
          if is_expanded(self.request, 'employer'):
              queryset = queryset.select_related('employer')
          return queryset
  ```

  Notice how this example is using the `is_expanded` utility method as well as `select_related` and `prefetch_related` to efficiently query the database if the field is expanded.



  Set `many` to `True` in the serializer options to make sure "to many" fields are expanded correctly.

  ```python
  class StateSerializer(FlexFieldsModelSerializer):
      class Meta:
          model = State
          fields = ['name', 'population']


  class CountrySerializer(FlexFieldsModelSerializer):
      class Meta:
          model = Country
          fields = ['name', 'population']

          expandable_fields = {
              'states': (StateSerializer, {'many': True})
          }
  ```

  A request to `GET /countries?expand=states` will return:

  ```python
  {
      "id" : 12,
      "name" : "United States",
      "states" : [
        {
          "name" : "Alabama",
          "population": 11000000
        },
        //... more states ... //
        {
          "name" : "Ohio",
          "population": 11000000
        }
      ]
  }
  ```



  You can use either the `fields` or `omit` keywords to declare only the fields you want to include or to specify fields that should be excluded.

  Consider this as a default serialized response:

  ```json
  {
    "id": 13322,
    "name": "John Doe",
    "country": {
      "name": "United States",
      "population": 330000000
    },
    "occupation": "Programmer",
    "hobbies": ["rock climbing", "sipping coffee"]
  }
  ```

  To whittle down the fields via URL parameters, simply add `?fields=id,name,country` to your requests to get back:

  ```json
  {
    "id": 13322,
    "name": "John Doe",
    "country": {
      "name": "United States",
      "population": 330000000
    }
  }
  ```

  Or, for more specificity, you can use dot-notation, `?fields=id,name,country.name`:

  ```json
  {
    "id": 13322,
    "name": "John Doe",
    "country": {
      "name": "United States"
    }
  }
  ```

  Or, if you want to leave out the nested country object, do `?omit=country`:

  ```json
  {
    "id": 13322,
    "name": "John Doe",
    "occupation": "Programmer",
    "hobbies": ["rock climbing", "sipping coffee"]
  }
  ```



  To avoid circular import problems, it's possible to lazily evaluate a string reference to you serializer class using this syntax:

  ```python
  expandable_fields = {
      'record_set': ('<module_path_to_serializer_class>.RelatedSerializer', {'many': True})
  }
  ```

  **Note**:
  Prior to version `0.9.0`, it was assumed your serializer classes would be in a module with the following path:
  `<app_name>.serializers`.

  This import style will still work, but you can also now specify fully-qualified import paths to any locations.



  The `omit` and `fields` options can be passed directly to serializers. Rather than defining a separate, slimmer version of a regular serializer, you can re-use the same serializer and declare which fields you want.

  ```python
  from rest_flex_fields import FlexFieldsModelSerializer

  class CountrySerializer(FlexFieldsModelSerializer):
      class Meta:
          model = Country
          fields = ['id', 'name', 'population', 'capital', 'square_miles']

  class PersonSerializer(FlexFieldsModelSerializer):
      country = CountrySerializer(fields=['id', 'name'])

      class Meta:
          model = Person
          fields = ['id', 'name', 'country']


  serializer = PersonSerializer(person)
  print(serializer.data)

  >>>{
    "id": 13322,
    "name": "John Doe",
    "country": {
      "id": 1,
      "name": "United States",
    }
  }
  ```



  Dynamic field options can be passed in the following ways:

  - from the request's query parameters; separate multiple values with a commma
  - as keyword arguments directly to the serializer class when its constructed
  - from a dictionary placed as the second element in a tuple when defining `expandable_fields`

  Approach #1

  ```
  GET /people?expand=friends.hobbies,employer&omit=age
  ```

  Approach #2

  ```python
  serializer = PersonSerializer(
    person,
    expand=["friends.hobbies", "employer"],
    omit="friends.age"
  )
  ```

  Approach #3

  ```python

  class PersonSerializer(FlexFieldsModelSerializer):
    // Your field definitions

    class Meta:
      model = Person
      fields = ["age", "hobbies", "name"]
      expandable_fields = {
        'friends': (
          'serializer.FriendSerializer',
          {'many': True, "expand": ["hobbies"], "omit": ["age"]}
        )
      }
  ```

  | Option |                                 Description                                  |
  | ------ | :--------------------------------------------------------------------------: |
  | expand | Fields to expand; must be configured in the serializer's `expandable_fields` |
  | fields |         Fields that should be included; all others will be excluded          |
  | omit   |         Fields that should be excluded; all others will be included          |





  Parameter names and wildcard values can be configured within a Django setting, named `REST_FLEX_FIELDS`.

  | Option                        |                                                                                                                                                                                                                                                                         Description                                                                                                                                                                                                                                                                          | Default         |
  |-------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|-----------------|
  | EXPAND_PARAM                  |                                                                                                                                                                                                                                                   The name of the parameter with the fields to be expanded                                                                                                                                                                                                                                                   | `"expand"`      |
  | MAXIMUM_EXPANSION_DEPTH       |                                                                                                                                                                                                                                                      The max allowed expansion depth. By default it's unlimited. Expanding `state.towns` would equal a depth of 2                                                                                                                                                                                                                                            | `None`          |
  | FIELDS_PARAM                  |                                                                                                                                                                                                                                      The name of the parameter with the fields to be included (others will be omitted)                                                                                                                                                                                                                                       | `"fields"`      |
  | OMIT_PARAM                    |                                                                                                                                                                                                                                                   The name of the parameter with the fields to be omitted                                                                                                                                                                                                                                                    | `"omit"`        |
  | RECURSIVE_EXPANSION_PERMITTED |                                                                                                                                                                                                                                             If `False`, an exception is raised when a recursive pattern is found                                                                                                                                                                                                                                             | `True`          |
  | WILDCARD_VALUES               | List of values that stand in for all field names. Can be used with the `fields` and `expand` parameters. <br><br>When used with `expand`, a wildcard value will trigger the expansion of all `expandable_fields` at a given level.<br><br>When used with `fields`, all fields are included at a given level. For example, you could pass `fields=name,state.*` if you have a city resource with a nested state in order to expand only the city's name field and all of the state's fields. <br><br>To disable use of wildcards, set this setting to `None`. | `["*", "~all"]` |

  For example, if you want your API to work a bit more like [JSON API](https://jsonapi.org/format/#fetching-includes), you could do:

  ```python
  REST_FLEX_FIELDS = {"EXPAND_PARAM": "include"}
  ```



  A `maximum_expansion_depth` integer property can be set on a serializer class.

  `recursive_expansion_permitted` boolean property can be set on a serializer class.

  Both settings raise `serializers.ValidationError` when conditions are met but exceptions can be customized by overriding the `recursive_expansion_not_permitted` and `expansion_depth_exceeded` methods.




  When using an instance of `FlexFieldsModelSerializer`, you can examine the property `expanded_fields` to discover which fields, if any, have been dynamically expanded.



  You can pass `expand=*` ([or another value of your choosing](#customization)) to automatically expand all fields that are available for expansion at a given level. To refer to nested resources, you can use dot-notation. For example, requesting `expand=menu.sections` for a restaurant resource would expand its nested `menu` resource, as well as that menu's nested `sections` resource.

  Or, when requesting sparse fields, you can pass `fields=*` to include only the specified fields at a given level. To refer to nested resources, you can use dot-notation. For example, if you have an `order` resource, you could request all of its fields as well as only two fields on its nested `restaurant` resource with the following: `fields=*,restaurent.name,restaurant.address&expand=restaurant`.



  You may be wondering how things work if you use both the `expand` and `fields` option, and there is overlap. For example, your serialized person model may look like the following by default:

  ```json
  {
    "id": 13322,
    "name": "John Doe",
    "country": {
      "name": "United States"
    }
  }
  ```

  However, you make the following request `HTTP GET /person/13322?include=id,name&expand=country`. You will get the following back:

  ```json
  {
    "id": 13322,
    "name": "John Doe"
  }
  ```

  The `fields` parameter takes precedence over `expand`. That is, if a field is not among the set that is explicitly alllowed, it cannot be expanded. If such a conflict occurs, you will not pay for the extra database queries - the expanded field will be silently abandoned.





  Checks whether a field has been expanded via the request's query parameters.

  **Parameters**

  - **request**: The request object
  - **field**: The name of the field to check



  Checks whether a field has NOT been excluded via either the `omit` parameter or the `fields` parameter.

  **Parameters**

  - **request**: The request object
  - **field**: The name of the field to check



  An experimental filter backend is available to help you automatically reduce the number of SQL queries and their transfer size. _This feature has not been tested thorougly and any help testing and reporting bugs is greatly appreciated._ You can add FlexFieldFilterBackend to `DEFAULT_FILTER_BACKENDS` in the settings:

  ```python


  REST_FRAMEWORK = {
      'DEFAULT_FILTER_BACKENDS': (
          'rest_flex_fields.filter_backends.FlexFieldsFilterBackend',
          
      ),
      
  }
  ```

  It will automatically call `select_related` and `prefetch_related` on the current QuerySet by determining which fields are needed from many-to-many and foreign key-related models. For sparse fields requests (`?omit=fieldX,fieldY` or `?fields=fieldX,fieldY`), the backend will automatically call `only(*field_names)` using only the fields needed for serialization.

  **WARNING:** The optimization currently works only for one nesting level.





  - Adds control over whether recursive expansions are allowed and allows setting the max expansion depth. Thanks @andruten!



  - Various bug fixes. Thanks @michaelschem, @andruten, and @erielias!



  - Improvements to the filter backends for generic foreign key handling and docs generation. Thanks @KrYpTeD974 and @michaelschem!



  - Fixes bug in `FlexFieldsFilterBackend`. Thanks @michaelschem!
  - Adds `FlexFieldsDocsFilterBackend` for schema population. Thanks @Rjevski!



  - Set expandable fields as the default example for expand query parameters in `coreapi.Field`. Thanks @JasperSui!



  - Includes m2m in prefetch_related clause even if they're not expanded. Thanks @pablolmedorado and @ADR-007!



  - Make it possible to use wildcard values with sparse fields requests.



  - Adds OpenAPI support. Thanks @soroush-tabesh!
  - Updates tests for Django 3.2 and fixes deprecation warning. Thanks @giovannicimolin!



  - Fixes bug where custom parameter names were not passed when constructing nested serializers. Thanks @Kandeel4411!



  - Ensures `context` dict is passed down to expanded serializers. Thanks @nikeshyad!



  - No longer auto removes `source` argument if it's equal to the field name.



  - Allows fully qualified import strings for lazy serializer classes.



  - Adds OpenAPI support to experimental filter backend. Thanks @LukasBerka!



  - Django 3.1.1 fix. Thansks @NiyazNz!
  - Docs typo fix. Thanks @zakjholt!



  - Adds `is_included` utility function.



  - Adds options to customize parameter names and wildcard values. Closes #10.



  - Fixes #44, related to the experimental filter backend. Thanks @jsatt!



  - Adds support for `expand`, `omit` and `fields` query parameters for non-GET requests.
    - The common use case is creating/updating a model instance and returning a serialized response with expanded fields
    - Thanks @kotepillar for raising the issue (#25) and @Crocmagnon for the idea of delaying field modification to `to_representation()`.



  - Simplifies declaration of `expandable_fields`
    - If using a tuple, the second element - to define the serializer settings - is now optional.
    - Instead of a tuple, you can now just use the serializer class or a string to lazily reference that class.
    - Updates documentation.



  - Adds support for different ways of passing arrays in query strings. Thanks @sentyaev!
  - Fixes attribute error when map is supplied to split levels utility function. Thanks @hemache!



  - Adds experimental support for automatically SQL query optimization via a `FlexFieldsFilterBackend`. Thanks ADR-007!
  - Adds CircleCI config file. Thanks mikeIFTS!
  - Moves declaration of `expandable_fields` to `Meta` class on serialzer for consistency with DRF (will continue to support declaration as class property)
  - Python 2 is no longer supported. If you need Python 2 support, you can continue to use older versions of this package.



  - Added support for `omit` keyword for field exclusion. Code clean up and improved test coverage.



  - Handle case where `request` is `None` when accessing request object from serializer. Thanks @jsatt!



  - Exposes `FlexFieldsSerializerMixin` in addition to `FlexFieldsModelSerializer`. Thanks @jsatt!



  Tests are found in a simplified DRF project in the `/tests` folder. Install the project requirements and do `./manage.py test` to run them.



  See [License](LICENSE.md).


pkgId: 7e20b038126e77372d037e5415a2c3f739b8b56e706da5f39fcfc8ea8e06b2cb
name: python-drf-jwt
arch: src
version: 1.19.2
epoch: 0
release: 1
summary: JSON Web Token based authentication for Django REST framework
url: https://github.com/Styria-Digital/django-rest-framework-jwt
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c1e25b1-7e05-48c4-9f7a-6c81e1f49ee2
location_href: 00011377-python-drf-jwt/python-drf-jwt-1.19.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/Styria-Digital/django-rest-framework-jwt.svg?branch=master)](https://travis-ci.org/Styria-Digital/django-rest-framework-jwt)
  [![Coverage](https://codecov.io/github/Styria-Digital/django-rest-framework-jwt/branch/master/graph/badge.svg)](https://codecov.io/github/Styria-Digital/django-rest-framework-jwt/branch/master)

  JSON Web Token Authentication support for Django REST Framework



  This package provides [JSON Web Token Authentication][jwt-auth-spec] support
  for [Django REST framework][drf].

  If you want to know more about JWT, check out the following resources:

   - DjangoCon 2014 - JSON Web Tokens [Video][jwt-video] | [Slides][jwt-slides]
   - [Auth with JSON Web Tokens][auth-jwt]
   - [JWT.io][jwt-io]



  -  Python 2.7, 3.4+
  -  Django 1.11+
  -  Django REST Framework 3.7+



  ```bash
  $ pip install drf-jwt
  ```



  Full documentation for the project is available at [docs][docs].

  [jwt-auth-spec]: http://tools.ietf.org/html/draft-ietf-oauth-json-web-token
  [drf]: http://django-rest-framework.org/
  [jwt-video]: https://www.youtube.com/watch?v=825hodQ61bg
  [jwt-slides]: https://speakerdeck.com/jpadilla/djangocon-json-web-tokens
  [auth-jwt]: http://jpadilla.com/post/73791304724/auth-with-json-web-tokens
  [jwt-io]: http://jwt.io/
  [docs]: http://styria-digital.github.io/django-rest-framework-jwt


pkgId: eef1a4ad6c2ce1e13bf495c5fe3b2fa3180fa98748da68ff3615993fdc834e3f
name: python-drf-nested-routers
arch: src
version: 0.93.4
epoch: 0
release: 1
summary: Nested resources for the Django Rest Framework
url: https://github.com/alanjds/drf-nested-routers
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-59b06379-df10-43f6-9946-7552acda11e1
location_href: 00010337-python-drf-nested-routers/python-drf-nested-routers-0.93.4-1.src.rpm
checksum_type: sha256
description:
  **This is a work in progress. It "works for me" at www.apiregistro.com.br,
  but I cannot warranty that it fully "works everywhere" yet. Join us on Gitter (below) if you need some help.**



  [![Join the chat at https://gitter.im/alanjds/drf-nested-routers](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/alanjds/drf-nested-routers?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Build Status](https://github.com/alanjds/drf-nested-routers/workflows/CI/badge.svg)](https://github.com/alanjds/drf-nested-routers/actions?query=workflow%3ACI+branch%3Amaster)

  This package provides routers and fields to create nested resources in the [Django Rest Framework](http://django-rest-framework.org/)

  Nested resources are needed for full REST URL structure, if one resource lives inside another.

  The following example is about Domains and DNS Nameservers.
  There are many domains, and each domain has many nameservers. The "nameserver" resource does not
  exist without a domain, so you need it "nested" inside the domain.




  -  Python (3.6, 3.7, 3.8, 3.9)
  -  Django (2.2, 3.0, 3.1)
  -  Django REST Framework (3.11)

  It may work with lower versions, but since the release **0.92.1** is no more
  tested on CI for Pythons 2.7 to 3.5, Django 1.11 to 2.1 or DRF 3.6 to 3.10.




  You can install this library using pip:

  ```pip install drf-nested-routers```

  It is not needed to add this library in your Django project's `settings.py` file, as it does not contain any app, signal or model.



  The desired URL signatures are:
  ```
  /domain/ <- Domains list
  /domain/{pk}/ <- One domain, from {pk}
  /domain/{domain_pk}/nameservers/ <- Nameservers of domain from {domain_pk}
  /domain/{domain_pk}/nameservers/{pk} <- Specific nameserver from {pk}, of domain from {domain_pk}
  ```

  How to do it (example):
  ```python

  from rest_framework_nested import routers
  from views import DomainViewSet, NameserverViewSet
  (...)

  router = routers.SimpleRouter()
  router.register(r'domains', DomainViewSet)

  domains_router = routers.NestedSimpleRouter(router, r'domains', lookup='domain')
  domains_router.register(r'nameservers', NameserverViewSet, basename='domain-nameservers')



  urlpatterns = patterns('',
      url(r'^', include(router.urls)),
      url(r'^', include(domains_router.urls)),
  )
  ```

  ```python




  class NameserverViewSet(viewsets.ModelViewSet):
      def get_queryset(self):
          return Nameserver.objects.filter(domain=self.kwargs['domain_pk'])



  class NameserverViewSet(viewsets.ViewSet):
      def list(self, request, domain_pk=None):
          nameservers = self.queryset.filter(domain=domain_pk)
          (...)
          return Response([...])

      def retrieve(self, request, pk=None, domain_pk=None):
          nameservers = self.queryset.get(pk=pk, domain=domain_pk)
          (...)
          return Response(serializer.data)
  ```





  **(optional)** If you need hyperlinks for nested relations, you need a custom serializer.

  There you will inform how to access the *parent* of the instance being serialized when
  building the *children* URL.

  In the following example, an instance of Nameserver on `/domain/{domain_pk}/nameservers/{pk}`
  is being informed that the *parent* Domain should be looked up using the `domain_pk` kwarg
  from the URL:
  ```python


  from rest_framework_nested.relations import NestedHyperlinkedRelatedField

  class DomainSerializer(HyperlinkedModelSerializer):
      class Meta:
          model = Domain

      nameservers = HyperlinkedIdentityField(
          view_name='domain-nameservers-list',
          lookup_url_kwarg='domain_pk'
                          
                          
      )

  	

      nameservers = NestedHyperlinkedRelatedField(
          many=True,
          read_only=True,   # Or add a queryset
          view_name='domain-nameservers-detail',
          parent_lookup_kwargs={'domain_pk': 'domain__pk'}
                              
                              
      )
  ```

  **(optional)** If you want a little bit more control over the fields displayed for the nested relations while looking at the parent, you need a custom serializer using NestedHyperlinkedModelSerializer.
  ```python
  from rest_framework.serializers import HyperlinkedModelSerializer
  from rest_framework_nested.serializers import NestedHyperlinkedModelSerializer

  class NameserverSerializers(HyperlinkedModelSerializer):
  	class Meta:
  		model = Nameserver
  		fields = (...)


  class DomainNameserverSerializers(NestedHyperlinkedModelSerializer):
  	parent_lookup_kwargs = {
  		'domain_pk': 'domain__pk',
  	}
  	class Meta:
  		model = Nameserver
  		fields = ('url', ...)


  class DomainSerializer(HyperlinkedModelSerializer):
  	class Meta:
  		model = Domain
  		fields = (..., 'nameservers')

  	nameservers = DomainNameserverSerializers(many=True, read_only=True)
  ```



  Example of nested router 3 levels deep.
  You can use this same logic to nest routers as deep as you need.
  This example ahead accomplishes the below URL patterns.
  ```
  /clients/
  /clients/{pk}/
  /clients/{client_pk}/maildrops/
  /clients/{client_pk}/maildrops/{maildrop_pk}/
  /clients/{client_pk}/maildrops/{maildrop_pk}/recipients/
  /clients/{client_pk}/maildrops/{maildrop_pk}/recipients/{pk}/
  ```

  ```python

  router = DefaultRouter()
  router.register(r'clients', ClientViewSet, basename='clients')




  client_router = routers.NestedSimpleRouter(router, r'clients', lookup='client')
  client_router.register(r'maildrops', MailDropViewSet, basename='maildrops')




  maildrops_router = routers.NestedSimpleRouter(client_router, r'maildrops', lookup='maildrop')
  maildrops_router.register(r'recipients', MailRecipientViewSet, basename='recipients')




  urlpatterns = patterns (
      '',
      url(r'^', include(router.urls)),
      url(r'^', include(client_router.urls)),
      url(r'^', include(maildrops_router.urls)),
  )
  ```

  ```python

  class ClientViewSet(viewsets.ViewSet):
      serializer_class = ClientSerializer

      def list(self, request,):
          queryset = Client.objects.filter()
          serializer = ClientSerializer(queryset, many=True)
          return Response(serializer.data)

      def retrieve(self, request, pk=None):
          queryset = Client.objects.filter()
          client = get_object_or_404(queryset, pk=pk)
          serializer = ClientSerializer(client)
          return Response(serializer.data)


  class MailDropViewSet(viewsets.ViewSet):
      serializer_class = MailDropSerializer

      def list(self, request, client_pk=None):
          queryset = MailDrop.objects.filter(client=client_pk)
          serializer = MailDropSerializer(queryset, many=True)
          return Response(serializer.data)

      def retrieve(self, request, pk=None, client_pk=None):
          queryset = MailDrop.objects.filter(pk=pk, client=client_pk)
          maildrop = get_object_or_404(queryset, pk=pk)
          serializer = MailDropSerializer(maildrop)
          return Response(serializer.data)


  class MailRecipientViewSet(viewsets.ViewSet):
      serializer_class = MailRecipientSerializer

      def list(self, request, client_pk=None, maildrop_pk=None):
          queryset = MailRecipient.objects.filter(mail_drop__client=client_pk, mail_drop=maildrop_pk)
          serializer = MailRecipientSerializer(queryset, many=True)
          return Response(serializer.data)

      def retrieve(self, request, pk=None, client_pk=None, maildrop_pk=None):
          queryset = MailRecipient.objects.filter(pk=pk, mail_drop=maildrop_pk, mail_drop__client=client_pk)
          maildrop = get_object_or_404(queryset, pk=pk)
          serializer = MailRecipientSerializer(maildrop)
          return Response(serializer.data)
  ```

  ```python

  class ClientSerializer(HyperlinkedModelSerializer):
      class Meta:
          model = Client
          fields = (...)


  class MailDropSerializer(NestedHyperlinkedModelSerializer):
      parent_lookup_kwargs = {
          'client_pk': 'client__pk',
      }
      class Meta:
          model = MailDrop
          fields = (...)


  class MailRecipientSerializer(NestedHyperlinkedModelSerializer):
      parent_lookup_kwargs = {
          'maildrop_pk': 'mail_drop__pk',
          'client_pk': 'mail_drop__client__pk',
      }
      class Meta:
          model = MailRecipient
          fields = (...)
  ```



  In order to get started with testing, you will need to install [tox](https://tox.readthedocs.io/en/latest/).
  Once installed, you can then run one environment locally, to speed up your development cycle:

  ```
  $ tox -e py39-django3.1-drf3.11
  ```

  Once you submit a pull request, your changes will be run against many environments with GitHub Actions named CI.




  This package is licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
  and can undestand more at http://choosealicense.com/licenses/apache/ on the
  sidebar notes.

  Apache Licence v2.0 is a MIT-like licence. This means, in plain English:
  - It's truly open source
  - You can use it as you wish, for money or not
  - You can sublicence it (change the licence!!)
  - This way, you can even use it on your closed-source project
  As long as:
  - You cannot use the authors name, logos, etc, to endorse a project
  - You keep the authors copyright notices where this code got used, even on your closed-source project
  (come on, even Microsoft kept BSD notices on Windows about its TCP/IP stack :P)


pkgId: cebfc19cc34efe5b63fc645e84e321c4ff0e34aecbf392cc3b46f5ba7319f16f
name: python-dropbox
arch: src
version: 11.36.0
epoch: 0
release: 1
summary: Official Dropbox API Client
url: http://www.dropbox.com/developers
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03786599-e474-4df1-b0fb-f41570f1586c
location_href: 00003545-python-dropbox/python-dropbox-11.36.0-1.src.rpm
checksum_type: sha256
description:
  Create an app via the `Developer Console`_.
  Install via `pip <https://pip.pypa.io/>`_:
      $ pip install dropbox
  Install from source:
      $ git clone git://github.com/dropbox/dropbox-sdk-python.git
      $ cd dropbox-sdk-python
      $ python setup.py install
  After installation, follow one of our `Examples`_ or read the documentation on `Read The Docs`_.
  You can also view our `OAuth Guide`_.


pkgId: f97ee8a418d3f857c3987f9fa24758d971dfcd0b5cef83b0e9d1262da7968d98
name: python-dtale
arch: src
version: 2.14.0
epoch: 0
release: 1
summary: Web Client for Visualizing Pandas Objects
url: https://github.com/man-group/dtale
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e8945824-e288-4ae1-b58f-47bd98ac81e7
location_href: 00012328-python-dtale/python-dtale-2.14.0-1.src.rpm
checksum_type: sha256
description:
  |CircleCI| |PyPI Python Versions| |PyPI| |Conda| |ReadTheDocs| |codecov|
  |Downloads| |Open in VS Code|


pkgId: 83cae70fde870b81c54250c798ecb4c6070a1a1d01b667aeeac4169cae378013
name: python-dtfabric
arch: src
version: 20221218
epoch: 0
release: 1
summary: Data type fabric (dtfabric)
url: https://github.com/libyal/dtfabric
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-69f73845-f584-480f-9713-77563b643f0b
location_href: 00003546-python-dtfabric/python-dtfabric-20221218-1.src.rpm
checksum_type: sha256
description:
  dtFabric, or data type fabric, is a project to manage data types and structures, as used in the libyal projects.


pkgId: ee015ef57622b133da9a15c9560f36956fb2e9500de7a9c8a4382418d0a61ceb
name: python-dtopt
arch: src
version: 0.1
epoch: 0
release: 1
summary: Add options to doctest examples while they are running
url: http://pypi.python.org/pypi/dtopt/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-18cf820e-6a29-4517-bc84-9e9c5c475bb7
location_href: 00003547-python-dtopt/python-dtopt-0.1-1.src.rpm
checksum_type: sha256
description:
  When using the `doctest
  <http://python.org/doc/current/lib/module-doctest.html>`_ module it is often
  convenient to use the ELLIPSIS option, which allows you to use ``...`` as a
  wildcard.  But you either have to setup the test runner to use this option, or
  you must put ``#doctest: +ELLIPSIS`` on *every* example that uses this feature.

  ``dtopt`` lets you enable this option globally from within a doctest, by doing::

      >>> from dtopt import ELLIPSIS

  (The options ``NORMALIZE_WHITESPACE`` and ``COMPARE`` are also available)

  You can install this from `the subversion repository
  <http://svn.colorstudy.com/dtopt/trunk/#egg=dtopt-dev>`_ with ``easy_install
  dtopt==dev``.


pkgId: 2e6c477580f6cd61c86227b14e814527bf79758a98dd1e5c74613c1b31e02ac9
name: python-dtreeviz
arch: src
version: 2.2.0
epoch: 0
release: 1
url: https://github.com/parrt/dtreeviz
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8065680b-b90b-48fb-9a40-5bd879f717e4
location_href: 00010897-python-dtreeviz/python-dtreeviz-2.2.0-1.src.rpm
checksum_type: sha256
summary:
  A Python 3 library for sci-kit learn, XGBoost, LightGBM, Spark, and TensorFlow decision tree visualization

description:
  A python library for decision tree visualization and model interpretation.  Decision trees are the fundamental building block of [gradient boosting machines](http://explained.ai/gradient-boosting/index.html) and [Random Forests](https://en.wikipedia.org/wiki/Random_forest)(tm), probably the two most popular machine learning models for structured data.  Visualizing decision trees is a tremendous aid when learning how these models work and when interpreting models. The visualizations are inspired by an educational animation by [R2D3](http://www.r2d3.us/); [A visual introduction to machine learning](http://www.r2d3.us/visual-intro-to-machine-learning-part-1/). Please see [How to visualize decision trees](http://explained.ai/decision-tree-viz/index.html) for deeper discussion of our decision tree visualization library and the visual design decisions we made.

  Currently dtreeviz supports: [scikit-learn](https://scikit-learn.org/stable), [XGBoost](https://xgboost.readthedocs.io/en/latest), [Spark MLlib](https://spark.apache.org/mllib/), [LightGBM](https://lightgbm.readthedocs.io/en/latest/), and [Tensorflow](https://www.tensorflow.org/decision_forests).  See [Installation instructions](README.md#Installation).


pkgId: 8eb7f8c1aff1f019fa2f64ddd79ff150d40bdbe764e27980edcb102eabcb01be
name: python-duecredit
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Publications (and donations) tracer
url: https://github.com/duecredit/duecredit
rpm_license: 2-clause BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c8327333-aec6-4a73-9f8d-4a5e1c2d1ce8
location_href: 00003548-python-duecredit/python-duecredit-0.9.2-1.src.rpm
checksum_type: sha256
description:
      [1] Van Der Walt, S., Colbert, S.C. & Varoquaux, G., 2011. The NumPy array: a structure for efficient numerical computation. Computing in Science & Engineering, 13(2), pp.22–30.
      [2] Jones, E. et al., 2001. SciPy: Open source scientific tools for Python.
      [3] Sibson, R., 1973. SLINK: an optimally efficient algorithm for the single-link cluster method. The Computer Journal, 16(1), pp.30–34.
  Incremental runs of various software would keep enriching that file.
  Then you can use `duecredit summary` command to show that information
  again (stored in `.duecredit.p` file) or export it as a BibTeX file
  ready for reuse, e.g.:
      $> duecredit summary --format=bibtex
      @article{van2011numpy,
              title={The NumPy array: a structure for efficient numerical computation},
              author={Van Der Walt, Stefan and Colbert, S Chris and Varoquaux, Gael},
              journal={Computing in Science \& Engineering},
              volume={13},
              number={2},
              pages={22--30},
              year={2011},
              publisher={AIP Publishing}
              }
      @Misc{JOP+01,
            author =    {Eric Jones and Travis Oliphant and Pearu Peterson and others},
            title =     {{SciPy}: Open source scientific tools for {Python}},
            year =      {2001--},
            url = "http://www.scipy.org/",
            note = {[Online; accessed 2015-07-13]}
          }
      @article{sibson1973slink,
              title={SLINK: an optimally efficient algorithm for the single-link cluster method},
              author={Sibson, Robin},
              journal={The Computer Journal},
              volume={16},
              number={1},
              pages={30--34},
              year={1973},
              publisher={Br Computer Soc}
          }
  and if by default only references for "implementation" are listed, we
  can enable listing of references for other tags as well (e.g. "edu"
  depicting instructional materials -- textbooks etc. on the topic):
      $> DUECREDIT_REPORT_TAGS=* duecredit summary
      DueCredit Report:
      - Scientific tools library / numpy (v 1.10.4) [1]
      - Scientific tools library / scipy (v 0.14) [2]
        - Hierarchical clustering / scipy.cluster.hierarchy (v 0.14) [3, 4, 5, 6, 7, 8, 9]
        - Single linkage hierarchical clustering / scipy.cluster.hierarchy:linkage (v 0.14) [10, 11]
      2 packages cited
      1 module cited
      1 function cited


pkgId: 08861964ef679fdb86a924c270e7f8a301a93587c97cf58abefda701842b35c7
name: python-dukpy
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Simple JavaScript interpreter for Python
url: https://github.com/amol-/dukpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-25769f24-1aef-4ce1-840d-ceacd38e95e7
location_href: 00003549-python-dukpy/python-dukpy-0.3.0-1.src.rpm
checksum_type: sha256
description:
  DukPy is a simple javascript interpreter for Python built on top of
  duktape engine **without any external dependency**.
  It comes with a bunch of common transpilers built-in for convenience:
      - *CoffeeScript*
      - *BabelJS*
      - *TypeScript*
      - *JSX*
      - *LESS*


pkgId: c4fefc45d4931156fe06be62f8c41909a83d5642f133a33ae0e09420ec04f789
name: python-dukpy-debuginfo
arch: aarch64
version: 0.3.0
epoch: 0
release: 1
summary: Debug information for package python-dukpy
url: https://github.com/amol-/dukpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-25769f24-1aef-4ce1-840d-ceacd38e95e7
rpm_sourcerpm: python-dukpy-0.3.0-1.src.rpm
location_href: 00003549-python-dukpy/python-dukpy-debuginfo-0.3.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-dukpy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 5e489595fd7fce2f49773bfcbc3f789d4b118ec48dc1291e7d22bbf0ffbc0078
name: python-dukpy-debugsource
arch: aarch64
version: 0.3.0
epoch: 0
release: 1
summary: Debug sources for package python-dukpy
url: https://github.com/amol-/dukpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-25769f24-1aef-4ce1-840d-ceacd38e95e7
rpm_sourcerpm: python-dukpy-0.3.0-1.src.rpm
location_href: 00003549-python-dukpy/python-dukpy-debugsource-0.3.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-dukpy.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 7595d3508f706ea7265dadd0909c776bbf20915b9493b16bc554567fa4c2a1f5
name: python-dulwich
arch: src
version: 0.21.3
epoch: 0
release: 1
summary: Python Git Library
url: https://www.dulwich.io/
rpm_license: Apachev2 or later or GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0751cf95-49bc-4675-99cd-9574c8e9ecad
location_href: 00003550-python-dulwich/python-dulwich-0.21.3-1.src.rpm
checksum_type: sha256
description:
  This is the Dulwich project.
  It aims to provide an interface to git repos (both local and remote) that
  doesn't call out to git directly but instead uses pure Python.
  **Main website**: <https://www.dulwich.io/>
  **License**: Apache License, version 2 or GNU General Public License, version 2 or later.
  The project is named after the part of London that Mr. and Mrs. Git live in
  in the particular Monty Python sketch.


pkgId: d1fc99270584b5279c8adebd9df50f0df0dbb8aca5351f840bac03313de7c1f1
name: python-dulwich-debuginfo
arch: aarch64
version: 0.21.3
epoch: 0
release: 1
summary: Debug information for package python-dulwich
url: https://www.dulwich.io/
rpm_license: Apachev2 or later or GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-0751cf95-49bc-4675-99cd-9574c8e9ecad
rpm_sourcerpm: python-dulwich-0.21.3-1.src.rpm
location_href: 00003550-python-dulwich/python-dulwich-debuginfo-0.21.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-dulwich.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1d2f04567a88e5fa2e6a12dccffbcbe398c0b44657d1a8ba609708e4ebdae8f8
name: python-dulwich-debugsource
arch: aarch64
version: 0.21.3
epoch: 0
release: 1
summary: Debug sources for package python-dulwich
url: https://www.dulwich.io/
rpm_license: Apachev2 or later or GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-0751cf95-49bc-4675-99cd-9574c8e9ecad
rpm_sourcerpm: python-dulwich-0.21.3-1.src.rpm
location_href: 00003550-python-dulwich/python-dulwich-debugsource-0.21.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-dulwich.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: ed8122206201ec4e05e48b25885c0585cc04205af87e6e33a498d79b8d44cb08
name: python-dumbyaml
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: A YAML parser that reads only a restricted version of YAML.
url: https://github.com/crdoconnor/dumbyaml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4392b816-e047-4405-b2de-d6e0fcac23a8
location_href: 00010925-python-dumbyaml/python-dumbyaml-0.9.3-1.src.rpm
checksum_type: sha256
description:
  DEPRECATED

  Please use StrictYAML instead:

  * https://github.com/crdoconnor/strictyaml
  * http://pypi.python.org/pypi/strictyaml


pkgId: 52542ccea40ab3ced9c0a997aed0f32139a0ad4bf6d076110f0c7f449de4fcd5
name: python-dunamai
arch: src
version: 1.16.0
epoch: 0
release: 1
summary: Dynamic version generation
url: https://github.com/mtkennerly/dunamai
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f05cc9b3-6d7b-4fa0-8500-9a2687303dac
location_href: 00011395-python-dunamai/python-dunamai-1.16.0-1.src.rpm
checksum_type: sha256
description:
  Dunamai is a Python 3.5+ library and command line tool for producing dynamic,
  standards-compliant version strings, derived from tags in your version
  control system. This facilitates uniquely identifying nightly or per-commit
  builds in continuous integration and releasing new versions of your software
  simply by creating a tag.

  Dunamai is also available as a [GitHub Action](https://github.com/marketplace/actions/run-dunamai).


  * Version control system support:
    * [Git](https://git-scm.com) (2.7.0+ is recommended, but versions as old as 1.8.2.3 will work with some reduced functionality)
    * [Mercurial](https://www.mercurial-scm.org)
    * [Darcs](http://darcs.net)
    * [Subversion](https://subversion.apache.org)
    * [Bazaar](https://bazaar.canonical.com/en)
    * [Fossil](https://www.fossil-scm.org/home/doc/trunk/www/index.wiki)
    * [Pijul](https://pijul.org)
  * Version styles:
    * [PEP 440](https://www.python.org/dev/peps/pep-0440)
    * [Semantic Versioning](https://semver.org)
    * [Haskell Package Versioning Policy](https://pvp.haskell.org)
    * Custom output formats
  * Can be used for projects written in any programming language.
    For Python, this means you do not need a setup.py.



  ```
  pip install dunamai
  ```


  ```console



  $ dunamai from any
  0.2.0.post7.dev0+g29045e8


  $ dunamai from git --no-metadata --style semver
  0.2.0-post.7


  $ dunamai from any --format "v{base}+{distance}.{commit}"
  v0.2.0+7.g29045e8



  $ dunamai from any --bump
  0.2.1.dev7+g29045e8


  $ dunamai from any --format "v{base}" --style pep440
  Version 'v0.2.0' does not conform to the PEP 440 style


  $ dunamai check 0.01.0 --style semver
  Version '0.01.0' does not conform to the Semantic Versioning style


  $ dunamai --help
  $ dunamai from --help
  $ dunamai from git --help
  ```



  ```python
  from dunamai import Version, Style


  version = Version.from_git()
  assert version.serialize() == "0.1.0"



  version = Version.from_any_vcs()
  assert version.serialize() == "0.1.0rc5.post44.dev0+g644252b"
  assert version.serialize(metadata=False) == "0.1.0rc5.post44.dev0"
  assert version.serialize(dirty=True) == "0.1.0rc5.post44.dev0+g644252b.dirty"
  assert version.serialize(style=Style.SemVer) == "0.1.0-rc.5.post.44+g644252b"
  ```

  The `serialize()` method gives you an opinionated, PEP 440-compliant default
  that ensures that versions for untagged commits are compatible with Pip's
  `--pre` flag. The individual parts of the version are also available for you
  to use and inspect as you please:

  ```python
  assert version.base == "0.1.0"
  assert version.stage == "rc"
  assert version.revision == 5
  assert version.distance == 44
  assert version.commit == "g644252b"
  assert version.dirty is True


  assert version.tagged_metadata == "linux"
  ```


  By default, the "v" prefix on the tag is required, unless you specify
  a custom tag pattern. You can either write a regular expression:

  ```console
  $ dunamai from any --pattern "(?P<base>\d+\.\d+\.\d+)"
  ```

  ```python
  from dunamai import Version

  version = Version.from_any_vcs(pattern=r"(?P<base>\d+\.\d+\.\d+)")
  ```

  ...or use a named preset:

  ```console
  $ dunamai from any --pattern default-unprefixed
  ```

  ```python
  from dunamai import Version, Pattern

  version = Version.from_any_vcs(pattern=Pattern.DefaultUnprefixed)
  ```


  Sometimes, you may only have access to an archive of a repository (e.g., a zip file) without the full history.
  Dunamai can still detect a version in some of these cases:

  * For Git, you can configure `git archive` to produce a file with some metadata for Dunamai.

    Add a `.git_archival.json` file to the root of your repository with this content:
    ```
    {
      "hash-full": "$Format:%H$",
      "hash-short": "$Format:%h$",
      "timestamp": "$Format:%cI$",
      "refs": "$Format:%D$",
      "describe": "$Format:$"
    }
    ```

    Add this line to your `.gitattributes` file.
    If you don't already have this file, add it to the root of your repository:
    ```
    .git_archival.json  export-subst
    ```

  * For Mercurial, Dunamai will detect and use an `.hg_archival.txt` file created by `hg archive`.
    It will also recognize `.hgtags` if present.


  Here are the available substitutions for custom formats. If you have a tag like
  `v9!0.1.2-beta.3+other`, then:

  * `{base}` = `0.1.2`
  * `{stage}` = `beta`
  * `{revision}` = `3`
  * `{distance}` is the number of commits since the last
  * `{commit}` is the commit hash (defaults to short form, unless you use `--full-commit`)
  * `{dirty}` expands to either "dirty" or "clean" if you have uncommitted modified files
  * `{tagged_metadata}` = `other`
  * `{epoch}` = `9`
  * `{branch}` = `feature/foo`
  * `{branch_escaped}` = `featurefoo`
  * `{timestamp}` is in the format `YYYYmmddHHMMSS` as UTC

  If you specify a substitution, its value will always be included in the output.
  For conditional formatting, you can do something like this (Bash):

  ```bash
  distance=$(dunamai from any --format "{distance}")
  if [ "$distance" = "0" ]; then
      dunamai from any --format "v{base}"
  else
      dunamai from any --format "v{base}+{distance}.{dirty}"
  fi
  ```


  [Versioneer](https://github.com/warner/python-versioneer) is another great
  library for dynamic versions, but there are some design decisions that
  prompted the creation of Dunamai as an alternative:

  * Versioneer requires a setup.py file to exist, or else `versioneer install`
    will fail, rendering it incompatible with non-setuptools-based projects
    such as those using Poetry or Flit. Dunamai can be used regardless of the
    project's build system.
  * Versioneer has a CLI that generates Python code which needs to be committed
    into your repository, whereas Dunamai is just a normal importable library
    with an optional CLI to help statically include your version string.
  * Versioneer produces the version as an opaque string, whereas Dunamai provides
    a Version class with discrete parts that can then be inspected and serialized
    separately.
  * Versioneer provides customizability through a config file, whereas Dunamai
    aims to offer customizability through its library API and CLI for both
    scripting support and use in other libraries.


  * Setting a `__version__` statically:

    ```console
    $ echo "__version__ = '$(dunamai from any)'" > your_library/_version.py
    ```
    ```python
    
    from your_library._version import __version__
    ```

    Or dynamically (but Dunamai becomes a runtime dependency):

    ```python
    
    import dunamai as _dunamai
    __version__ = _dunamai.get_version("your-library", third_choice=_dunamai.Version.from_any_vcs).serialize()
    ```

  * setup.py (no install-time dependency on Dunamai as long as you use wheels):

    ```python
    from setuptools import setup
    from dunamai import Version

    setup(
        name="your-library",
        version=Version.from_any_vcs().serialize(),
    )
    ```

    Or you could use a static inclusion approach as in the prior example.

  * [Poetry](https://poetry.eustace.io):

    ```console
    $ poetry version $(dunamai from any)
    ```

    Or you can use the [poetry-dynamic-versioning](https://github.com/mtkennerly/poetry-dynamic-versioning) plugin.


  * When using Git, remember that lightweight tags do not store their creation time.
    Therefore, if a commit has multiple lightweight tags,
    we cannot reliably determine which one should be considered the newest.
    The solution is to use annotated tags instead.
  * When using Git, the initial commit must **not** be both tagged and empty
    (i.e., created with `--allow-empty`). This is related to a reporting issue
    in Git. For more info, [click here](https://github.com/mtkennerly/dunamai/issues/14).


pkgId: 3c88d14395e47373ac37c7e031a30d143eef5ba4140fd2ae6416c383d345d91e
name: python-dynamodb-json
arch: src
version: 1.3
epoch: 0
release: 1
summary: A DynamoDB json util from and to python objects
url: https://github.com/Alonreznik/dynamodb-json
rpm_license: Mozilla
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c0e111d-8976-44bc-a3a5-25020584c313
location_href: 00010941-python-dynamodb-json/python-dynamodb-json-1.3-1.src.rpm
checksum_type: sha256
description:
  DynamoDB json util to load and dump strings of Dynamodb json format to python object and vise-versa


  just use pip:
  ```
  pip install dynamodb-json
  ```


  The dynamodb-json util works the same as json loads and dumps functions:
  ```python
  import time
  import uuid
  from datetime import datetime
  from decimal import Decimal

  from dynamodb_json import json_util as json

  json_ = {"MyString": "a",
           "num": 4,
           "MyBool": False,
           "my_dict": {"my_date": datetime.utcnow()},
           "MyNone": None,
           "MyZero": 0,
           "myDecimal": Decimal("19.2"),  # converts Decimal to float, load it as float
           "myLong": long(1938475658493),
           "MyNestedDict": {
               "my_other_nested": {
                   "name": "John",
                   "surname": "Lennon",
                   "MyOtherNone": None,
                   "floaty": float(29.4),
                   "myList": [1, 3, 4, 5, 6, "This Is Sparta!"],
                   "mySet": {1, 3, 4, 5, 6},  # converts set to list, returns as list
                   "myUUID": uuid.uuid4(),  # converts uuid to string, loads it as string
                   "time": time.time()  # converts it to seconds python float, loads it as float
               }
           }
      }

  dynamodb_json = json.dumps(json_)






















  json.loads(dynamodb_json)


















  ```


pkgId: 59af9cf7f0d82a354da33fbf99674b4494aa3dfb7e971bfe20d17806a19064be
name: python-easyargs
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: Making argument parsing easy
url: https://github.com/stedmeister/easyargs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7fcaf6aa-bd30-4c26-aeb6-26fd75b97871
location_href: 00003552-python-easyargs/python-easyargs-0.9.4-1.src.rpm
checksum_type: sha256
description:
  A project designed to make command line argument parsing easy.
  There are many ways to create a command line parser in python: argparse, docopt,
  click.  These are all great options, but require quite a lot of configuration
  and sometimes you just need a function to be called.  Enter easyargs.  Define
  the function that you want to be called, decorate it and let easyargs work out
  the command line.  This is probably best shown with an example that takes one
  required argument and two optional ones:
      from __future__ import print_function
      import easyargs
      @easyargs
      def main(name, count=1, greeting='Hello'):
          """A simple greeting program"""
          for i in range(count):
              print('{greeting} {name}!'.format(greeting=greeting, name=name))
      if __name__ == '__main__':
          main()
  In this example, main is inspected, the arg keywords are turned into
  positional arguments and the kwarg keywords will be turned
  into optional arguments.  This can be seen if we run the above script with the
  help flag:
      $ python simple.py -h
      usage: simple_test.py [-h] [--count COUNT] [--greeting GREETING] name
      A simple greeting program
      positional arguments:
        name
      optional arguments:
        -h, --help           show this help message and exit
        --count COUNT
        --greeting GREETING
  A few things worth noting.  Firstly, the description is taken from the docstring
  of the function.  Secondly, there is no need to convert count to an integer.
  Because the default argument is of type int, the value is coerced to an integer:
      $ python simple.py World
      Hello World
      $ python simple.py everybody --count 2 --greeting Hola
      Hola everybody!
      Hola everybody!


pkgId: ad8818889b6e70034dd26dc0a27aae6e190c61fe9a90728780fe870d531028a1
name: python-easygui
arch: src
version: 0.98.3
epoch: 0
release: 1
url: https://github.com/robertlugg/easygui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9adf5df6-f34a-48b6-a32c-3c68ec3251bd
location_href: 00003554-python-easygui/python-easygui-0.98.3-1.src.rpm
checksum_type: sha256
summary:
  EasyGUI is a module for very simple, very easy GUI programming in Python.  EasyGUI is different from other GUI generators in that EasyGUI is NOT event-driven.  Instead, all GUI interactions are invoked by simple function calls.

description:
  Hi everyone.  There hasn't been much activity but thankfully we have a new revision.  Thank you contributors and thank you Stephen Ferg for creating EasyGui.
  You might also consider the following alternatives:
   - https://github.com/aroberge/easygui_qt
   - https://github.com/ponty/psidialogs
  For those who wish to contribute you are welcome to fork this respository.  Or, take a look at the alternatives and contribute there.
  Kind Regards, Robert


pkgId: d203422f296c698317a3b495abff87c9c278bacf70d4bb28f5d5a2056e447615
name: python-easypost
arch: src
version: 7.11.0
epoch: 0
release: 1
summary: EasyPost Shipping API Client Library for Python
url: https://easypost.com/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5c5cd49-f2ac-4d2f-85d2-bff5b3e62af1
location_href: 00013297-python-easypost/python-easypost-7.11.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/EasyPost/easypost-python/workflows/CI/badge.svg)](https://github.com/EasyPost/easypost-python/actions?query=workflow%3ACI)
  [![Coverage Status](https://coveralls.io/repos/github/EasyPost/easypost-python/badge.svg)](https://coveralls.io/github/EasyPost/easypost-python)
  [![PyPI version](https://badge.fury.io/py/easypost.svg)](https://badge.fury.io/py/easypost)

  EasyPost, the simple shipping solution. You can sign up for an account at <https://easypost.com>.



  The library is tested against Python3 and should be compatible with PyPy3.

  ```bash
  pip install easypost
  ```

  ```python

  import easypost
  ```



  A simple create & buy shipment example:

  ```python
  import os
  import easypost

  easypost.api_key = os.getenv('EASYPOST_API_KEY')

  shipment = easypost.Shipment.create(
      from_address = {
          "name": "EasyPost",
          "street1": "118 2nd Street",
          "street2": "4th Floor",
          "city": "San Francisco",
          "state": "CA",
          "zip": "94105",
          "country": "US",
          "phone": "415-456-7890",
      },
      to_address = {
          "name": "Dr. Steve Brule",
          "street1": "179 N Harbor Dr",
          "city": "Redondo Beach",
          "state": "CA",
          "zip": "90277",
          "country": "US",
          "phone": "310-808-5243",
      },
      parcel = {
          "length": 10.2,
          "width": 7.8,
          "height": 4.3,
          "weight": 21.2,
      },
  )

  shipment.buy(rate=shipment.lowest_rate())

  print(shipment)
  ```



  API documentation can be found at: <https://easypost.com/docs/api>.

  Library documentation can be found on the web at: <https://easypost.github.io/easypost-python/> or locally in the `docs` directory.

  Upgrading major versions of this project? Refer to the [Upgrade Guide](UPGRADE_GUIDE.md).



  New features and bug fixes are released on the latest major release of this library. If you are on an older major release of this library, we recommend upgrading to the most recent release to take advantage of new features, bug fixes, and security patches. Older versions of this library will continue to work and be available as long as the API version they are tied to remains active; however, they will not receive updates and are considered EOL.

  For additional support, see our [org-wide support policy](https://github.com/EasyPost/.github/blob/main/SUPPORT.md).



  ```bash

  make install


  make lint


  make format


  EASYPOST_TEST_API_KEY=123... EASYPOST_PROD_API_KEY=123... make test


  EASYPOST_TEST_API_KEY=123... EASYPOST_PROD_API_KEY=123... make coverage


  make scan


  make docs


  git submodule init
  git submodule update --remote
  ```



  The test suite in this project was specifically built to produce consistent results on every run, regardless of when they run or who is running them. This project uses [VCR](https://github.com/kevin1024/vcrpy) to record and replay HTTP requests and responses via "cassettes". When the suite is run, the HTTP requests and responses for each test function will be saved to a cassette if they do not exist already and replayed from this saved file if they do, which saves the need to make live API calls on every test run. If you receive errors about a cassette expiring, delete and re-record the cassette to ensure the data is up-to-date.

  **Sensitive Data:** We've made every attempt to include scrubbers for sensitive data when recording cassettes so that PII or sensitive info does not persist in version control; however, please ensure when recording or re-recording cassettes that prior to committing your changes, no PII or sensitive information gets persisted by inspecting the cassette.

  **Making Changes:** If you make an addition to this project, the request/response will get recorded automatically for you if the `@pytest.mark.vcr()` decorator is included on the test function. When making changes to this project, you'll need to re-record the associated cassette to force a new live API call for that test which will then record the request/response used on the next run.

  **Test Data:** The test suite has been populated with various helpful fixtures that are available for use, each completely independent from a particular user **with the exception of the USPS carrier account ID** (see [Unit Test API Keys](#unit-test-api-keys) for more information) which has a fallback value of our internal testing user's ID. Some fixtures use hard-coded dates that may need to be incremented if cassettes get re-recorded (such as reports or pickups).



  The following are required on every test run:

  - `EASYPOST_TEST_API_KEY`
  - `EASYPOST_PROD_API_KEY`

  Some tests may require an EasyPost user with a particular set of enabled features such as a `Partner` user when creating referrals. We have attempted to call out these functions in their respective docstrings. The following are required when you need to re-record cassettes for applicable tests:

  - `USPS_CARRIER_ACCOUNT_ID` (eg: one-call buying a shipment for non-EasyPost employees)
  - `PARTNER_USER_PROD_API_KEY` (eg: creating a referral user)
  - `REFERRAL_CUSTOMER_PROD_API_KEY` (eg: adding a credit card to a referral user)


pkgId: a97056b73f0ca4db71db761d00ba69e143c4fe223c86a3ec2d1536f2fae67efa
name: python-ebaysdk
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: eBay SDK for Python
url: https://github.com/timotheus/ebaysdk-python
rpm_license: COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e8455ae-bb3e-46e7-a436-751a60d31fce
location_href: 00012073-python-ebaysdk/python-ebaysdk-2.2.0-1.src.rpm
checksum_type: sha256
description:
  This SDK is a programatic inteface into the eBay
  APIs. It simplifies development and cuts development time by standerizing
  calls, response processing, error handling, debugging across the Finding,
  Shopping, Merchandising, & Trading APIs.


pkgId: b2e52bbed2dff6d30cf3f7d5d4766dd092de7bbaa8606808db99a2d86ab30eab
name: python-ecdsa
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: ECDSA cryptographic signature library (pure python)
url: http://github.com/tlsfuzzer/python-ecdsa
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-665b69b2-c2d1-4cb9-8139-64baf03eed21
location_href: 00009176-python-ecdsa/python-ecdsa-0.18.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/tlsfuzzer/python-ecdsa/workflows/GitHub%20CI/badge.svg?branch=master)](https://github.com/tlsfuzzer/python-ecdsa/actions?query=workflow%3A%22GitHub+CI%22+branch%3Amaster)
  [![Documentation Status](https://readthedocs.org/projects/ecdsa/badge/?version=latest)](https://ecdsa.readthedocs.io/en/latest/?badge=latest)
  [![Coverage Status](https://coveralls.io/repos/github/tlsfuzzer/python-ecdsa/badge.svg?branch=master)](https://coveralls.io/github/tlsfuzzer/python-ecdsa?branch=master)
  ![condition coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/tomato42/9b6ca1f3410207fbeca785a178781651/raw/python-ecdsa-condition-coverage.json)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/tlsfuzzer/python-ecdsa.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/tlsfuzzer/python-ecdsa/context:python)
  [![Total alerts](https://img.shields.io/lgtm/alerts/g/tlsfuzzer/python-ecdsa.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/tlsfuzzer/python-ecdsa/alerts/)
  [![Latest Version](https://img.shields.io/pypi/v/ecdsa.svg?style=flat)](https://pypi.python.org/pypi/ecdsa/)
  ![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat)


  This is an easy-to-use implementation of ECC (Elliptic Curve Cryptography)
  with support for ECDSA (Elliptic Curve Digital Signature Algorithm),
  EdDSA (Edwards-curve Digital Signature Algorithm) and ECDH
  (Elliptic Curve Diffie-Hellman), implemented purely in Python, released under
  the MIT license. With this library, you can quickly create key pairs (signing
  key and verifying key), sign messages, and verify the signatures. You can
  also agree on a shared secret key based on exchanged public keys.
  The keys and signatures are very short, making them easy to handle and
  incorporate into other protocols.

  **NOTE: This library should not be used in production settings, see [Security](#Security) for more details.**



  This library provides key generation, signing, verifying, and shared secret
  derivation for five
  popular NIST "Suite B" GF(p) (_prime field_) curves, with key lengths of 192,
  224, 256, 384, and 521 bits. The "short names" for these curves, as known by
  the OpenSSL tool (`openssl ecparam -list_curves`), are: `prime192v1`,
  `secp224r1`, `prime256v1`, `secp384r1`, and `secp521r1`. It includes the
  256-bit curve `secp256k1` used by Bitcoin. There is also support for the
  regular (non-twisted) variants of Brainpool curves from 160 to 512 bits. The
  "short names" of those curves are: `brainpoolP160r1`, `brainpoolP192r1`,
  `brainpoolP224r1`, `brainpoolP256r1`, `brainpoolP320r1`, `brainpoolP384r1`,
  `brainpoolP512r1`. Few of the small curves from SEC standard are also
  included (mainly to speed-up testing of the library), those are:
  `secp112r1`, `secp112r2`, `secp128r1`, and `secp160r1`.
  Key generation, siging and verifying is also supported for Ed25519 and
  Ed448 curves.
  No other curves are included, but it is not too hard to add support for more
  curves over prime fields.



  This library uses only Python and the 'six' package. It is compatible with
  Python 2.6, 2.7, and 3.3+. It also supports execution on alternative
  implementations like pypy and pypy3.

  If `gmpy2` or `gmpy` is installed, they will be used for faster arithmetic.
  Either of them can be installed after this library is installed,
  `python-ecdsa` will detect their presence on start-up and use them
  automatically.
  You should prefer `gmpy2` on Python3 for optimal performance.

  To run the OpenSSL compatibility tests, the 'openssl' tool must be in your
  `PATH`. This release has been tested successfully against OpenSSL 0.9.8o,
  1.0.0a, 1.0.2f, 1.1.1d and 3.0.1 (among others).




  This library is available on PyPI, it's recommended to install it using `pip`:

  ```
  pip install ecdsa
  ```

  In case higher performance is wanted and using native code is not a problem,
  it's possible to specify installation together with `gmpy2`:

  ```
  pip install ecdsa[gmpy2]
  ```

  or (slower, legacy option):
  ```
  pip install ecdsa[gmpy]
  ```



  The following table shows how long this library takes to generate key pairs
  (`keygen`), to sign data (`sign`), to verify those signatures (`verify`),
  to derive a shared secret (`ecdh`), and
  to verify the signatures with no key-specific precomputation (`no PC verify`).
  All those values are in seconds.
  For convenience, the inverses of those values are also provided:
  how many keys per second can be generated (`keygen/s`), how many signatures
  can be made per second (`sign/s`), how many signatures can be verified
  per second (`verify/s`), how many shared secrets can be derived per second
  (`ecdh/s`), and how many signatures with no key specific
  precomputation can be verified per second (`no PC verify/s`). The size of raw
  signature (generally the smallest
  the way a signature can be encoded) is also provided in the `siglen` column.
  Use `tox -e speed` to generate this table on your own computer.
  On an Intel Core i7 4790K @ 4.0GHz I'm getting the following performance:

  ```
                    siglen    keygen   keygen/s      sign     sign/s    verify   verify/s  no PC verify  no PC verify/s
          NIST192p:     48   0.00032s   3134.06   0.00033s   2985.53   0.00063s   1598.36       0.00129s         774.43
          NIST224p:     56   0.00040s   2469.24   0.00042s   2367.88   0.00081s   1233.41       0.00170s         586.66
          NIST256p:     64   0.00051s   1952.73   0.00054s   1867.80   0.00098s   1021.86       0.00212s         471.27
          NIST384p:     96   0.00107s    935.92   0.00111s    904.23   0.00203s    491.77       0.00446s         224.00
          NIST521p:    132   0.00210s    475.52   0.00215s    464.16   0.00398s    251.28       0.00874s         114.39
         SECP256k1:     64   0.00052s   1921.54   0.00054s   1847.49   0.00105s    948.68       0.00210s         477.01
   BRAINPOOLP160r1:     40   0.00025s   4003.88   0.00026s   3845.12   0.00053s   1893.93       0.00105s         949.92
   BRAINPOOLP192r1:     48   0.00033s   3043.97   0.00034s   2975.98   0.00063s   1581.50       0.00135s         742.29
   BRAINPOOLP224r1:     56   0.00041s   2436.44   0.00043s   2315.51   0.00078s   1278.49       0.00180s         556.16
   BRAINPOOLP256r1:     64   0.00053s   1892.49   0.00054s   1846.24   0.00114s    875.64       0.00229s         437.25
   BRAINPOOLP320r1:     80   0.00073s   1361.26   0.00076s   1309.25   0.00143s    699.29       0.00322s         310.49
   BRAINPOOLP384r1:     96   0.00107s    931.29   0.00111s    901.80   0.00230s    434.19       0.00476s         210.20
   BRAINPOOLP512r1:    128   0.00207s    483.41   0.00212s    471.42   0.00425s    235.43       0.00912s         109.61
         SECP112r1:     28   0.00015s   6672.53   0.00016s   6440.34   0.00031s   3265.41       0.00056s        1774.20
         SECP112r2:     28   0.00015s   6697.11   0.00015s   6479.98   0.00028s   3524.72       0.00058s        1716.16
         SECP128r1:     32   0.00018s   5497.65   0.00019s   5272.89   0.00036s   2747.39       0.00072s        1396.16
         SECP160r1:     42   0.00025s   3949.32   0.00026s   3894.45   0.00046s   2153.85       0.00102s         985.07
           Ed25519:     64   0.00076s   1324.48   0.00042s   2405.01   0.00109s    918.05       0.00344s         290.50
             Ed448:    114   0.00176s    569.53   0.00115s    870.94   0.00282s    355.04       0.01024s          97.69

                         ecdh     ecdh/s
          NIST192p:   0.00104s    964.89
          NIST224p:   0.00134s    748.63
          NIST256p:   0.00170s    587.08
          NIST384p:   0.00352s    283.90
          NIST521p:   0.00717s    139.51
         SECP256k1:   0.00154s    648.40
   BRAINPOOLP160r1:   0.00082s   1220.70
   BRAINPOOLP192r1:   0.00105s    956.75
   BRAINPOOLP224r1:   0.00136s    734.52
   BRAINPOOLP256r1:   0.00178s    563.32
   BRAINPOOLP320r1:   0.00252s    397.23
   BRAINPOOLP384r1:   0.00376s    266.27
   BRAINPOOLP512r1:   0.00733s    136.35
         SECP112r1:   0.00046s   2180.40
         SECP112r2:   0.00045s   2229.14
         SECP128r1:   0.00054s   1868.15
         SECP160r1:   0.00080s   1243.98
  ```

  To test performance with `gmpy2` loaded, use `tox -e speedgmpy2`.
  On the same machine I'm getting the following performance with `gmpy2`:
  ```
                    siglen    keygen   keygen/s      sign     sign/s    verify   verify/s  no PC verify  no PC verify/s
          NIST192p:     48   0.00017s   5933.40   0.00017s   5751.70   0.00032s   3125.28       0.00067s        1502.41
          NIST224p:     56   0.00021s   4782.87   0.00022s   4610.05   0.00040s   2487.04       0.00089s        1126.90
          NIST256p:     64   0.00023s   4263.98   0.00024s   4125.16   0.00045s   2200.88       0.00098s        1016.82
          NIST384p:     96   0.00041s   2449.54   0.00042s   2399.96   0.00083s   1210.57       0.00172s         581.43
          NIST521p:    132   0.00071s   1416.07   0.00072s   1389.81   0.00144s    692.93       0.00312s         320.40
         SECP256k1:     64   0.00024s   4245.05   0.00024s   4122.09   0.00045s   2206.40       0.00094s        1068.32
   BRAINPOOLP160r1:     40   0.00014s   6939.17   0.00015s   6681.55   0.00029s   3452.43       0.00057s        1769.81
   BRAINPOOLP192r1:     48   0.00017s   5920.05   0.00017s   5774.36   0.00034s   2979.00       0.00069s        1453.19
   BRAINPOOLP224r1:     56   0.00021s   4732.12   0.00022s   4622.65   0.00041s   2422.47       0.00087s        1149.87
   BRAINPOOLP256r1:     64   0.00024s   4233.02   0.00024s   4115.20   0.00047s   2143.27       0.00098s        1015.60
   BRAINPOOLP320r1:     80   0.00032s   3162.38   0.00032s   3077.62   0.00063s   1598.83       0.00136s         737.34
   BRAINPOOLP384r1:     96   0.00041s   2436.88   0.00042s   2395.62   0.00083s   1202.68       0.00178s         562.85
   BRAINPOOLP512r1:    128   0.00063s   1587.60   0.00064s   1558.83   0.00125s    799.96       0.00281s         355.83
         SECP112r1:     28   0.00009s  11118.66   0.00009s  10775.48   0.00018s   5456.00       0.00033s        3020.83
         SECP112r2:     28   0.00009s  11322.97   0.00009s  10857.71   0.00017s   5748.77       0.00032s        3094.28
         SECP128r1:     32   0.00010s  10078.39   0.00010s   9665.27   0.00019s   5200.58       0.00036s        2760.88
         SECP160r1:     42   0.00015s   6875.51   0.00015s   6647.35   0.00029s   3422.41       0.00057s        1768.35
           Ed25519:     64   0.00030s   3322.56   0.00018s   5568.63   0.00046s   2165.35       0.00153s         654.02
             Ed448:    114   0.00060s   1680.53   0.00039s   2567.40   0.00096s   1036.67       0.00350s         285.62

                         ecdh     ecdh/s
          NIST192p:   0.00050s   1985.70
          NIST224p:   0.00066s   1524.16
          NIST256p:   0.00071s   1413.07
          NIST384p:   0.00127s    788.89
          NIST521p:   0.00230s    434.85
         SECP256k1:   0.00071s   1409.95
   BRAINPOOLP160r1:   0.00042s   2374.65
   BRAINPOOLP192r1:   0.00051s   1960.01
   BRAINPOOLP224r1:   0.00066s   1518.37
   BRAINPOOLP256r1:   0.00071s   1399.90
   BRAINPOOLP320r1:   0.00100s    997.21
   BRAINPOOLP384r1:   0.00129s    777.51
   BRAINPOOLP512r1:   0.00210s    475.99
         SECP112r1:   0.00022s   4457.70
         SECP112r2:   0.00024s   4252.33
         SECP128r1:   0.00028s   3589.31
         SECP160r1:   0.00043s   2305.02
  ```

  (there's also `gmpy` version, execute it using `tox -e speedgmpy`)

  For comparison, a highly optimised implementation (including curve-specific
  assembly for some curves), like the one in OpenSSL 1.1.1d, provides the
  following performance numbers on the same machine.
  Run `openssl speed ecdsa` and `openssl speed ecdh` to reproduce it:
  ```
                                sign    verify    sign/s verify/s
   192 bits ecdsa (nistp192)   0.0002s   0.0002s   4785.6   5380.7
   224 bits ecdsa (nistp224)   0.0000s   0.0001s  22475.6   9822.0
   256 bits ecdsa (nistp256)   0.0000s   0.0001s  45069.6  14166.6
   384 bits ecdsa (nistp384)   0.0008s   0.0006s   1265.6   1648.1
   521 bits ecdsa (nistp521)   0.0003s   0.0005s   3753.1   1819.5
   256 bits ecdsa (brainpoolP256r1)   0.0003s   0.0003s   2983.5   3333.2
   384 bits ecdsa (brainpoolP384r1)   0.0008s   0.0007s   1258.8   1528.1
   512 bits ecdsa (brainpoolP512r1)   0.0015s   0.0012s    675.1    860.1

                                sign    verify    sign/s verify/s
   253 bits EdDSA (Ed25519)   0.0000s   0.0001s  28217.9  10897.7
   456 bits EdDSA (Ed448)     0.0003s   0.0005s   3926.5   2147.7

                                 op      op/s
   192 bits ecdh (nistp192)   0.0002s   4853.4
   224 bits ecdh (nistp224)   0.0001s  15252.1
   256 bits ecdh (nistp256)   0.0001s  18436.3
   384 bits ecdh (nistp384)   0.0008s   1292.7
   521 bits ecdh (nistp521)   0.0003s   2884.7
   256 bits ecdh (brainpoolP256r1)   0.0003s   3066.5
   384 bits ecdh (brainpoolP384r1)   0.0008s   1298.0
   512 bits ecdh (brainpoolP512r1)   0.0014s    694.8
  ```

  Keys and signature can be serialized in different ways (see Usage, below).
  For a NIST192p key, the three basic representations require strings of the
  following lengths (in bytes):

      to_string:  signkey= 24, verifykey= 48, signature=48
      compressed: signkey=n/a, verifykey= 25, signature=n/a
      DER:        signkey=106, verifykey= 80, signature=55
      PEM:        signkey=278, verifykey=162, (no support for PEM signatures)



  In 2006, Peter Pearson announced his pure-python implementation of ECDSA in a
  [message to sci.crypt][1], available from his [download site][2]. In 2010,
  Brian Warner wrote a wrapper around this code, to make it a bit easier and
  safer to use. In 2020, Hubert Kario included an implementation of elliptic
  curve cryptography that uses Jacobian coordinates internally, improving
  performance about 20-fold. You are looking at the README for this wrapper.

  [1]: http://www.derkeiler.com/Newsgroups/sci.crypt/2006-01/msg00651.html
  [2]: http://webpages.charter.net/curryfans/peter/downloads.html



  To run the full test suite, do this:

      tox -e coverage

  On an Intel Core i7 4790K @ 4.0GHz, the tests take about 18 seconds to execute.
  The test suite uses
  [`hypothesis`](https://github.com/HypothesisWorks/hypothesis) so there is some
  inherent variability in the test suite execution time.

  One part of `test_pyecdsa.py` and `test_ecdh.py` checks compatibility with
  OpenSSL, by running the "openssl" CLI tool, make sure it's in your `PATH` if
  you want to test compatibility with it (if OpenSSL is missing, too old, or
  doesn't support all the curves supported in upstream releases you will see
  skipped tests in the above `coverage` run).



  This library was not designed with security in mind. If you are processing
  data that needs to be protected we suggest you use a quality wrapper around
  OpenSSL. [pyca/cryptography](https://cryptography.io) is one example of such
  a wrapper. The primary use-case of this library is as a portable library for
  interoperability testing and as a teaching tool.

  **This library does not protect against side-channel attacks.**

  Do not allow attackers to measure how long it takes you to generate a key pair
  or sign a message. Do not allow attackers to run code on the same physical
  machine when key pair generation or signing is taking place (this includes
  virtual machines). Do not allow attackers to measure how much power your
  computer uses while generating the key pair or signing a message. Do not allow
  attackers to measure RF interference coming from your computer while generating
  a key pair or signing a message. Note: just loading the private key will cause
  key pair generation. Other operations or attack vectors may also be
  vulnerable to attacks. **For a sophisticated attacker observing just one
  operation with a private key will be sufficient to completely
  reconstruct the private key**.

  Please also note that any Pure-python cryptographic library will be vulnerable
  to the same side-channel attacks. This is because Python does not provide
  side-channel secure primitives (with the exception of
  [`hmac.compare_digest()`][3]), making side-channel secure programming
  impossible.

  This library depends upon a strong source of random numbers. Do not use it on
  a system where `os.urandom()` does not provide cryptographically secure
  random numbers.

  [3]: https://docs.python.org/3/library/hmac.html#hmac.compare_digest



  You start by creating a `SigningKey`. You can use this to sign data, by passing
  in data as a byte string and getting back the signature (also a byte string).
  You can also ask a `SigningKey` to give you the corresponding `VerifyingKey`.
  The `VerifyingKey` can be used to verify a signature, by passing it both the
  data string and the signature byte string: it either returns True or raises
  `BadSignatureError`.

  ```python
  from ecdsa import SigningKey
  sk = SigningKey.generate() # uses NIST192p
  vk = sk.verifying_key
  signature = sk.sign(b"message")
  assert vk.verify(signature, b"message")
  ```

  Each `SigningKey`/`VerifyingKey` is associated with a specific curve, like
  NIST192p (the default one). Longer curves are more secure, but take longer to
  use, and result in longer keys and signatures.

  ```python
  from ecdsa import SigningKey, NIST384p
  sk = SigningKey.generate(curve=NIST384p)
  vk = sk.verifying_key
  signature = sk.sign(b"message")
  assert vk.verify(signature, b"message")
  ```

  The `SigningKey` can be serialized into several different formats: the shortest
  is to call `s=sk.to_string()`, and then re-create it with
  `SigningKey.from_string(s, curve)` . This short form does not record the
  curve, so you must be sure to pass to `from_string()` the same curve you used
  for the original key. The short form of a NIST192p-based signing key is just 24
  bytes long. If a point encoding is invalid or it does not lie on the specified
  curve, `from_string()` will raise `MalformedPointError`.

  ```python
  from ecdsa import SigningKey, NIST384p
  sk = SigningKey.generate(curve=NIST384p)
  sk_string = sk.to_string()
  sk2 = SigningKey.from_string(sk_string, curve=NIST384p)
  print(sk_string.hex())
  print(sk2.to_string().hex())
  ```

  Note: while the methods are called `to_string()` the type they return is
  actually `bytes`, the "string" part is leftover from Python 2.

  `sk.to_pem()` and `sk.to_der()` will serialize the signing key into the same
  formats that OpenSSL uses. The PEM file looks like the familiar ASCII-armored
  `"-----BEGIN EC PRIVATE KEY-----"` base64-encoded format, and the DER format
  is a shorter binary form of the same data.
  `SigningKey.from_pem()/.from_der()` will undo this serialization. These
  formats include the curve name, so you do not need to pass in a curve
  identifier to the deserializer. In case the file is malformed `from_der()`
  and `from_pem()` will raise `UnexpectedDER` or` MalformedPointError`.

  ```python
  from ecdsa import SigningKey, NIST384p
  sk = SigningKey.generate(curve=NIST384p)
  sk_pem = sk.to_pem()
  sk2 = SigningKey.from_pem(sk_pem)

  ```

  Likewise, the `VerifyingKey` can be serialized in the same way:
  `vk.to_string()/VerifyingKey.from_string()`, `to_pem()/from_pem()`, and
  `to_der()/from_der()`. The same `curve=` argument is needed for
  `VerifyingKey.from_string()`.

  ```python
  from ecdsa import SigningKey, VerifyingKey, NIST384p
  sk = SigningKey.generate(curve=NIST384p)
  vk = sk.verifying_key
  vk_string = vk.to_string()
  vk2 = VerifyingKey.from_string(vk_string, curve=NIST384p)


  from ecdsa import SigningKey, VerifyingKey, NIST384p
  sk = SigningKey.generate(curve=NIST384p)
  vk = sk.verifying_key
  vk_pem = vk.to_pem()
  vk2 = VerifyingKey.from_pem(vk_pem)

  ```

  There are a couple of different ways to compute a signature. Fundamentally,
  ECDSA takes a number that represents the data being signed, and returns a
  pair of numbers that represent the signature. The `hashfunc=` argument to
  `sk.sign()` and `vk.verify()` is used to turn an arbitrary string into a
  fixed-length digest, which is then turned into a number that ECDSA can sign,
  and both sign and verify must use the same approach. The default value is
  `hashlib.sha1`, but if you use NIST256p or a longer curve, you can use
  `hashlib.sha256` instead.

  There are also multiple ways to represent a signature. The default
  `sk.sign()` and `vk.verify()` methods present it as a short string, for
  simplicity and minimal overhead. To use a different scheme, use the
  `sk.sign(sigencode=)` and `vk.verify(sigdecode=)` arguments. There are helper
  functions in the `ecdsa.util` module that can be useful here.

  It is also possible to create a `SigningKey` from a "seed", which is
  deterministic. This can be used in protocols where you want to derive
  consistent signing keys from some other secret, for example when you want
  three separate keys and only want to store a single master secret. You should
  start with a uniformly-distributed unguessable seed with about `curve.baselen`
  bytes of entropy, and then use one of the helper functions in `ecdsa.util` to
  convert it into an integer in the correct range, and then finally pass it
  into `SigningKey.from_secret_exponent()`, like this:

  ```python
  import os
  from ecdsa import NIST384p, SigningKey
  from ecdsa.util import randrange_from_seed__trytryagain

  def make_key(seed):
    secexp = randrange_from_seed__trytryagain(seed, NIST384p.order)
    return SigningKey.from_secret_exponent(secexp, curve=NIST384p)

  seed = os.urandom(NIST384p.baselen) # or other starting point
  sk1a = make_key(seed)
  sk1b = make_key(seed)

  assert sk1a.to_string() == sk1b.to_string()
  sk2 = make_key(b"2-"+seed)  # different key
  assert sk1a.to_string() != sk2.to_string()
  ```

  In case the application will verify a lot of signatures made with a single
  key, it's possible to precompute some of the internal values to make
  signature verification significantly faster. The break-even point occurs at
  about 100 signatures verified.

  To perform precomputation, you can call the `precompute()` method
  on `VerifyingKey` instance:
  ```python
  from ecdsa import SigningKey, NIST384p
  sk = SigningKey.generate(curve=NIST384p)
  vk = sk.verifying_key
  vk.precompute()
  signature = sk.sign(b"message")
  assert vk.verify(signature, b"message")
  ```

  Once `precompute()` was called, all signature verifications with this key will
  be faster to execute.



  To produce signatures that can be verified by OpenSSL tools, or to verify
  signatures that were produced by those tools, use:

  ```python







  import hashlib
  from ecdsa import SigningKey, VerifyingKey
  from ecdsa.util import sigencode_der, sigdecode_der

  with open("vk.pem") as f:
     vk = VerifyingKey.from_pem(f.read())

  with open("data", "rb") as f:
     data = f.read()

  with open("data.sig", "rb") as f:
     signature = f.read()

  assert vk.verify(signature, data, hashlib.sha256, sigdecode=sigdecode_der)

  with open("sk.pem") as f:
     sk = SigningKey.from_pem(f.read(), hashlib.sha256)

  new_signature = sk.sign_deterministic(data, sigencode=sigencode_der)

  with open("data.sig2", "wb") as f:
     f.write(new_signature)


  ```

  Note: if compatibility with OpenSSL 1.0.0 or earlier is necessary, the
  `sigencode_string` and `sigdecode_string` from `ecdsa.util` can be used for
  respectively writing and reading the signatures.

  The keys also can be written in format that openssl can handle:

  ```python
  from ecdsa import SigningKey, VerifyingKey

  with open("sk.pem") as f:
      sk = SigningKey.from_pem(f.read())
  with open("sk.pem", "wb") as f:
      f.write(sk.to_pem())

  with open("vk.pem") as f:
      vk = VerifyingKey.from_pem(f.read())
  with open("vk.pem", "wb") as f:
      f.write(vk.to_pem())
  ```



  Creating a signing key with `SigningKey.generate()` requires some form of
  entropy (as opposed to
  `from_secret_exponent`/`from_string`/`from_der`/`from_pem`,
  which are deterministic and do not require an entropy source). The default
  source is `os.urandom()`, but you can pass any other function that behaves
  like `os.urandom` as the `entropy=` argument to do something different. This
  may be useful in unit tests, where you want to achieve repeatable results. The
  `ecdsa.util.PRNG` utility is handy here: it takes a seed and produces a strong
  pseudo-random stream from it:

  ```python
  from ecdsa.util import PRNG
  from ecdsa import SigningKey
  rng1 = PRNG(b"seed")
  sk1 = SigningKey.generate(entropy=rng1)
  rng2 = PRNG(b"seed")
  sk2 = SigningKey.generate(entropy=rng2)

  ```

  Likewise, ECDSA signature generation requires a random number, and each
  signature must use a different one (using the same number twice will
  immediately reveal the private signing key). The `sk.sign()` method takes an
  `entropy=` argument which behaves the same as `SigningKey.generate(entropy=)`.



  If you call `SigningKey.sign_deterministic(data)` instead of `.sign(data)`,
  the code will generate a deterministic signature instead of a random one.
  This uses the algorithm from RFC6979 to safely generate a unique `k` value,
  derived from the private key and the message being signed. Each time you sign
  the same message with the same key, you will get the same signature (using
  the same `k`).

  This may become the default in a future version, as it is not vulnerable to
  failures of the entropy source.



  Create a NIST192p key pair and immediately save both to disk:

  ```python
  from ecdsa import SigningKey
  sk = SigningKey.generate()
  vk = sk.verifying_key
  with open("private.pem", "wb") as f:
      f.write(sk.to_pem())
  with open("public.pem", "wb") as f:
      f.write(vk.to_pem())
  ```

  Load a signing key from disk, use it to sign a message (using SHA-1), and write
  the signature to disk:

  ```python
  from ecdsa import SigningKey
  with open("private.pem") as f:
      sk = SigningKey.from_pem(f.read())
  with open("message", "rb") as f:
      message = f.read()
  sig = sk.sign(message)
  with open("signature", "wb") as f:
      f.write(sig)
  ```

  Load the verifying key, message, and signature from disk, and verify the
  signature (assume SHA-1 hash):

  ```python
  from ecdsa import VerifyingKey, BadSignatureError
  vk = VerifyingKey.from_pem(open("public.pem").read())
  with open("message", "rb") as f:
      message = f.read()
  with open("signature", "rb") as f:
      sig = f.read()
  try:
      vk.verify(sig, message)
      print "good signature"
  except BadSignatureError:
      print "BAD SIGNATURE"
  ```

  Create a NIST521p key pair:

  ```python
  from ecdsa import SigningKey, NIST521p
  sk = SigningKey.generate(curve=NIST521p)
  vk = sk.verifying_key
  ```

  Create three independent signing keys from a master seed:

  ```python
  from ecdsa import NIST192p, SigningKey
  from ecdsa.util import randrange_from_seed__trytryagain

  def make_key_from_seed(seed, curve=NIST192p):
      secexp = randrange_from_seed__trytryagain(seed, curve.order)
      return SigningKey.from_secret_exponent(secexp, curve)

  sk1 = make_key_from_seed("1:%s" % seed)
  sk2 = make_key_from_seed("2:%s" % seed)
  sk3 = make_key_from_seed("3:%s" % seed)
  ```

  Load a verifying key from disk and print it using hex encoding in
  uncompressed and compressed format (defined in X9.62 and SEC1 standards):

  ```python
  from ecdsa import VerifyingKey

  with open("public.pem") as f:
      vk = VerifyingKey.from_pem(f.read())

  print("uncompressed: {0}".format(vk.to_string("uncompressed").hex()))
  print("compressed: {0}".format(vk.to_string("compressed").hex()))
  ```

  Load a verifying key from a hex string from compressed format, output
  uncompressed:

  ```python
  from ecdsa import VerifyingKey, NIST256p

  comp_str = '022799c0d0ee09772fdd337d4f28dc155581951d07082fb19a38aa396b67e77759'
  vk = VerifyingKey.from_string(bytearray.fromhex(comp_str), curve=NIST256p)
  print(vk.to_string("uncompressed").hex())
  ```

  ECDH key exchange with remote party:

  ```python
  from ecdsa import ECDH, NIST256p

  ecdh = ECDH(curve=NIST256p)
  ecdh.generate_private_key()
  local_public_key = ecdh.get_public_key()

  with open("remote_public_key.pem") as e:
      remote_public_key = e.read()
  ecdh.load_received_public_key_pem(remote_public_key)
  secret = ecdh.generate_sharedsecret_bytes()
  ```


pkgId: 5f12ee7dae2c857b2ce6f4b9684e0ebe3803adc5eab010b9af217478f37c1296
name: python-editables
arch: src
version: 0.3
epoch: 0
release: 1
summary: Editable installations
url: https://github.com/pfmoore/editables
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3d4375aa-a93c-4bd7-a873-750d55b08210
location_href: 00013189-python-editables/python-editables-0.3-1.src.rpm
checksum_type: sha256
description:
  This library supports the building of wheels which, when installed, will
  expose packages in a local directory on `sys.path` in "editable mode". In
  other words, changes to the package source will be  reflected in the package
  visible to Python, without needing a reinstall.



  Suppose you want to build a wheel for your project `foo`. Your project is
  located in the directory `/path/to/foo`. Under that directory, you have a
  `src` directory containing your project, which is a package called `foo`
  and a Python module called `bar.py`. So your directory structure looks like
  this:

  ```
  /path/to/foo
  |
  +-- src
  |   +-- foo
  |   |   +-- __init__.py
  |   +-- bar.py
  |
  +-- setup.py
  +-- other files
  ```

  Build your wheel as follows:

  ```python
  from editables import EditableProject

  my_project = EditableProject("foo", "/path/to/foo")
  my_project.add_to_path("src")


  wheel = BuildAWheel()


  for name, content in my_project.files():
      wheel.add_file(name, content)


  for dep in my_project.dependencies():
      wheel.metadata.dependencies.add(dep)
  ```

  The resulting wheel will, when installed, put the project `src` directory on
  `sys.path` so that editing the original source will take effect without needing
  a reinstall (i.e., as "editable" packages). The project is exposed on `sys.path`
  by adding a single `.pth` file, named after the project, into the wheel.

  For more details, including how to control what gets exposed more precisely, see
  [the documentation](https://editables.readthedocs.io/en/latest/).

  Note that this project doesn't build wheels directly. That's the responsibility
  of the calling code.



  This project supports the same versions of Python as pip does. Currently
  that is Python 3.7 and later, and PyPy3 (although we don't test against
  PyPy).


pkgId: f5725e587d8dbb4e136cbda52cb758623c08fa11054a705d8c4bdf9d4f04a7a3
name: python-editor
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: 🖋 Open the default text editor 🖋
url: https://pypi.org/project/editor/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a992bf8-fea3-46dd-bc8c-cd6b44e6bcfd
location_href: 00009014-python-editor/python-editor-1.3.0-1.src.rpm
checksum_type: sha256
description:
  `editor` opens a text editor for an existing file, a new file, or a tempfile,
  blocks while the user edits text, then returns the results.

  You can specify a command line that runs the editor, but usually you leave it
  empty - in that case, `editor` uses the  the command line from the environment
  variable `VISUAL`, or if that's empty, the environment variable `EDITOR`, or if
  *that's* empty, either `Notepad` on Windows or `vi` elsewhere.



  If no filename is provided, a temporary file gets edited, and its contents
  returned.


      import editor

      MESSAGE = 'Insert comments below this line\n\n'
      comments = editor(text=MESSAGE)
      



  If a filename is provided, then it gets edited!

      import os

      FILE = 'file.txt'
      assert not os.path.exists(FILE)

      comments = editor(text=MESSAGE, filename=FILE)
      

      assert os.path.exists(FILE)

      
      comments2 = editor(filename=FILE, editor='emacs')


pkgId: c36a73391a21ef51c2ba35dee0d746f1604ca2f4942f0f69a88a0ca2946bc08f
name: python-edx-django-utils
arch: src
version: 5.3.0
epoch: 0
release: 1
summary: EdX utilities for Django Application development.
url: https://github.com/openedx/edx-django-utils
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c9079ef2-634a-4b0a-acaf-9cc4d7e4e279
location_href: 00012972-python-edx-django-utils/python-edx-django-utils-5.3.0-1.src.rpm
checksum_type: sha256
description:
  |pypi-badge| |ci-badge| |codecov-badge| |doc-badge| |pyversions-badge|
  |license-badge| |status-badge|
  EdX utilities for Django Application development.
  Note that some utilities may warrant their own repository. A judgement call
  needs to be made as to whether code properly belongs here or not. Please
  review with the Architecture Team if you have any questions.


pkgId: 3606e49559dcb208b4c1c4b411d590e59a866e4c3967304977983496d4690f39
name: python-edx-rest-api-client
arch: src
version: 5.5.0
epoch: 0
release: 1
summary: Slumber client used to access various edX Platform REST APIs.
url: https://github.com/edx/edx-rest-api-client
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6914e9c2-9463-47a0-82ae-8f0ec31daece
location_href: 00013167-python-edx-rest-api-client/python-edx-rest-api-client-5.5.0-1.src.rpm
checksum_type: sha256
description:
  The edX REST API Client (henceforth, client) allows users to communicate with various edX REST APIs, including the `E-Commerce Service`_ and the `Programs Service`_.


pkgId: 8520c3e5f081e33bb8bf90dd76c5eb14f2da12f85afc08a21e212d6edf0ee352
name: python-efel
arch: src
version: 4.1.63
epoch: 0
release: 1
summary: Electrophys Feature Extract Library (eFEL)
url: https://github.com/BlueBrain/eFEL
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eec8e559-5365-41f7-8d9e-e2f057e17582
location_href: 00003561-python-efel/python-efel-4.1.63-1.src.rpm
checksum_type: sha256
description:
  The Electrophys Feature Extract Library (eFEL) allows neuroscientists to automatically extract features from time series data recorded from neurons (both in vitro and in silico). Examples are the action potential width and amplitude in voltage traces recorded during whole-cell patch clamp experiments. The user of the library provides a set of traces and selects the features to be calculated. The library will then extract the requested features and return the values to the user.


pkgId: d821468c77521f0254c4f1b5e24f7d900e900ab1cea6360631ce18c013f0a2f9
name: python-efel-debuginfo
arch: aarch64
version: 4.1.63
epoch: 0
release: 1
summary: Debug information for package python-efel
url: https://github.com/BlueBrain/eFEL
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-eec8e559-5365-41f7-8d9e-e2f057e17582
rpm_sourcerpm: python-efel-4.1.63-1.src.rpm
location_href: 00003561-python-efel/python-efel-debuginfo-4.1.63-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-efel.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 39a72a5ba0f03f168c6f69d7562abdccb8f7c17ad47f76409f772b52ae67ccf3
name: python-efel-debugsource
arch: aarch64
version: 4.1.63
epoch: 0
release: 1
summary: Debug sources for package python-efel
url: https://github.com/BlueBrain/eFEL
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-eec8e559-5365-41f7-8d9e-e2f057e17582
rpm_sourcerpm: python-efel-4.1.63-1.src.rpm
location_href: 00003561-python-efel/python-efel-debugsource-4.1.63-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-efel.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 00cd9c6838ff8b683c369781fac9cdd0eb83295dce5ff2d426d41418ef470d47
name: python-efficientnet
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: EfficientNet model re-implementation. Keras and TensorFlow Keras.
url: https://github.com/qubvel/efficientnet
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1828e35b-1514-4d9a-aeea-684975829f32
location_href: 00011903-python-efficientnet/python-efficientnet-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/efficientnet.svg)](https://badge.fury.io/py/efficientnet) [![Downloads](https://pepy.tech/badge/efficientnet/month)](https://pepy.tech/project/efficientnet/month)

  This repository contains a Keras (and TensorFlow Keras) reimplementation of **EfficientNet**, a lightweight convolutional neural network architecture achieving the [state-of-the-art accuracy with an order of magnitude fewer parameters and FLOPS](https://arxiv.org/abs/1905.11946), on both ImageNet and
  five other commonly used transfer learning datasets.

  The codebase is heavily inspired by the [TensorFlow implementation](https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet).


  There was a huge library update **24 of July 2019**. Now efficintnet works with both frameworks: `keras` and `tensorflow.keras`.
  If you have models, trained before that date, to load them, please, use efficientnet of 0.0.4 version (PyPI). You can roll back using `pip install -U efficientnet==0.0.4`.



   1. [About EfficientNet Models](#about-efficientnet-models)
   2. [Examples](#examples)
   3. [Models](#models)
   4. [Installation](#installation)
   5. [Frequently Asked Questions](#frequently-asked-questions)
   6. [Acknowledgements](#acknowledgements)



  EfficientNets rely on AutoML and compound scaling to achieve superior performance without compromising resource efficiency. The [AutoML Mobile framework](https://ai.googleblog.com/2018/08/mnasnet-towards-automating-design-of.html) has helped develop a mobile-size baseline network, **EfficientNet-B0**, which is then improved by the compound scaling method  to obtain EfficientNet-B1 to B7.

  <table border="0">
  <tr>
      <td>
      <img src="https://raw.githubusercontent.com/tensorflow/tpu/master/models/official/efficientnet/g3doc/params.png" width="100%" />
      </td>
      <td>
      <img src="https://raw.githubusercontent.com/tensorflow/tpu/master/models/official/efficientnet/g3doc/flops.png", width="90%" />
      </td>
  </tr>
  </table>

  EfficientNets achieve state-of-the-art accuracy on ImageNet with an order of magnitude better efficiency:

  * In high-accuracy regime, EfficientNet-B7 achieves the state-of-the-art 84.4% top-1 / 97.1% top-5 accuracy on ImageNet with 66M parameters and 37B FLOPS. At the same time, the model is 8.4x smaller and 6.1x faster on CPU inference than the former leader, [Gpipe](https://arxiv.org/abs/1811.06965).

  * In middle-accuracy regime, EfficientNet-B1 is 7.6x smaller and 5.7x faster on CPU inference than [ResNet-152](https://arxiv.org/abs/1512.03385), with similar ImageNet accuracy.

  * Compared to the widely used [ResNet-50](https://arxiv.org/abs/1512.03385), EfficientNet-B4 improves the top-1 accuracy from 76.3% of ResNet-50 to 82.6% (+6.3%), under similar FLOPS constraints.



  * *Initializing the model*:

  ```python



  import efficientnet.keras as efn

  model = efn.EfficientNetB0(weights='imagenet')  # or weights='noisy-student'

  ```

  * *Loading the pre-trained weights*:

  ```python



  import efficientnet.tfkeras
  from tensorflow.keras.models import load_model

  model = load_model('path/to/model.h5')
  ```

  See the complete example of loading the model and making an inference in the Jupyter notebook [here](https://github.com/qubvel/efficientnet/blob/master/examples/inference_example.ipynb).



  The performance of each model variant using the pre-trained weights converted from checkpoints provided by the authors is as follows:

  | Architecture   | @top1* Imagenet| @top1* Noisy-Student|
  | -------------- | :----: |:---:|
  | EfficientNetB0 | 0.772  |0.788|
  | EfficientNetB1 | 0.791  |0.815|
  | EfficientNetB2 | 0.802  |0.824|
  | EfficientNetB3 | 0.816  |0.841|
  | EfficientNetB4 | 0.830  |0.853|
  | EfficientNetB5 | 0.837  |0.861|
  | EfficientNetB6 | 0.841  |0.864|
  | EfficientNetB7 | 0.844  |0.869|

  **\*** - topK accuracy score for converted models (imagenet `val` set)





  * `Keras >= 2.2.0` / `TensorFlow >= 1.12.0`
  * `keras_applications >= 1.0.7`
  * `scikit-image`



  ```bash
  $ pip install -U git+https://github.com/qubvel/efficientnet
  ```



  PyPI stable release

  ```bash
  $ pip install -U efficientnet
  ```

  PyPI latest release (with keras and tf.keras support)

  ```bash
  $ pip install -U --pre efficientnet
  ```



  * **How can I convert the original TensorFlow checkpoints to Keras HDF5?**

  Pick the target directory (like `dist`) and run the [converter script](./scripts) from the repo directory as follows:

  ```bash
  $ ./scripts/convert_efficientnet.sh --target_dir dist
  ```

  You can also optionally create the virtual environment with all the dependencies installed by adding `--make_venv=true` and operate in a self-destructing temporary location instead of the target directory by setting `--tmp_working_dir=true`.


  I would like to thanks community members who actively contribute to this repository:

  1) Sasha Illarionov ([@sdll](https://github.com/sdll)) for preparing automated script for weights conversion
  2) Björn Barz ([@Callidior](https://github.com/Callidior)) for model code adaptation for keras and tensorflow.keras frameworks


pkgId: e33b09e6c904bfdce5ec1ff541ef92aed72e1566aafd6891f7ed1169c5f6c3fa
name: python-eight
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Python 2 to the power of 3. A lightweight porting helper library.
url: https://github.com/kislyuk/eight
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5c994972-83a6-4439-a426-cb9531fb8ea9
location_href: 00012747-python-eight/python-eight-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Eight is a Python module that provides a minimalist compatibility layer between Python 3 and 2. Eight lets you write
  code for Python 3.3+ while providing limited compatibility with Python 2.7 with no code changes.  Eight is inspired by
  `six <https://pythonhosted.org/six/>`_, `nine <https://github.com/nandoflorestan/nine>`_, and `python-future
  <https://github.com/PythonCharmers/python-future>`_, but provides better internationalization (i18n) support, is more
  lightweight, easier to use, and unambiguously biased toward Python 3 code: if you remove eight from your code, it will
  continue to function exactly as it did with eight on Python 3.
  To write code for Python 3 that is portable to Python 2, you may also want to read Armin Ronacher's excellent `Python 3
  porting guide <http://lucumr.pocoo.org/2013/5/21/porting-to-python-3-redux/>`_, as well as the official
  `porting guide <http://docs.python.org/3/howto/pyporting.html>`_.
  Writing ``from eight import *`` in your code is a no-op in Python 3. In Python 2, it binds a bunch of Python 3 names to
  their Python 2 equivalents. Also, if you need to import a module or module member that was renamed in Python 3, writing
  ``from eight import <module>`` will do the right thing (equivalent to ``import <module>`` on Python 3 and ``import
  <old_name> as <module>`` on Python 2). Finally, eight can optionally wrap your standard streams and environment variable
  I/O to use text, not bytes (see below).


pkgId: e18b1f57b18ff07022c8cc198eb27ea24b3b5f06b7f83f7f9077a362f91ab23e
name: python-elasticsearch-dbapi
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: A DBAPI and SQLAlchemy dialect for Elasticsearch
url: http://preset.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-14231d6c-838b-41c8-9189-edc0e1ce524e
location_href: 00012589-python-elasticsearch-dbapi/python-elasticsearch-dbapi-0.2.10-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/preset-io/elasticsearch-dbapi/workflows/Python/badge.svg)](https://github.com/preset-io/elasticsearch-dbapi/actions)
  [![PyPI version](https://badge.fury.io/py/elasticsearch-dbapi.svg)](https://badge.fury.io/py/elasticsearch-dbapi)
  [![Coverage Status](https://codecov.io/github/preset-io/elasticsearch-dbapi/coverage.svg?branch=master)](https://codecov.io/github/preset-io/elasticsearch-dbapi)


  `elasticsearch-dbapi` Implements a DBAPI (PEP-249) and SQLAlchemy dialect,
  that enables SQL access on elasticsearch clusters for query only access.

  On Elastic Elasticsearch:
  Uses Elastic X-Pack [SQL API](https://www.elastic.co/guide/en/elasticsearch/reference/current/xpack-sql.html)

  On AWS ES, opendistro Elasticsearch:
  [Open Distro SQL](https://opendistro.github.io/for-elasticsearch-docs/docs/sql/)

  This library supports Elasticsearch 7.X versions.



  ```bash
  $ pip install elasticsearch-dbapi
  ```

  To install support for AWS Elasticsearch Service / [Open Distro](https://opendistro.github.io/for-elasticsearch/features/SQL%20Support.html):

  ```bash
  $ pip install elasticsearch-dbapi[opendistro]
  ```





  ```python
  from es.elastic.api import connect

  conn = connect(host='localhost')
  curs = conn.cursor()
  curs.execute(
      "select * from flights LIMIT 10"
  )
  print([row for row in curs])
  ```



  ```python
  from sqlalchemy.engine import create_engine

  engine = create_engine("elasticsearch+http://localhost:9200/")
  rows = engine.connect().execute(
      "select * from flights LIMIT 10"
  )
  print([row for row in rows])
  ```



  ```python
  from sqlalchemy import func, select
  from sqlalchemy.engine import create_engine
  from sqlalchemy.schema import MetaData, Table


  engine = create_engine("elasticsearch+http://localhost:9200/")
  logs = Table("flights", MetaData(bind=engine), autoload=True)
  count = select([func.count("*")], from_obj=logs).scalar()
  print(f"COUNT: {count}")
  ```



  ```python

  from sqlalchemy.engine import create_engine
  from sqlalchemy.schema import Table, MetaData

  engine = create_engine("elasticsearch+http://localhost:9200/")
  logs = Table("flights", MetaData(bind=engine), autoload=True)
  print(engine.table_names())

  metadata = MetaData()
  metadata.reflect(bind=engine)
  print([table for table in metadata.sorted_tables])
  print(logs.columns)
  ```



  [elasticsearch-py](https://elasticsearch-py.readthedocs.io/en/master/index.html)
  is used to establish connections and transport, this is the official
  elastic python library. `Elasticsearch` constructor accepts multiple optional parameters
  that can be used to properly configure your connection on aspects like security, performance
  and high availability. These optional parameters can be set at the connection string, for
  example:

   ```bash
      elasticsearch+http://localhost:9200/?http_compress=True&timeout=100
  ```
  will set transport to use gzip (http_compress) and timeout to 10 seconds.

  For more information on configuration options, look at `elasticsearch-py`’s documentation:
  - [Transport Options](https://elasticsearch-py.readthedocs.io/en/master/connection.html#transport)
  - [HTTP tranport](https://elasticsearch-py.readthedocs.io/en/master/transports.html#urllib3httpconnection)

  The connection string follows RFC-1738, to support multiple nodes you should use `sniff_*` parameters



  By default the maximum number of rows which get fetched by a single query
  is limited to 10000. This can be adapted through the `fetch_size`
  parameter:

  ```python
  from es.elastic.api import connect

  conn = connect(host="localhost", fetch_size=1000)
  curs = conn.cursor()
  ```

  If more than 10000 rows should get fetched then
  [max_result_window](https://www.elastic.co/guide/en/elasticsearch/reference/7.x/index-modules.html#dynamic-index-settings)
  has to be adapted as well.



  By default, elasticsearch query time zone defaults to `Z` (UTC). This can be adapted through the `time_zone`
  parameter:

  ```python
  from es.elastic.api import connect

  conn = connect(host="localhost", time_zone="Asia/Shanghai")
  curs = conn.cursor()
  ```



  To run unittest launch elasticsearch and kibana (kibana is really not required but is a nice to have)

  ```bash
  $ docker-compose up -d
  $ nosetests -v
  ```



  AWS ES exposes the opendistro SQL plugin, and it follows a different SQL dialect.
  Using the `odelasticsearch` driver:

  ```python
  from sqlalchemy.engine import create_engine

  engine = create_engine(
      "odelasticsearch+https://search-SOME-CLUSTER.us-west-2.es.amazonaws.com:443/"
  )
  rows = engine.connect().execute(
      "select count(*), Carrier from flights GROUP BY Carrier"
  )
  print([row for row in rows])
  ```

  Or using DBAPI:
  ```python
  from es.opendistro.api import connect

  conn = connect(host='localhost',port=9200,path="", scheme="http")

  curs = conn.cursor().execute(
      "select * from flights LIMIT 10"
  )

  print([row for row in curs])
  ```



  Basic authentication is configured as expected on the <username>,<password> fields of the URI

  ```python
  from sqlalchemy.engine import create_engine

  engine = create_engine(
      "odelasticsearch+https://my_user:my_password@search-SOME-CLUSTER.us-west-2.es.amazonaws.com:443/"
  )
  ```

  IAM AWS Authentication keys are passed on the URI basic auth location, and by setting `aws_keys`

  Query string keys are:

  - aws_keys
  - aws_region

  ```python
  from sqlalchemy.engine import create_engine

  engine = create_engine(
      "odelasticsearch+https://<AWS_ACCESS_KEY>:<AWS_SECRET_KEY>@search-SOME-CLUSTER.us-west-2.es.amazonaws.com:443/?aws_keys=1&&aws_region=<AWS_REGION>"
  )
  ```

  IAM AWS profile is configured has a query parameter name `aws_profile` on the URI. The value for the key provides the AWS region

  ```python
  from sqlalchemy.engine import create_engine

  engine = create_engine(
      "odelasticsearch+https://search-SOME-CLUSTER.us-west-2.es.amazonaws.com:443/?aws_profile=us-west-2"
  )
  ```

  Using the new SQL engine:

  Opendistro 1.13.0 brings (enabled by default) a new SQL engine, with lots of improvements and fixes.
  Take a look at the [release notes](https://github.com/opendistro-for-elasticsearch/sql/blob/develop/docs/dev/NewSQLEngine.md)

  This DBAPI has to behave slightly different for SQL v1 and SQL v2, by default we comply with v1,
  to enable v2 support, pass `v2=true` has a query parameter.

  ```
  odelasticsearch+https://search-SOME-CLUSTER.us-west-2.es.amazonaws.com:443/?aws_profile=us-west-2&v2=true
  ```

  To connect to the provided Opendistro ES on `docker-compose` use the following URI:
  `odelasticsearch+https://admin:admin@localhost:9400/?verify_certs=False`



  This library does not yet support the following features:

  - Array type columns are not supported. Elaticsearch SQL does not support them either.
  SQLAlchemy `get_columns` will exclude them.
  - `object` and `nested` column types are not well supported and are converted to strings
  - Indexes that whose name start with `.`
  - GEO points are not currently well-supported and are converted to strings

  - AWS ES (opendistro elascticsearch) is supported (still beta), known limitations are:
    * You are only able to `GROUP BY` keyword fields (new [experimental](https://github.com/opendistro-for-elasticsearch/sql#experimental)
   opendistro SQL already supports it)
    * Indices with dots are not supported (indices like 'audit_log.2021.01.20'),
    on these cases we recommend the use of aliases


pkgId: dd326ba3fd18f823727787a1a64b17b3650832f5ba5b0bbc2188ebf0ff7fd42d
name: python-elasticsearch-dsl
arch: src
version: 7.4.1
epoch: 0
release: 1
summary: Python client for Elasticsearch
url: https://github.com/elasticsearch/elasticsearch-dsl-py
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d2609d6d-2406-4305-87f7-566673a1e627
location_href: 00009454-python-elasticsearch-dsl/python-elasticsearch-dsl-7.4.1-1.src.rpm
checksum_type: sha256
description:
  Elasticsearch DSL is a high-level library whose aim is to help with writing and
  running queries against Elasticsearch. It is built on top of the official
  low-level client (`elasticsearch-py <https://github.com/elastic/elasticsearch-py>`_).
  It provides a more convenient and idiomatic way to write and manipulate
  queries. It stays close to the Elasticsearch JSON DSL, mirroring its
  terminology and structure. It exposes the whole range of the DSL from Python
  either directly using defined classes or a queryset-like expressions.
  It also provides an optional wrapper for working with documents as Python
  objects: defining mappings, retrieving and saving documents, wrapping the
  document data in user-defined classes.
  To use the other Elasticsearch APIs (eg. cluster health) just use the
  underlying client.


pkgId: 411d1faed4e4a2df1629cccc73ab46185ea90a1b4139af057e723699b86218df
name: python-elasticsearch2
arch: src
version: 2.5.1
epoch: 0
release: 1
summary: Python client for Elasticsearch
url: https://github.com/elastic/elasticsearch-py
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-20327f7d-6caf-4118-a5ec-749f55b9c69f
location_href: 00011724-python-elasticsearch2/python-elasticsearch2-2.5.1-1.src.rpm
checksum_type: sha256
description:
  Official low-level client for Elasticsearch. Its goal is to provide common
  ground for all Elasticsearch-related code in Python; because of this it tries
  to be opinion-free and very extendable.
  For a more high level client library with more limited scope, have a look at
  `elasticsearch-dsl`_ - a more pythonic library sitting on top of
  ``elasticsearch-py``.
  It provides a more convenient and idiomatic way to write and manipulate
  `queries`_. It stays close to the Elasticsearch JSON DSL, mirroring its
  terminology and structure while exposing the whole range of the DSL from Python
  either directly using defined classes or a queryset-like expressions.
  It also provides an optional `persistence layer`_ for working with documents as
  Python objects in an ORM-like fashion: defining mappings, retrieving and saving
  documents, wrapping the document data in user-defined classes.


pkgId: 948624d6739df3d09a99450a4935d4c9b01300a60036d9711d80bb290a4a4810
name: python-elementpath
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: XPath 1.0/2.0/3.0/3.1 parsers and selectors for ElementTree and lxml
url: https://github.com/sissaschool/elementpath
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-13473c68-e062-423a-a820-3692c92bdd33
location_href: 00009656-python-elementpath/python-elementpath-4.1.0-1.src.rpm
checksum_type: sha256
description:
  You can install the package with *pip* in a Python 3.7+ environment::
      pip install elementpath
  For using it import the package and apply the selectors on ElementTree nodes:
  >>> import elementpath
  >>> from xml.etree import ElementTree
  >>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
  >>> elementpath.select(root, '/A/B2/*')
  [<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
  The *select* API provides the standard XPath result format that is a list or an elementary
  datatype's value. If you want only to iterate over results you can use the generator function
  *iter_select* that accepts the same arguments of *select*.
  The selectors API works also using XML data trees based on the `lxml.etree <http://lxml.de>`_
  library:
  >>> import elementpath
  >>> import lxml.etree as etree
  >>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
  >>> elementpath.select(root, '/A/B2/*')
  [<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
  When you need to apply the same XPath expression to several XML data you can also use the
  *Selector* class, creating an instance and then using it to apply the path on distinct XML
  data:
  >>> import elementpath
  >>> import lxml.etree as etree
  >>> selector = elementpath.Selector('/A/*/*')
  >>> root = etree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
  >>> selector.select(root)
  [<Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
  >>> root = etree.XML('<A><B1><C0/></B1><B2><C1/><C2/><C3/></B2></A>')
  >>> selector.select(root)
  [<Element C0 at ...>, <Element C1 at ...>, <Element C2 at ...>, <Element C3 at ...>]
  Public API classes and functions are described into the
  `elementpath manual on the "Read the Docs" site <http://elementpath.readthedocs.io/en/latest/>`_.
  For default the XPath 2.0 is used. If you need XPath 1.0 parser provide the *parser* argument:
  >>> from elementpath import select, XPath1Parser
  >>> from xml.etree import ElementTree
  >>> root = ElementTree.XML('<A><B1/><B2><C1/><C2/><C3/></B2></A>')
  >>> select(root, '/A/B2/*', parser=XPath1Parser)
  [<Element 'C1' at ...>, <Element 'C2' at ...>, <Element 'C3' at ...>]
  For XPath 3.0/3.1 import the parser from *elementpath.xpath3* subpackage, that is not loaded
  for default:
  >>> from elementpath.xpath3 import XPath3Parser
  >>> select(root, 'math:atan(1.0e0)', parser=XPath3Parser)
  0.7853981633974483
  Note: *XPath3Parser* is an alias of *XPath31Parser*.
  If you need only XPath 3.0 you can also use a more specific subpackage,
  avoiding the loading of XPath 3.1 implementation:
  >>> from elementpath.xpath30 import XPath30Parser
  >>> select(root, 'math:atan(1.0e0)', parser=XPath30Parser)
  0.7853981633974483


pkgId: b8edf4bd1d4fdc1421265a8abcd708164a89fd52e30e14e151e21e8ad7b8e2e9
name: python-elephant
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: Elephant is a package for analysis of electrophysiology data in Python
url: http://python-elephant.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a6ae1bd-7931-46dd-85d4-5d1d993b80a9
location_href: 00003562-python-elephant/python-elephant-0.12.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/NeuralEnsemble/elephant.svg?branch=master)](https://travis-ci.org/NeuralEnsemble/elephant)
  [![Coverage Status](https://coveralls.io/repos/github/NeuralEnsemble/elephant/badge.svg?branch=master)](https://coveralls.io/github/NeuralEnsemble/elephant?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/elephant/badge/?version=latest)](https://elephant.readthedocs.io/en/latest/?badge=latest)
  [![![PyPi]](https://img.shields.io/pypi/v/elephant)](https://pypi.org/project/elephant/)
  [![Statistics](https://img.shields.io/pypi/dm/elephant)](https://seladb.github.io/StarTrack-js/#/preload?r=neuralensemble,elephant)
  [![Gitter](https://badges.gitter.im/python-elephant/community.svg)](https://gitter.im/python-elephant/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
  [![DOI Latest Release](https://zenodo.org/badge/10311278.svg)](https://zenodo.org/badge/latestdoi/10311278)
  [![tests](https://github.com/NeuralEnsemble/elephant/actions/workflows/CI.yml/badge.svg)](https://github.com/NeuralEnsemble/elephant/actions/workflows/CI.yml)
  [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/6191/badge)](https://bestpractices.coreinfrastructure.org/projects/6191)

  *Elephant* package analyses all sorts of neurophysiological data:
  spike trains, LFP, analog signals. The input-output data format is either
  [Neo](https://github.com/NeuralEnsemble/python-neo), Quantity or Numpy array.




  * Documentation: https://elephant.readthedocs.io/en/latest/
  * Mailing list: https://groups.google.com/group/neuralensemble




  Viziphant package (https://github.com/INM-6/viziphant) is developed by Elephant
  team for plotting and visualization of the output of Elephant functions in a
  few lines of code.




  Modified BSD License, see [LICENSE.txt](LICENSE.txt) for details.




  :copyright: 2014-2023 by the [Elephant team](doc/authors.rst).




  See [acknowledgments](doc/acknowledgments.rst).




  See [citations](doc/citation.rst).


pkgId: fcfb7851a6cede13c172f2e9888c180da551de1f39e8bfabffe573f9c0df6036
name: python-elephant-debuginfo
arch: aarch64
version: 0.12.0
epoch: 0
release: 1
summary: Debug information for package python-elephant
url: http://python-elephant.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5a6ae1bd-7931-46dd-85d4-5d1d993b80a9
rpm_sourcerpm: python-elephant-0.12.0-1.src.rpm
location_href: 00003562-python-elephant/python-elephant-debuginfo-0.12.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-elephant.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 224ee7abee7753136f620188f7e1303567f0e91ad4b03668189067a8bce72fec
name: python-elephant-debugsource
arch: aarch64
version: 0.12.0
epoch: 0
release: 1
summary: Debug sources for package python-elephant
url: http://python-elephant.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5a6ae1bd-7931-46dd-85d4-5d1d993b80a9
rpm_sourcerpm: python-elephant-0.12.0-1.src.rpm
location_href: 00003562-python-elephant/python-elephant-debugsource-0.12.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-elephant.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 2896521635e559a5b2c70a69ee28f644001a495af012c2529294930736c28e90
name: python-email-validator
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: A robust email address syntax and deliverability validation library.
url: https://github.com/JoshData/python-email-validator
rpm_license: CC0 (copyright waived)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-04032c50-d6d2-4948-a444-28a6dda468ab
location_href: 00003564-python-email-validator/python-email-validator-1.3.1-1.src.rpm
checksum_type: sha256
description:
  A robust email address syntax and deliverability validation library for
  Python by [Joshua Tauberer](https://joshdata.me).
  This library validates that a string is of the form `name@example.com`. This is
  the sort of validation you would want for an email-based login form on
  a website.
  Key features:
  * Checks that an email address has the correct syntax --- good for
    login forms or other uses related to identifying users.
  * Gives friendly error messages when validation fails (appropriate to show
    to end users).
  * (optionally) Checks deliverability: Does the domain name resolve? And you can override the default DNS resolver.
  * Supports internationalized domain names and (optionally)
    internationalized local parts, but blocks unsafe characters.
  * Normalizes email addresses (super important for internationalized
    addresses! see below).
  The library is NOT for validation of the To: line in an email message
  (e.g. `My Name <my@address.com>`), which
  [flanker](https://github.com/mailgun/flanker) is more appropriate for.
  And this library does NOT permit obsolete forms of email addresses, so
  if you need strict validation against the email specs exactly, use
  [pyIsEmail](https://github.com/michaelherold/pyIsEmail).
  This library is tested with Python 3.6+ but should work in earlier versions:
  [![Build Status](https://app.travis-ci.com/JoshData/python-email-validator.svg?branch=main)](https://app.travis-ci.com/JoshData/python-email-validator)


pkgId: 98fe6035b29d8795fe52464a523be34c8264f640ee1beb027738579222feccf3
name: python-emails
arch: src
version: 0.6
epoch: 0
release: 1
summary: Modern python library for emails.
url: https://github.com/lavr/python-emails
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-598c4f2f-6028-4b2b-89ed-ee79557332d3
location_href: 00011135-python-emails/python-emails-0.6-1.src.rpm
checksum_type: sha256
description:
  python-emails
  ~~~~~~~~~~~~~

  Modern python library for email.

  Build message:

     >>> import emails
     >>> message = emails.html(html="<p>Hi!<br>Here is your receipt...",
                            subject="Your receipt No. 567098123",
                            mail_from=('Some Store', 'store@somestore.com'))
     >>> message.attach(data=open('bill.pdf'), filename='bill.pdf')

  send message and get response from smtp server:

     >>> r = message.send(to='s@lavr.me', smtp={'host': 'aspmx.l.google.com', 'timeout': 5})
     >>> assert r.status_code == 250

  and more:

   * DKIM signature
   * Render body from template
   * Flask extension and Django integration
   * Message body transformation methods
   * Load message from url or from file


  Links
  `````

  * `documentation <http://python-emails.readthedocs.org/>`_
  * `source code <http://github.com/lavr/python-emails>`_


pkgId: 4b6232ed12b109047f6f6d11938de281314ce2e0e1046122c10ac5d264b208f8
name: python-embeddings
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Pretrained word embeddings in Python.
url: https://github.com/vzhong/embeddings
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d07bf27a-5889-49ed-85f1-c93315385ce2
location_href: 00009622-python-embeddings/python-embeddings-0.0.8-1.src.rpm
checksum_type: sha256
description:
  Embeddings is a python package that provides pretrained word embeddings for natural language processing and machine learning.
  Instead of loading a large file to query for embeddings, ``embeddings`` is backed by a database and fast to load and query:
      >>> %timeit GloveEmbedding('common_crawl_840', d_emb=300)
      100 loops, best of 3: 12.7 ms per loop
      >>> %timeit GloveEmbedding('common_crawl_840', d_emb=300).emb('canada')
      100 loops, best of 3: 12.9 ms per loop
      >>> g = GloveEmbedding('common_crawl_840', d_emb=300)
      >>> %timeit -n1 g.emb('canada')
      1 loop, best of 3: 38.2 µs per loop


pkgId: d9c81e1f911c2df8c497b91bbabd9741ad01b32e0bc7c3da0455d9dc8c52cfad
name: python-emcee
arch: src
version: 3.1.4
epoch: 0
release: 1
summary: The Python ensemble sampling toolkit for MCMC
url: https://emcee.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3e16819b-5949-484e-9b94-9773a9711614
location_href: 00003566-python-emcee/python-emcee-3.1.4-1.src.rpm
checksum_type: sha256
description:
  **The Python ensemble sampling toolkit for affine-invariant MCMC**
  emcee is a stable, well tested Python implementation of the affine-invariant
  ensemble sampler for Markov chain Monte Carlo (MCMC)
  proposed by
  `Goodman & Weare (2010) <http://cims.nyu.edu/~weare/papers/d13.pdf>`_.
  The code is open source and has
  already been used in several published projects in the Astrophysics
  literature.


pkgId: 9bb622c2791c7a37259b6118caf5f87e581e391d995292708477108779287306
name: python-emoji-country-flag
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: En/Decode unicode country flags emoji
url: https://pypi.org/project/emoji-country-flag/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-97bf77fd-4324-410e-8b0f-21893ac14aa5
location_href: 00012447-python-emoji-country-flag/python-emoji-country-flag-1.3.2-1.src.rpm
checksum_type: sha256
description:
  [![foodemoji on PyPI](https://img.shields.io/pypi/v/emoji-country-flag.svg)](https://pypi.python.org/pypi/emoji-country-flag)
  [![Python Versions](https://img.shields.io/pypi/pyversions/emoji-country-flag.svg)](https://pypi.python.org/pypi/emoji-country-flag)
  [![Coverage Status](https://coveralls.io/repos/github/cvzi/flag/badge.svg?branch=master)](https://coveralls.io/github/cvzi/flag?branch=master)
  [![Build Status](https://travis-ci.com/cvzi/flag.svg?branch=master)](https://travis-ci.com/cvzi/flag)
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/e897c2f701ee44f5aa36457d0ab1a84a)](https://app.codacy.com/app/cvzi/flag?utm_source=github.com&utm_medium=referral&utm_content=cvzi/flag&utm_campaign=Badge_Grade_Dashboard)
  [![Maintainability](https://api.codeclimate.com/v1/badges/cf1f88720896db4d1b0a/maintainability)](https://codeclimate.com/github/cvzi/flag/maintainability)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=cvzi_flag&metric=alert_status)](https://sonarcloud.io/dashboard?id=cvzi_flag)
  Flag emoji for Python.
  Converts flag emoji to ASCII and other way round.
  This is based on [http://schinckel.net/2015/10/29/unicode-flags-in-python/](http://web.archive.org/web/20180425063617/https://schinckel.net/2015/10/29/unicode-flags-in-python/) by [schinckel](https://github.com/schinckel/)


pkgId: 619f104abb15b21fd2e4f22c85327394e0126801be8191475883cc162631a7fe
name: python-enrich
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: enrich
url: https://github.com/pycontribs/enrich
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-98e0188a-cef0-4196-aec8-58f974ffef99
location_href: 00010355-python-enrich/python-enrich-1.2.7-1.src.rpm
checksum_type: sha256
description:
  Enriched extends [rich](https://pypi.org/project/rich/) library functionality
  with a set of changes that were not accepted to rich itself.



  Our Console class adds one additional option to rich.Console in order to
  redirect `sys.stdout` and `sys.stderr` streams using a FileProxy.

  ```python
  from enrich.console import Console
  import sys

  console = Console(
      redirect=True,  # <-- not supported by rich.cosole.Console
      record=True)
  sys.write("foo")


  assert console.export_text() == "foo"
  ```



  If you want to produce fluid terminal output, one where the client terminal
  decides where to wrap the text instead of the application, you can now
  tell the Console constructor the soft_wrap preference.

  ```python
  from enrich.console import Console
  import sys

  console = Console(soft_wrap=True)
  console.print(...)  # no longer need to pass soft_wrap to each print
  ```



  Extends Rich Console to detect if original text already had ANSI escapes and
  decodes it before processing it. This solves the case where printing
  output captured from other processes that contained ANSI escapes would brake.
  [upstream-404](https://github.com/willmcgugan/rich/discussions/404)



  Rich logger assumes that you always have a fixed width console and it does
  wrap logged output according to it. Our alternative logger does exactly the
  opposite: it ignores the columns of the current console and prints output
  using a Console with soft wrapping enabled.

  The result are logged lines that can be displayed on any terminal or web
  page as they will allow the client to decide when to perform the wrapping.

  ```python
  import logging
  from enrich.logging import RichHandler

  FORMAT = "s"
  logging.basicConfig(
      level="NOTSET", format=FORMAT, datefmt="[%X]", handlers=[RichHandler()]
  )

  log = logging.getLogger("rich")
  log.info("Text that we do not want pre-wrapped by logger: %s", 100 * "x")
  ```


pkgId: 02d6fe4d2d8689626eeb402645b25d28136357104a44a5e832924f55997bc567
name: python-enthought-sphinx-theme
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Sphinx theme for Enthought products
url: https://github.com/enthought/enthought-sphinx-theme
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3818e6c4-4f94-42db-945e-8cdf15813771
location_href: 00003572-python-enthought-sphinx-theme/python-enthought-sphinx-theme-0.7.2-1.src.rpm
checksum_type: sha256
description:
  `Sphinx <http://sphinx-doc.org>`_ theme for `Enthought projects
  <http://www.enthought.com>`_, derived from the `Scipy theme
  <https://github.com/scipy/scipy-sphinx-theme>`_.


pkgId: 468a4c8fa9572d89eb851648561ab0b581f87e9671e0cc0899039be358a51319
name: python-entrypoint2
arch: src
version: 1.1
epoch: 0
release: 1
summary: easy to use command-line interface for python modules
url: https://github.com/ponty/entrypoint2
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ad869ec-e379-4e7a-b249-d08a09fd0864
location_href: 00011031-python-entrypoint2/python-entrypoint2-1.1-1.src.rpm
checksum_type: sha256
description:
  easy to use command-line interface for Python modules

  home: https://github.com/ponty/entrypoint2/tree/1.1


pkgId: c5bf62f6ef66cf547db69f30902a44ab789b793298234ca24d72bb93935c1dde
name: python-enturclient
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: An API client for public transport data from Entur.
url: https://github.com/hfurubotten/enturclient
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d69b32b5-074f-448f-a2b0-151318130e59
location_href: 00003573-python-enturclient/python-enturclient-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Python client for fetching estimated departures from stop places in Norway from [`entur.org`](https://developer.entur.org) API. Information about stop places, platforms and real-time departures.

  [![PyPI version fury.io][pypi-version-badge]][pypi-enturclient]
  [![PyPI pyversions][py-versions-badge]][pypi-enturclient]

  [![Buy me a coffee][buymeacoffee-shield]][buymeacoffee]



  ```python
  import aiohttp
  import asyncio
  from enturclient import EnturPublicTransportData

  API_CLIENT_ID = 'awesome_company - my_application'

  async def print_bergen_train_delay():
      async with aiohttp.ClientSession() as client:
          stops = ['NSR:StopPlace:548']
          quays = ['NSR:Quay:48550']

          data = EnturPublicTransportData(
              client_name=API_CLIENT_ID, # Required
              stops=stops,
              quays=quays,
              omit_non_boarding=True,
              number_of_departures=5,
              web_session=client) # recommended argument

          await data.update()

          bergen_train = data.get_stop_info('NSR:StopPlace:548')
          bergen_train_delay = bergen_train.estimated_calls[0].delay_in_min

          print(bergen_train_delay)

  asyncio.run(print_bergen_train_delay())
  ```



  [Entur's travel planer](https://en-tur.no) has a map of all stops used in Norway. Use the map to find the stops you're interested in. When you have found one of your stops, click on it, and hit "Se alle avganger".

  Now the web browser should contain an URL with the id in it. Such as this:
  `https://en-tur.no/nearby-stop-place-detail?id=NSR:StopPlace:32376`

  The stop id is the content after `id=` parameter in the url. Copy paste this into the configuration.

  It's also possible to use the [National Stop Register (NSR)](https://stoppested.entur.org).
  Find your stop in the map, click on it and then again at the name. You have to zoom quite a bit in before the stops shows in the map. Information about the stop place, including the stop and quay ids will pop up on the side.

  [buymeacoffee-shield]: https://www.buymeacoffee.com/assets/img/guidelines/download-assets-sm-2.svg
  [buymeacoffee]: https://www.buymeacoffee.com/heine
  [pypi-enturclient]: https://pypi.org/project/enturclient/
  [pypi-version-badge]: https://badge.fury.io/py/enturclient.svg
  [py-versions-badge]: https://img.shields.io/pypi/pyversions/enturclient.svg


pkgId: 0422216715eb49a2816f683c711dea4038457509fdd396db4535f544e059e849
name: python-enum-compat
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: enum/enum34 compatibility package
url: https://github.com/jstasiak/enum-compat
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1fb54f1f-38dc-42e0-8c7f-9357f7d5e088
location_href: 00009992-python-enum-compat/python-enum-compat-0.0.3-1.src.rpm
checksum_type: sha256
description:
  This is a virtual package, its whole purpose is to install enum34 on
  Python older than 3.4. On Python 3.4+ it's a no-op.


pkgId: f52e434266a43798cfb5233a83a25f066319dfbcb1c1e0720f9ced5ac7e78beb
name: python-environs
arch: src
version: 9.5.0
epoch: 0
release: 1
summary: simplified environment variable parsing
url: https://github.com/sloria/environs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d65dfbf1-82f8-4773-b74a-efc415712485
location_href: 00010070-python-environs/python-environs-9.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Latest version](https://badgen.net/pypi/v/environs)](https://pypi.org/project/environs/)
  [![Build Status](https://dev.azure.com/sloria/sloria/_apis/build/status/sloria.environs?branchName=master)](https://dev.azure.com/sloria/sloria/_build/latest?definitionId=12&branchName=master)
  [![marshmallow 3 compatible](https://badgen.net/badge/marshmallow/3)](https://marshmallow.readthedocs.io/en/latest/upgrading.html)
  [![Black code style](https://badgen.net/badge/code%20style/black/000)](https://github.com/ambv/black)

  **environs** is a Python library for parsing environment variables.
  It allows you to store configuration separate from your code, as per
  [The Twelve-Factor App](https://12factor.net/config) methodology.



  - [Features](#features)
  - [Install](#install)
  - [Basic usage](#basic-usage)
  - [Supported types](#supported-types)
  - [Reading .env files](#reading-env-files)
    - [Reading a specific file](#reading-a-specific-file)
  - [Handling prefixes](#handling-prefixes)
  - [Variable expansion](#variable-expansion)
  - [Validation](#validation)
  - [Deferred validation](#deferred-validation)
  - [Serialization](#serialization)
  - [Defining custom parser behavior](#defining-custom-parser-behavior)
  - [Usage with Flask](#usage-with-flask)
  - [Usage with Django](#usage-with-django)
  - [Why...?](#why)
    - [Why envvars?](#why-envvars)
    - [Why not os.environ?](#why-not-osenviron)
    - [Why another library?](#why-another-library)
  - [License](#license)



  - Type-casting
  - Read `.env` files into `os.environ` (useful for local development)
  - Validation
  - Define custom parser behavior
  - Framework-agnostic, but integrates well with [Flask](#usage-with-flask) and [Django](#usage-with-django)



      pip install environs



  With some environment variables set...

  ```bash
  export GITHUB_USER=sloria
  export MAX_CONNECTIONS=100
  export SHIP_DATE='1984-06-25'
  export TTL=42
  export ENABLE_LOGIN=true
  export GITHUB_REPOS=webargs,konch,ped
  export GITHUB_REPO_PRIORITY="webargs=2,konch=3"
  export COORDINATES=23.3,50.0
  export LOG_LEVEL=DEBUG
  ```

  Parse them with environs...

  ```python
  from environs import Env

  env = Env()
  env.read_env()  # read .env file, if it exists

  gh_user = env("GITHUB_USER")  # => 'sloria'
  secret = env("SECRET")  # => raises error if not set


  max_connections = env.int("MAX_CONNECTIONS")  # => 100
  ship_date = env.date("SHIP_DATE")  # => datetime.date(1984, 6, 25)
  ttl = env.timedelta("TTL")  # => datetime.timedelta(0, 42)
  log_level = env.log_level("LOG_LEVEL")  # => logging.DEBUG


  enable_login = env.bool("ENABLE_LOGIN", False)  # => True
  enable_feature_x = env.bool("ENABLE_FEATURE_X", False)  # => False


  gh_repos = env.list("GITHUB_REPOS")  # => ['webargs', 'konch', 'ped']
  coords = env.list("COORDINATES", subcast=float)  # => [23.3, 50.0]


  gh_repos_priorities = env.dict(
      "GITHUB_REPO_PRIORITY", subcast_values=int
  )  # => {'webargs': 2, 'konch': 3}
  ```



  The following are all type-casting methods of `Env`:

  - `env.str`
  - `env.bool`
  - `env.int`
  - `env.float`
  - `env.decimal`
  - `env.list` (accepts optional `subcast` and `delimiter` keyword arguments)
  - `env.dict` (accepts optional `subcast_keys` and `subcast_values` keyword arguments)
  - `env.json`
  - `env.datetime`
  - `env.date`
  - `env.time`
  - `env.timedelta` (assumes value is an integer in seconds)
  - `env.url`
  - `env.uuid`
  - `env.log_level`
  - `env.path` (casts to a [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html))
  - `env.enum` (casts to any given enum type specified in `type` keyword argument, accepts optional `ignore_case` keyword argument)



  ```bash

  DEBUG=true
  PORT=4567
  ```

  Call `Env.read_env` before parsing variables.

  ```python
  from environs import Env

  env = Env()

  env.read_env()

  env.bool("DEBUG")  # => True
  env.int("PORT")  # => 4567
  ```



  By default, `Env.read_env` will look for a `.env` file in current
  directory and (if no .env exists in the CWD) recurse
  upwards until a `.env` file is found.

  You can also read a specific file:

  ```python
  from environs import Env

  with open(".env.test", "w") as fobj:
      fobj.write("A=foo\n")
      fobj.write("B=123\n")

  env = Env()
  env.read_env(".env.test", recurse=False)

  assert env("A") == "foo"
  assert env.int("B") == 123
  ```



  ```python



  with env.prefixed("MYAPP_"):
      host = env("HOST", "localhost")  # => 'lolcathost'
      port = env.int("PORT", 5000)  # => 3000






  with env.prefixed("MYAPP_"):
      with env.prefixed("DB_"):
          db_host = env("HOST", "lolcathost")
          db_port = env.int("PORT", 10101)
  ```



  ```python




  from environs import Env

  env = Env(expand_vars=True)

  connection_url = env("CONNECTION_URL")  # =>'https://sloria:secret@localhost'
  year = env.int("YEAR")  # =>2020
  ```



  ```python




  from environs import Env
  from marshmallow.validate import OneOf, Length, Email

  env = Env()


  env.int("TTL", validate=lambda n: n > 0)




  env.str(
      "NODE_ENV",
      validate=OneOf(
          ["production", "development"], error="NODE_ENV must be one of: {choices}"
      ),
  )



  env.str("EMAIL", validate=[Length(min=4), Email()])

  ```



  By default, a validation error is raised immediately upon calling a parser method for an invalid environment variable.
  To defer validation and raise an exception with the combined error messages for all invalid variables, pass `eager=False` to `Env`.
  Call `env.seal()` after all variables have been parsed.

  ```python




  from environs import Env
  from marshmallow.validate import OneOf, Email, Length, Range

  env = Env(eager=False)

  TTL = env.int("TTL", validate=Range(min=0, max=100))
  NODE_ENV = env.str(
      "NODE_ENV",
      validate=OneOf(
          ["production", "development"], error="NODE_ENV must be one of: {choices}"
      ),
  )
  EMAIL = env.str("EMAIL", validate=[Length(min=4), Email()])

  env.seal()

  ```

  `env.seal()` validates all parsed variables and prevents further parsing (calling a parser method will raise an error).



  ```python

  env.dump()










  ```



  ```python



  from furl import furl


  @env.parser_for("furl")
  def furl_parser(value):
      return furl(value)


  domain = env.furl("DOMAIN")  # => furl('https://myapp.com')



  @env.parser_for("choice")
  def choice_parser(value, choices):
      if value not in choices:
          raise environs.EnvError("Invalid!")
      return value


  color = env.choice("COLOR", choices=["black"])  # => raises EnvError
  ```



  ```python


  from environs import Env

  env = Env()
  env.read_env()


  DEBUG = env.bool("FLASK_DEBUG", default=False)

  SECRET_KEY = env.str("SECRET_KEY")
  ```

  Load the configuration after you initialize your app.

  ```python


  from flask import Flask

  app = Flask(__name__)
  app.config.from_object("myapp.settings")
  ```

  For local development, use a `.env` file to override the default
  configuration.

  ```bash

  DEBUG=true
  SECRET_KEY="not so secret"
  ```

  Note: Because environs depends on [python-dotenv](https://github.com/theskumar/python-dotenv),
  the `flask` CLI will automatically read .env and .flaskenv files.



  environs includes a number of helpers for parsing connection URLs. To
  install environs with django support:

      pip install environs[django]

  Use `env.dj_db_url`, `env.dj_cache_url` and `env.dj_email_url` to parse the `DATABASE_URL`, `CACHE_URL`
  and `EMAIL_URL` environment variables, respectively.

  For more details on URL patterns, see the following projects that environs is using for converting URLs.

  - [dj-database-url](https://github.com/jacobian/dj-database-url)
  - [django-cache-url](https://github.com/epicserve/django-cache-url)
  - [dj-email-url](https://github.com/migonzalvar/dj-email-url)

  Basic example:

  ```python

  from environs import Env

  env = Env()
  env.read_env()


  DEBUG = env.bool("DEBUG", default=False)

  SECRET_KEY = env.str("SECRET_KEY")


  DATABASES = {"default": env.dj_db_url("DATABASE_URL")}


  email = env.dj_email_url("EMAIL_URL", default="smtp://")
  EMAIL_HOST = email["EMAIL_HOST"]
  EMAIL_PORT = email["EMAIL_PORT"]
  EMAIL_HOST_PASSWORD = email["EMAIL_HOST_PASSWORD"]
  EMAIL_HOST_USER = email["EMAIL_HOST_USER"]
  EMAIL_USE_TLS = email["EMAIL_USE_TLS"]


  CACHES = {"default": env.dj_cache_url("CACHE_URL")}
  ```

  For local development, use a `.env` file to override the default
  configuration.

  ```bash

  DEBUG=true
  SECRET_KEY="not so secret"
  ```

  For a more complete example, see
  [django_example.py](https://github.com/sloria/environs/blob/master/examples/django_example.py)
  in the `examples/` directory.





  See [The 12-factor App](http://12factor.net/config) section on
  [configuration](http://12factor.net/config).



  While `os.environ` is enough for simple use cases, a typical application
  will need a way to manipulate and validate raw environment variables.
  environs abstracts common tasks for handling environment variables.

  environs will help you

  - cast envvars to the correct type
  - specify required envvars
  - define default values
  - validate envvars
  - parse list and dict values
  - parse dates, datetimes, and timedeltas
  - parse expanded variables
  - serialize your configuration to JSON, YAML, etc.



  There are many great Python libraries for parsing environment variables.
  In fact, most of the credit for environs\' public API goes to the
  authors of [envparse](https://github.com/rconradharris/envparse) and
  [django-environ](https://github.com/joke2k/django-environ).

  environs aims to meet three additional goals:

  1.  Make it easy to extend parsing behavior and develop plugins.
  2.  Leverage the deserialization and validation functionality provided
      by a separate library (marshmallow).
  3.  Clean up redundant API.

  See [this GitHub
  issue](https://github.com/rconradharris/envparse/issues/12#issue-151036722)
  which details specific differences with envparse.



  MIT licensed. See the
  [LICENSE](https://github.com/sloria/environs/blob/master/LICENSE) file
  for more details.


pkgId: e873b5b689779bf2a28808d19b756a0a14ab73c1a7e46be9adb53acba27fd8ed
name: python-envparse
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Simple environment variable parsing
url: https://github.com/rconradharris/envparse
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2477bebe-e9af-454d-bc6f-22b8462564b5
location_href: 00011369-python-envparse/python-envparse-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ``envparse`` is a simple utility to parse environment variables.
  If you use Heroku and/or subscribe to the tenets of the
  `12 Factor App <http://www.12factor.net/>`_
  you'll be using a lot of environment variable-based configuration in your app.
  ``os.environ`` is a great choice to start off with but over time you'll find
  yourself duplicating quite a bit of code around handling raw environment
  variables.
  ``envparse`` aims to eliminate this duplicated, often inconsistent parsing
  code and instead provide a single, easy-to-use wrapper.
  Ideas, and code portions, have been taken from `django-environ
  <https://github.com/joke2k/django-environ>`_ project but made framework
  agnostic.


pkgId: e88360e489af6024b3958a1815197d9ddd00d3554735fa32675053b83142100b
name: python-epc
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: EPC (RPC stack for Emacs Lisp) implementation in Python
url: https://github.com/tkf/python-epc
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-67bc38b6-8150-4a50-bf19-520a2eae8f80
location_href: 00003576-python-epc/python-epc-0.0.5-1.src.rpm
checksum_type: sha256
description:
  Links:
  * `Documentation <http://python-epc.readthedocs.org/>`_ (at Read the Docs)
  * `Repository <https://github.com/tkf/python-epc>`_ (at GitHub)
  * `Issue tracker <https://github.com/tkf/python-epc/issues>`_ (at GitHub)
  * `PyPI <http://pypi.python.org/pypi/epc>`_
  * `Travis CI <https://travis-ci.org/#!/tkf/python-epc>`_ |build-status|
  Other resources:
  * `kiwanami/emacs-epc <https://github.com/kiwanami/emacs-epc>`_
    (Client and server implementation in Emacs Lisp and Perl.)
  * `tkf/emacs-jedi <https://github.com/tkf/emacs-jedi>`_
    (Python completion for Emacs using EPC server.)
     image:: https://secure.travis-ci.org/tkf/python-epc.png
             ?branch=master


pkgId: 19eb1009a1919e8f76675f2b129b9f4fed69384b5f2746c99e4219c53f67b903
name: python-ephem-debuginfo
arch: aarch64
version: 4.1.4
epoch: 0
release: 1
summary: Debug information for package python-ephem
url: http://rhodesmill.org/pyephem/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-254636b0-316c-4882-b174-84b66f4a58c1
rpm_sourcerpm: python-ephem-4.1.4-1.src.rpm
location_href: 00003577-python-ephem/python-ephem-debuginfo-4.1.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-ephem.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 554c16751e4cc85f6bb3ec6bbf2b9ead7ce9c670c4c7073b2a005f0b6a4944a3
name: python-ephem-debugsource
arch: aarch64
version: 4.1.4
epoch: 0
release: 1
summary: Debug sources for package python-ephem
url: http://rhodesmill.org/pyephem/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-254636b0-316c-4882-b174-84b66f4a58c1
rpm_sourcerpm: python-ephem-4.1.4-1.src.rpm
location_href: 00003577-python-ephem/python-ephem-debugsource-4.1.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-ephem.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 68191307019641baf1151d7703bf1a7bd53e387f448d6a3340b025abd5a816c4
name: python-epiweeks
arch: src
version: 2.1.4
epoch: 0
release: 1
summary: Epidemiological weeks calculation based on the US CDC (MMWR) and ISO week numbering systems
url: https://github.com/mhalshehri/epiweeks
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d99def53-6c43-49ee-8748-989a180077b8
location_href: 00011477-python-epiweeks/python-epiweeks-2.1.4-1.src.rpm
checksum_type: sha256
description:
  <!-- start description -->

  A Python package to calculate epidemiological weeks using the US CDC (MMWR) and
  ISO week numbering systems.

  <!-- end description -->

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

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

  <!-- start summary -->



  - Support for both the US CDC (MMWR) and ISO week numbering systems.
  - Accurate and tested calculations.
  - Intuitive, clean, and easy-to-use interface.
  - Calculation of the start and end dates of weeks.
  - Iteration of year's weeks or week's dates.
  - Rich comparison between weeks.
  - Logical operations for weeks (addition, subtraction and containment).
  - Validation of input data.
  - Works on Python 3.6+ with zero dependencies.
  - Thoroughly tested with 100% test coverage.



  To install using `pip`, run:

  ```shell
  pip install epiweeks
  ```

  To install using `conda`, run:

  ```shell
  conda install -c bioconda epiweeks
  ```



  ```python
  from epiweeks import Week, Year

  week = Week(2019, 1)
  print(week.enddate())


  for week in Year(2019).iterweeks():
      print(week.enddate())





  ```

  <!-- end summary -->



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



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


pkgId: 44f1f75353f655c38ec24edd628756e9d940412ac721cb2a8c387c39294de46b
name: python-epsagon
arch: src
version: 1.82.0
epoch: 0
release: 1
summary: Epsagon Instrumentation for Python
url: https://github.com/epsagon/epsagon-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7b5f6b99-0fd4-4944-b6db-e179a63bdbdc
location_href: 00012739-python-epsagon/python-epsagon-1.82.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://epsagon.com" target="_blank" align="center">
      <img src="https://cdn2.hubspot.net/hubfs/4636301/Positive%20RGB_Logo%20Horizontal%20-01.svg" width="300">
    </a>
    <br />
  </p>

  [![Build Status](https://travis-ci.com/epsagon/epsagon-python.svg?token=wsveVqcNtBtmq6jpZfSf&branch=master)](https://travis-ci.com/epsagon/epsagon-python)
  [![Pyversions](https://img.shields.io/pypi/pyversions/epsagon.svg?style=flat)](https://pypi.org/project/epsagon/)
  [![PypiVersions](https://img.shields.io/pypi/v/epsagon.svg)](https://pypi.org/project/epsagon/)



  ![Trace](trace.png)

  This package provides tracing to Python applications for the collection of distributed tracing and performance metrics in [Epsagon](https://app.epsagon.com/?utm_source=github).



  - [Installation](#installation)
  - [Usage](#usage)
    - [Auto-tracing](#auto-tracing)
    - [Calling the SDK](#calling-the-sdk)
    - [Tagging Traces](#tagging-traces)
    - [Measuring Function Duration](#measuring-function-duration)
    - [Custom Errors](#custom-errors)
    - [Filter Sensitive Data](#filter-sensitive-data)
    - [Ignore Endpoints](#ignore-endpoints)
    - [Trace URL](#trace-url)
  - [Frameworks](#frameworks)
  - [Integrations](#integrations)
  - [Configuration](#configuration)
  - [Getting Help](#getting-help)
  - [Opening Issues](#opening-issues)
  - [License](#license)




  To install Epsagon, simply run:
  ```sh
  pip install -U epsagon
  ```





  The simplest way to get started is to run your python command with the following environment variable:
  ```sh
  export EPSAGON_TOKEN=<epsagon-token>
  export EPSAGON_APP_NAME=<app-name-stage>
  export EPSAGON_METADATA=FALSE
  export AUTOWRAPT_BOOTSTRAP=epsagon
  <python command>
  ```

  For example:
  ```sh
  export EPSAGON_TOKEN=<your-token>
  export EPSAGON_APP_NAME=django-prod
  export EPSAGON_METADATA=FALSE
  export AUTOWRAPT_BOOTSTRAP=epsagon
  python app.py
  ```

  When using inside a `Dockerfile`, you can use `ENV` instead of `export`.

  You can see the list of auto-tracing [supported frameworks](#frameworks)



  Another simple alternative is to copy the snippet into your code:
  ```python
  import epsagon
  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False,
  )
  ```

  To run on your framework please refer to [supported frameworks](#frameworks)




  You can add custom tags to your traces, for easier filtering and aggregations.

  Add the following call inside your code:
  ```python
  epsagon.label('key', 'value')
  epsagon.label('user_id', user_id)
  ```

  You can also use it to ship custom metrics:
  ```python
  epsagon.label('key', 'metric')
  epsagon.label('items_in_cart', items_in_cart)
  ```

  Valid types are `string`, `bool`, `int` and `float`.
  In some [frameworks](#frameworks) tagging can be done in different ways.



  You can measure internal functions duration by using the `@epsagon.measure` decorator. For example:
  ```python
  @epsagon.measure
  def heavy_calculation():
      
  ```

  This will ship another metric label to epsagon where the `key=heavy_calculation_duration` and the value will be the actual duration, in seconds.
  You'll be able to see this label in the trace search, visualize it over time, and generate alerts based on this metric.



  You can set a trace as an error (although handled correctly) to get an alert or just follow it on the dashboard.

  Add the following call inside your code:
  ```python
  try:
      fail = 1 / 0
  except Exception as ex:
      epsagon.error(ex)


  epsagon.error(Exception('My custom error'))
  ```

  In some [frameworks](#frameworks) custom errors can be declared in different ways.



  You can pass a list of sensitive properties and hostnames and they will be filtered out from the traces:

  ```python
  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False,
      keys_to_ignore=['password', 'user_name'],
      url_patterns_to_ignore=['example.com', 'auth.com']
  )
  ```

  Or specify keys that are allowed:

  ```python
  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False,
      keys_to_allow=['Request Data', 'Status_Code'],
  )
  ```

  The `keys_to_ignore` and `keys_to_allow` properties can contain strings (will perform a loose match, so that `First Name` also matches `first_name`).
  Also, you can set `url_patterns_to_ignore` to ignore HTTP calls to specific domains.




  You can ignore certain incoming requests by specifying endpoints:
  ```python
  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False,
      ignored_endpoints=['/healthcheck'],
  )
  ```



  You can get the Epsagon dashboard URL for the current trace, using the following:
  ```python
  import epsagon


  print('Epsagon trace URL:', epsagon.get_trace_url())
  ```

  This can be useful to have an easy access the trace from different platforms.



  The following frameworks are supported by Epsagon:

  |Framework                               |Supported Version          |Auto-tracing Supported                               |
  |----------------------------------------|---------------------------|-----------------------------------------------------|
  |[AWS Lambda](#aws-lambda)               |All                        |<ul><li>- [x] (Through the dashboard only)</li></ul> |
  |[Step Functions](#step-functions)       |All                        |<ul><li>- [ ] </li></ul>                             |
  |[Generic](#generic)                     |All                        |<ul><li>- [ ] </li></ul>                             |
  |[Gunicorn](#gunicorn)                   |`>=20.0.4`                 |<ul><li>- [x] </li></ul>                             |
  |[Django](#django)                       |`>=1.11`                   |<ul><li>- [x] </li></ul>                             |
  |[Flask](#flask)                         |`>=0.5`                    |<ul><li>- [x] </li></ul>                             |
  |[Tornado](#tornado)                     |`>=4.0`                    |<ul><li>- [x] </li></ul>                             |
  |[fastapi](#fastapi)                     |`>=0.62.0`                 |<ul><li>- [x] </li></ul>                             |
  |[Celery](#celery)                       |`>=4.0.0`                  |<ul><li>- [x] </li></ul>                             |
  |[Azure Functions](#azure-functions)     |`>=2.0.0`                  |<ul><li>- [ ] </li></ul>                             |
  |[Chalice](#chalice)                     |`>=1.0.0`                  |<ul><li>- [ ] </li></ul>                             |
  |[Zappa](#zappa)                         |`>=0.30.0`                 |<ul><li>- [ ] </li></ul>                             |




  Tracing Lambda functions can be done in three methods:
  1. Auto-tracing through the Epsagon dashboard.
  2. Using the [`serverless-plugin-epsagon`](https://github.com/epsagon/serverless-plugin-epsagon) if you're using The Serverless Framework.
  3. Calling the SDK.

  **Make sure to choose just one of the methods**

  Calling the SDK is simple:

  ```python
  import epsagon
  epsagon.init(
      token='<epsagon-token>',
      app_name='<app-name-stage>',
      metadata_only=False,
  )


  @epsagon.lambda_wrapper
  def handle(event, context):
      
  ```



  Tracing Step Functions is similar to regular Lambda functions, but the wrapper changes from `lambda_wrapper` to `step_lambda_wrapper`:

  ```python
  import epsagon
  epsagon.init(
      token='<epsagon-token>',
      app_name='<app-name-stage>',
      metadata_only=False,
  )


  @epsagon.step_lambda_wrapper
  def handle(event, context):
      
  ```



  Tracing Django application can be done in two methods:
  1. [Auto-tracing](#auto-tracing) using the environment variable.
  2. Calling the SDK.

  Calling the SDK is simple, and should be done in your main `settings.py` file where the application is being initialized:
  ```python
  import epsagon
  epsagon.init(
      token='<epsagon-token>',
      app_name='<app-name-stage>',
      metadata_only=False,
  )
  ```




  Tracing Flask application can be done in two methods:
  1. [Auto-tracing](#auto-tracing) using the environment variable.
  2. Calling the SDK.

  Calling the SDK is simple, and should be done in your main `py` file where the application is being initialized:
  ```python
  import epsagon
  epsagon.init(
      token='<epsagon-token>',
      app_name='<app-name-stage>',
      metadata_only=False,
  )
  ```



  Tracing Tornado application can be done in two methods:
  1. [Auto-tracing](#auto-tracing) using the environment variable.
  2. Calling the SDK.

  Calling the SDK is simple, and should be done in your main `py` file where the application is being initialized:
  ```python
  import epsagon
  epsagon.init(
      token='<epsagon-token>',
      app_name='<app-name-stage>',
      metadata_only=False,
  )
  ```



  Tracing fastapi application can be done in two methods:
  1. [Auto-tracing](#auto-tracing) using the environment variable.
  2. Calling the SDK.

  Calling the SDK is simple, and should be done in your main `py` file where the application is being initialized:
  ```python
  import epsagon
  epsagon.init(
      token='<epsagon-token>',
      app_name='<app-name-stage>',
      metadata_only=False,
  )
  ```



  Tracing Celery consumer can be done in two methods:
  1. [Auto-tracing](#auto-tracing) using the environment variable.
  2. Calling the SDK.

  Calling the SDK is simple, and should be done in your main `py` file where the consumer is being initialized:
  ```python
  import epsagon
  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False,
  )
  ```



  Tracing Gunicorn application can be done in two methods:
  1. [Auto-tracing](#auto-tracing) using the environment variable.
  2. Calling the SDK.

  Calling the SDK is simple, and should be done in your main `py` file where the application is being initialized:
  ```python
  import epsagon
  epsagon.init(
      token='<epsagon-token>',
      app_name='<app-name-stage>',
      metadata_only=False,
  )
  ```



  Tracing Azure Functions can be done in the following method:

  ```python
  import azure.functions as func
  import epsagon
  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False,
  )

  @epsagon.azure_wrapper
  def main(req):
      return func.HttpResponse('Success')
  ```



  Tracing Chalice applications running on Lambda functions can be done by:
  ```python
  from chalice import Chalice
  import epsagon
  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False
  )
  app = Chalice(app_name='hello-world')



  app = epsagon.chalice_wrapper(app)
  ```



  Tracing web applications running on Lambda functions using Zappa can be done by:
  ```python
  from zappa.handler import lambda_handler
  import epsagon

  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False
  )



  epsagon_handler = epsagon.lambda_wrapper(lambda_handler)
  ```

  And in your `zappa_settings.json` file include the following:

  ```json
  {
    "lambda_handler": "module.path_to.epsagon_handler"
  }
  ```



  For any tracing, you can simply use the generic Epsagon wrapper using the following example:

  ```python
  import epsagon
  epsagon.init(
      token='epsagon-token',
      app_name='app-name-stage',
      metadata_only=False,
  )


  @epsagon.python_wrapper(name='my-resource')
  def main(params):
      
  ```



  Epsagon provides out-of-the-box instrumentation (tracing) for many popular frameworks and libraries.

  |Library             |Supported Version          |
  |--------------------|---------------------------|
  |logging             |Fully supported            |
  |urllib              |Fully supported            |
  |urllib3             |Fully supported            |
  |requests            |`>=2.0.0`                  |
  |httplib2            |`>=0.9.2`                  |
  |redis               |`>=2.10.0`                 |
  |pymongo             |`>=3.0.0`                  |
  |pynamodb            |`>=2.0.0`                  |
  |PyMySQL             |`>=0.7.0`                  |
  |MySQLdb             |`>=1.0.0`                  |
  |psycopg2            |`>=2.2.0`                  |
  |pg8000              |`>=1.9.0`                  |
  |botocore (boto3)    |`>=1.4.0`                  |
  |azure.cosmos        |`>=4.0.0`                  |
  |celery              |`>=4.0.0`                  |
  |greengrasssdk       |`>=1.4.0`                  |
  |SQLAlchemy          |`>=1.2.0,<1.4.0`           |
  |kafka-python        |`>=1.4.0`                  |





  Advanced options can be configured as a parameter to the init() method or as environment variables.

  |Parameter               |Environment Variable           |Type   |Default      |Description                                                                        |
  |----------------------  |------------------------------ |-------|-------------|-----------------------------------------------------------------------------------|
  |token                   |EPSAGON_TOKEN                  |String |-            |Epsagon account token                                                              |
  |app_name                |EPSAGON_APP_NAME               |String |`Application`|Application name that will be set for traces                                       |
  |metadata_only           |EPSAGON_METADATA               |Boolean|`True`       |Whether to send only the metadata (`True`) or also the payloads (`False`)          |
  |use_ssl                 |EPSAGON_SSL                    |Boolean|`True`       |Whether to send the traces over HTTPS SSL or not                                   |
  |collector_url           |EPSAGON_COLLECTOR_URL          |String |-            |The address of the trace collector to send trace to                                |
  |keys_to_ignore          |EPSAGON_IGNORED_KEYS           |List   |-            |List of keys names to be removed from the trace                                    |
  |keys_to_allow           |EPSAGON_ALLOWED_KEYS           |List   |-            |List of keys names to be included from the trace                                   |
  |ignored_endpoints       |EPSAGON_ENDPOINTS_TO_IGNORE    |List   |-            |List of endpoints to ignore from tracing (for example `/healthcheck`               |
  |url_patterns_to_ignore  |EPSAGON_URLS_TO_IGNORE         |List   |`[]`         |Array of URL patterns to ignore the calls                                          |
  |debug                   |EPSAGON_DEBUG                  |Boolean|`False`      |Enable debug prints for troubleshooting                                            |
  |disable_timeout_send    |EPSAGON_DISABLE_ON_TIMEOUT     |Boolean|`False`      |Disable timeout detection in Lambda functions                                      |
  |split_on_send           |EPSAGON_SPLIT_ON_SEND          |Boolean|`False`      |Split the trace into multiple chunks to support large traces                       |
  |propagate_lambda_id     |EPSAGON_PROPAGATE_LAMBDA_ID    |Boolean|`False`      |Insert Lambda request ID into the response payload                                 |
  |logging_tracing_enabled |EPSAGON_LOGGING_TRACING_ENABLED|Boolean|`True`      |Add Epsagon Log Id to all `logging` messages                            |
  |step_dict_output_path |EPSAGON_STEPS_OUTPUT_PATH|List|`None`      |Path in the result dict to append the Epsagon steps data  |
  |-                       |EPSAGON_HTTP_ERR_CODE          |Integer|`500`        |The minimum number of an HTTP response status code to treat as an error            |
  |-                       |EPSAGON_SEND_TIMEOUT_SEC       |Float  |`1.0`        |The timeout duration in seconds to send the traces to the trace collector          |
  |-                       |EPSAGON_DISABLE_LOGGING_ERRORS |Boolean|`False`      |Disable the automatic capture of error messages into `logging`                     |
  |-                       |EPSAGON_IGNORE_FLASK_RESPONSE  |Boolean|`False`      |Disable the automatic capture of Flask response data                     |
  |-                       |EPSAGON_SKIP_HTTP_RESPONSE     |Boolean|`False`      |Disable the automatic capture of http client response data                     |
  |-                       |DISABLE_EPSAGON                |Boolean|`False`      |A flag to completely disable Epsagon (can be used for tests or locally)            |
  |-                       |DISABLE_EPSAGON_PATCH          |Boolean|`False`      |Disable the library patching (instrumentation)                                     |
  |-                       |EPSAGON_LAMBDA_TIMEOUT_THRESHOLD_MS          |Integer|`200`      |The threshold in millieseconds to send the trace before a Lambda timeout occurs                                     |
  |-                       |EPSAGON_PAYLOADS_TO_IGNORE     |List   |-            |Array of dictionaries to not instrument. Example: `'[{"source": "serverless-plugin-warmup"}]'` |
  |-                       |EPSAGON_REMOVE_EXCEPTION_FRAMES|Boolean|`False`      |Disable the automatic capture of exception frames data (Python 3)                             |
  |-                       |EPSAGON_FASTAPI_ASYNC_MODE|Boolean|`False`      |Enable capturing of Fast API async endpoint handlers calls(Python 3)                             |






  If you have any issue around using the library or the product, please don't hesitate to:

  * Use the [documentation](https://docs.epsagon.com).
  * Use the help widget inside the product.
  * Open an issue in GitHub.




  If you encounter a bug with the Epsagon library for Python, we want to hear about it.

  When opening a new issue, please provide as much information about the environment:
  * Library version, Python runtime version, dependencies, etc.
  * Snippet of the usage.
  * A reproducible example can really help.

  The GitHub issues are intended for bug reports and feature requests.
  For help and questions about Epsagon, use the help widget inside the product.



  Provided under the MIT license. See LICENSE for details.

  Copyright 2020, Epsagon


pkgId: 2f674a4aa412e15c85ace5fa0d482735df9939bcb3c9343b234bdea259f74880
name: python-epson-projector
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Epson projector support for Python
url: https://github.com/pszafer/epson_projector
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0a332bf2-d65e-42c8-8be3-8ff66f634a85
location_href: 00003579-python-epson-projector/python-epson-projector-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Requires Python 3.5. asyncio, aiohttp.

  Created mostly to use with Home Assistant.



  Check out test.py and const.py to see all posibilities to send to projector.

  ```python
  """Test and example of usage of Epson module."""
  import epson_projector as epson
  from epson_projector.const import (POWER)

  import asyncio
  import aiohttp


  async def main():
      """Run main with aiohttp ClientSession."""
      async with aiohttp.ClientSession() as session:
          await run(session)


  async def run(websession):
      """Use Projector class of epson module and check if it is turned on."""
      projector = epson.Projector(
          host='HOSTNAME',
          websession=websession,
          encryption=False)
      data = await projector.get_property(POWER)
      print(data)

  asyncio.get_event_loop().run_until_complete(main())
  ```


pkgId: a85af930cde03297fe7d29c1653a9db5a65c81ae3735526d8421cb9521460aba
name: python-esprima
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: ECMAScript parsing infrastructure for multipurpose analysis in Python
url: https://github.com/Kronuz/esprima-python
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a8303853-e3c0-4e0d-b4ab-214f47a43c1c
location_href: 00012675-python-esprima/python-esprima-4.0.1-1.src.rpm
checksum_type: sha256
description:
  |Donate| |PyPI Version| |PyPI License| |PyPI Format| |PyPI Status|

  **Esprima** (`esprima.org <http://esprima.org>`__, BSD license) is a
  high performance, standard-compliant
  `ECMAScript <http://www.ecma-international.org/publications/standards/Ecma-262.htm>`__
  parser officially written in ECMAScript (also popularly known as
  `JavaScript <https://en.wikipedia.org/wiki/JavaScript>`__) and ported to
  Python. Esprima is created and maintained by `Ariya
  Hidayat <https://twitter.com/ariyahidayat>`__, with the help of `many
  contributors <https://github.com/jquery/esprima/contributors>`__.

  Python port is a line-by-line manual translation and was created and is
  maintained by `German Mendez Bravo
  (Kronuz) <https://twitter.com/germbravo>`__.

  Features
  ~~~~~~~~

  -  Full support for ECMAScript 2017 (`ECMA-262 8th
     Edition <http://www.ecma-international.org/publications/standards/Ecma-262.htm>`__)
  -  Sensible `syntax tree
     format <https://github.com/estree/estree/blob/master/es5.md>`__ as
     standardized by `ESTree project <https://github.com/estree/estree>`__
  -  Experimental support for `JSX <https://facebook.github.io/jsx/>`__, a
     syntax extension for `React <https://facebook.github.io/react/>`__
  -  Optional tracking of syntax node location (index-based and
     line-column)
  -  `Heavily tested <http://esprima.org/test/ci.html>`__ (~1500 `unit
     tests <https://github.com/jquery/esprima/tree/master/test/fixtures>`__
     with `full code
     coverage <https://codecov.io/github/jquery/esprima>`__)

  Installation
  ~~~~~~~~~~~~

  .. code:: shell

      pip install esprima

  API
  ~~~

  Esprima can be used to perform `lexical
  analysis <https://en.wikipedia.org/wiki/Lexical_analysis>`__
  (tokenization) or `syntactic
  analysis <https://en.wikipedia.org/wiki/Parsing>`__ (parsing) of a
  JavaScript program.

  A simple example:

  .. code:: javascript

      >>> import esprima
      >>> program = 'const answer = 42'

      >>> esprima.tokenize(program)
      [{
          type: "Keyword",
          value: "const"
      }, {
          type: "Identifier",
          value: "answer"
      }, {
          type: "Punctuator",
          value: "="
      }, {
          type: "Numeric",
          value: "42"
      }]

      >>> esprima.parseScript(program)
      {
          body: [
              {
                  kind: "const",
                  declarations: [
                      {
                          init: {
                              raw: "42",
                              type: "Literal",
                              value: 42
                          },
                          type: "VariableDeclarator",
                          id: {
                              type: "Identifier",
                              name: "answer"
                          }
                      }
                  ],
                  type: "VariableDeclaration"
              }
          ],
          type: "Program",
          sourceType: "script"
      }

  For more information, please read the `complete
  documentation <http://esprima.org/doc>`__.

  .. |Donate| image:: https://img.shields.io/badge/Donate-PayPal-green.svg
     :target: https://www.paypal.me/Kronuz/25
  .. |PyPI Version| image:: https://img.shields.io/pypi/v/esprima.svg
     :target: https://pypi.python.org/pypi/esprima
  .. |PyPI License| image:: https://img.shields.io/pypi/l/esprima.svg
     :target: https://pypi.python.org/pypi/esprima
  .. |PyPI Wheel| image:: https://img.shields.io/pypi/wheel/esprima.svg
     :target: https://pypi.python.org/pypi/esprima
  .. |PyPI Format| image:: https://img.shields.io/pypi/format/esprima.svg
     :target: https://pypi.python.org/pypi/esprima
  .. |PyPI Python Version| image:: https://img.shields.io/pypi/pyversions/esprima.svg
     :target: https://pypi.python.org/pypi/esprima
  .. |PyPI Implementation| image:: https://img.shields.io/pypi/implementation/esprima.svg
     :target: https://pypi.python.org/pypi/esprima
  .. |PyPI Status| image:: https://img.shields.io/pypi/status/esprima.svg
     :target: https://pypi.python.org/pypi/esprima
  .. |PyPI Downloads| image:: https://img.shields.io/pypi/dm/esprima.svg
     :target: https://pypi.python.org/pypi/esprima


pkgId: 2b662519a86f8768314cecfe4acb75e7270a5891255e069a44dac0658691725e
name: python-et-xmlfile
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: An implementation of lxml.xmlfile for the standard library
url: https://foss.heptapod.net/openpyxl/et_xmlfile
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-595c4486-df25-4215-a18f-afb0619ed0dc
location_href: 00003584-python-et_xmlfile/python-et-xmlfile-1.1.0-1.src.rpm
checksum_type: sha256
description:
  et_xmlfile is a low memory library for creating large XML files.
  It is based upon the `xmlfile module from lxml <http://lxml.de/api.html#incremental-xml-generation>`_ with the aim of allowing code to be developed that will work with both libraries. It was developed initially for the openpyxl project but is now a standalone module.
  The code was written by Elias Rabel as part of the `Python Düsseldorf <http://pyddf.de>`_ openpyxl sprint in September 2014.


pkgId: 2c271ef571648de455055ad35bd2f906b62d1921f97757b526125657f0ef4de3
name: python-etcd3gw
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: A python client for etcd3 grpc-gateway v3 API
url: https://docs.openstack.org/etcd3gw/latest/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f16469b8-2c85-444f-bf1c-f6a6a23e37a2
location_href: 00003586-python-etcd3gw/python-etcd3gw-2.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/dims/etcd3-gateway.svg?branch=master)](https://travis-ci.org/dims/etcd3-gateway)
  [![PyPI version](https://badge.fury.io/py/etcd3gw.svg)](https://badge.fury.io/py/etcd3gw)
  [![codecov](https://codecov.io/gh/dims/etcd3-gateway/branch/master/graph/badge.svg)](https://codecov.io/gh/dims/etcd3-gateway "Non-generated packages only")
  [![pypi status](https://img.shields.io/pypi/status/etcd3gw.svg)](https://pypi.python.org/pypi/etcd3gw)
  [![pypi supported versions](https://img.shields.io/pypi/pyversions/etcd3gw.svg)](https://pypi.python.org/pypi/etcd3gw)

  A python client for etcd3 grpc-gateway v3 API


pkgId: dd53b862a6081cab1251a79e46365dc0ce4f961d09ab7f15e55b377d025d6011
name: python-eth-hash
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: eth-hash: The Ethereum hashing function, keccak256, sometimes (erroneously) called sha3
url: https://github.com/ethereum/eth-hash
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-611508a2-b401-4428-a701-187e2bde83d9
location_href: 00010352-python-eth-hash/python-eth-hash-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![Join the chat at https://gitter.im/ethereum/web3.py](https://badges.gitter.im/ethereum/web3.py.svg)](https://gitter.im/ethereum/web3.py?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Build Status](https://circleci.com/gh/ethereum/eth-hash.svg?style=shield)](https://circleci.com/gh/ethereum/eth-hash)
  [![PyPI version](https://badge.fury.io/py/eth-hash.svg)](https://badge.fury.io/py/eth-hash)
  [![Python versions](https://img.shields.io/pypi/pyversions/eth-hash.svg)](https://pypi.python.org/pypi/eth-hash)
  [![Docs build](https://readthedocs.org/projects/eth-hash/badge/?version=latest)](http://eth-hash.readthedocs.io/en/latest/?badge=latest)


  The Ethereum hashing function, keccak256, sometimes (erroneously) called sha3

  Note: the similarly named [pyethash](https://github.com/ethereum/ethash)
  has a completely different use: it generates proofs of work.

  This is a low-level library, intended to be used internally by other Ethereum tools.
  If you're looking for a convenient hashing tool, check out
  [`eth_utils.keccak()`](https://eth-utils.readthedocs.io/en/stable/utilities.html#keccak-bytes-int-bool-text-str-hexstr-str-bytes)
  which will be a little friendlier, and provide access to other helpful utilities.

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




  ```sh
  pip install eth-hash[pycryptodome]
  ```

  ```py
  >>> from eth_hash.auto import keccak
  >>> keccak(b'')
  b"\xc5\xd2F\x01\x86\xf7#<\x92~}\xb2\xdc\xc7\x03\xc0\xe5\x00\xb6S\xca\x82';{\xfa\xd8\x04]\x85\xa4p"
  ```

  See the [docs](http://eth-hash.readthedocs.io/en/latest/quickstart.html#quickstart)
  for more about choosing and installing backends.



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

  - Testing
  - Pull Requests
  - Code Style
  - Documentation



  You can set up your dev environment with:

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



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

  Show flake8 errors on file change:

  ```sh

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

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

  ```sh

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

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

  Run in one thread, with color and desktop notifications:

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



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

  To release a new version:

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



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

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

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

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


pkgId: c7be360aa7bc70d0f64c36ce8059cf7b5d06ebf9b2fa4eba9cf70ec8a647d267
name: python-eth-keys
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Common API for Ethereum key operations.
url: https://github.com/ethereum/eth-keys
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f4a822a4-6dfd-4e56-91f8-4a4959233432
location_href: 00010572-python-eth-keys/python-eth-keys-0.4.0-1.src.rpm
checksum_type: sha256
description:
  A common API for Ethereum key operations with pluggable backends.


  > This library and repository was previously located at https://github.com/pipermerriam/ethereum-keys.  It was transferred to the Ethereum foundation github in November 2017 and renamed to `eth-keys`.  The PyPi package was also renamed from `ethereum-keys` to `eth-keys`.



  ```sh
  pip install eth-keys
  ```



  ```sh
  pip install -e .[dev]
  ```




  You can run the tests with:

  ```sh
  py.test tests
  ```

  Or you can install `tox` to run the full test suite.




  Pandoc is required for transforming the markdown README to the proper format to
  render correctly on pypi.

  For Debian-like systems:

  ```
  apt install pandoc
  ```

  Or on OSX:

  ```sh
  brew install pandoc
  ```

  To release a new version:

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




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

  To issue the next version in line, specify which part to bump,
  like `make release bump=minor` or `make release bump=devnum`.

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

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





  ```python
  >>> from eth_keys import keys
  >>> pk = keys.PrivateKey(b'\x01' * 32)
  >>> signature = pk.sign_msg(b'a message')
  >>> pk
  '0x0101010101010101010101010101010101010101010101010101010101010101'
  >>> pk.public_key
  '0x1b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f70beaf8f588b541507fed6a642c5ab42dfdf8120a7f639de5122d47a69a8e8d1'
  >>> signature
  '0xccda990dba7864b79dc49158fea269338a1cf5747bc4c4bf1b96823e31a0997e7d1e65c06c5bf128b7109e1b4b9ba8d1305dc33f32f624695b2fa8e02c12c1e000'
  >>> pk.public_key.to_checksum_address()
  '0x1a642f0E3c3aF545E7AcBD38b07251B3990914F1'
  >>> signature.verify_msg(b'a message', pk.public_key)
  True
  >>> signature.recover_public_key_from_msg(b'a message') == pk.public_key
  True
  ```






  The `KeyAPI` object is the primary API for interacting with the `eth-keys`
  libary.  The object takes a single optional argument in its constructor which
  designates what backend will be used for eliptical curve cryptography
  operations.  The built-in backends are:

  * `eth_keys.backends.NativeECCBackend`: A pure python implementation of the ECC operations.
  * `eth_keys.backends.CoinCurveECCBackend`: Uses the [`coincurve`](https://github.com/ofek/coincurve) library for ECC operations.

  By default, `eth-keys` will *try* to use the `CoinCurveECCBackend`,
  falling back to the `NativeECCBackend` if the `coincurve` library is not
  available.

  > Note: The `coincurve` library is not automatically installed with `eth-keys` and must be installed separately.

  The `backend` argument can be given in any of the following forms.

  * Instance of the backend class
  * The backend class
  * String with the dot-separated import path for the backend class.

  ```python
  >>> from eth_keys import KeyAPI
  >>> from eth_keys.backends import NativeECCBackend

  >>> keys = KeyAPI(NativeECCBackend)
  >>> keys = KeyAPI(NativeECCBackend())
  >>> keys = KeyAPI('eth_keys.backends.NativeECCBackend')

  >>> keys = KeyAPI('eth_keys.backends.CoinCurveECCBackend')
  ```

  The backend can also be configured using the environment variable
  `ECC_BACKEND_CLASS` which should be set to the dot-separated python import path
  to the desired backend.

  ```python
  >>> import os
  >>> os.environ['ECC_BACKEND_CLASS'] = 'eth_keys.backends.CoinCurveECCBackend'
  ```




  This method returns a signature for the given `message_hash`, signed by the
  provided `private_key`.

  * `message_hash`: **must** be a byte string of length 32
  * `private_key`: **must** be an instance of `PrivateKey`




  Returns `True` or `False` based on whether the provided `signature` is a valid
  signature for the provided `message_hash` and `public_key`.

  * `message_hash`: **must** be a byte string of length 32
  * `signature`: **must** be an instance of `Signature`
  * `public_key`: **must** be an instance of `PublicKey`




  Returns the `PublicKey` instances recovered from the given `signature` and
  `message_hash`.

  * `message_hash`: **must** be a byte string of length 32
  * `signature`: **must** be an instance of `Signature`




  Returns the `PublicKey` instances computed from the given `private_key`
  instance.

  * `private_key`: **must** be an instance of `PublicKey`




  There is a common API for the following objects.

  * `PublicKey`
  * `PrivateKey`
  * `Signature`

  Each of these objects has all of the following APIs.

  * `obj.to_bytes()`: Returns the object in it's canonical `bytes` serialization.
  * `obj.to_hex()`: Returns a text string of the hex encoded canonical representation.




  The `PublicKey` class takes a single argument which must be a bytes string with length 64.

  > Note that there are two other common formats for public keys: 65 bytes with a leading `\x04` byte
  > and 33 bytes starting with either `\x02` or `\x03`. To use the former with the `PublicKey` object,
  > remove the first byte. For the latter, refer to `PublicKey.from_compressed_bytes`.

  The following methods are available:




  This `classmethod` returns a new `PublicKey` instance computed from its compressed representation.

  * `compressed_bytes` **must** be a byte string of length 33 starting with `\x02` or `\x03`.




  This `classmethod` returns a new `PublicKey` instance computed from the
  given `private_key`.

  * `private_key` may either be a byte string of length 32 or an instance of the `KeyAPI.PrivateKey` class.




  This `classmethod` returns a new `PublicKey` instance computed from the
  provided `message` and `signature`.

  * `message` **must** be a byte string
  * `signature` **must** be an instance of `KeyAPI.Signature`




  Same as `PublicKey.recover_from_msg` except that `message_hash` should be the Keccak
  hash of the `message`.




  This method returns `True` or `False` based on whether the signature is a valid
  for the given message.




  Same as `PublicKey.verify_msg` except that `message_hash` should be the Keccak
  hash of the `message`.




  Returns the compressed representation of this public key.




  Returns the hex encoded ethereum address for this public key.




  Returns the ERC55 checksum formatted ethereum address for this public key.




  Returns the 20-byte representation of the ethereum address for this public key.




  The `PrivateKey` class takes a single argument which must be a bytes string with length 32.

  The following methods and properties are available




  This *property* holds the `PublicKey` instance coresponding to this private key.




  This method returns a signature for the given `message` in the form of a
  `Signature` instance

  * `message` **must** be a byte string.




  Same as `PrivateKey.sign` except that `message_hash` should be the Keccak
  hash of the `message`.




  The `Signature` class can be instantiated in one of two ways.

  * `signature_bytes`: a bytes string with length 65.
  * `vrs`: a 3-tuple composed of the integers `v`, `r`, and `s`.

  > Note: If using the `signature_bytes` to instantiate, the byte string should be encoded as `r_bytes | s_bytes | v_bytes` where `|` represents concatenation.  `r_bytes` and `s_bytes` should be 32 bytes in length.  `v_bytes` should be a single byte `\x00` or `\x01`.

  Signatures are expected to use `1` or `0` for their `v` value.

  The following methods and properties are available




  This property returns the `v` value from the signature as an integer.




  This property returns the `r` value from the signature as an integer.




  This property returns the `s` value from the signature as an integer.




  This property returns a 3-tuple of `(v, r, s)`.




  This method returns `True` or `False` based on whether the signature is a valid
  for the given public key.

  * `message`: **must** be a byte string.
  * `public_key`: **must** be an instance of `PublicKey`




  Same as `Signature.verify_msg` except that `message_hash` should be the Keccak
  hash of the `message`.




  This method returns a `PublicKey` instance recovered from the signature.

  * `message`: **must** be a byte string.




  Same as `Signature.recover_public_key_from_msg` except that `message_hash`
  should be the Keccak hash of the `message`.






  This error is raised during instantaition of any of the `PublicKey`,
  `PrivateKey` or `Signature` classes if their constructor parameters are
  invalid.




  This error is raised from any of the `recover` or `verify` methods involving
  signatures if the signature is invalid.


pkgId: 20bced2fdcbd3754f212402a46cb60d896fd1b2b4f5df894926961fce33e4f49
name: python-eth-rlp
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: eth-rlp: RLP definitions for common Ethereum objects in Python
url: https://github.com/ethereum/eth-rlp
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c99e45c7-38ed-45c6-a584-044c8a70895f
location_href: 00010682-python-eth-rlp/python-eth-rlp-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Join the chat at https://gitter.im/ethereum/eth-rlp](https://badges.gitter.im/ethereum/eth-rlp.svg)](https://gitter.im/ethereum/eth-rlp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Build Status](https://circleci.com/gh/ethereum/eth-rlp.svg?style=shield)](https://circleci.com/gh/ethereum/eth-rlp)
  [![PyPI version](https://badge.fury.io/py/eth-rlp.svg)](https://badge.fury.io/py/eth-rlp)
  [![Python versions](https://img.shields.io/pypi/pyversions/eth-rlp.svg)](https://pypi.python.org/pypi/eth-rlp)
  [![Docs build](https://readthedocs.org/projects/eth-rlp/badge/?version=latest)](http://eth-rlp.readthedocs.io/en/latest/?badge=latest)


  RLP definitions for common Ethereum objects in Python

  Read more in the [documentation on ReadTheDocs](http://eth-rlp.readthedocs.io/). [View the change log](http://eth-rlp.readthedocs.io/en/latest/release_notes.html).



  ```sh
  pip install eth-rlp
  ```



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

  - Testing
  - Pull Requests
  - Code Style
  - Documentation



  You can set up your dev environment with:

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



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

  Show flake8 errors on file change:

  ```sh

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

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

  ```sh

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

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

  Run in one thread, with color and desktop notifications:

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



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

  To release a new version:

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



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

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

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

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


pkgId: 6416453e53767dbc201de73d7741025a332fd267b777f7fc12df3f69c86e3342
name: python-eth-utils
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: eth-utils: Common utility functions for python code that interacts with Ethereum
url: https://github.com/ethereum/eth-utils
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bc83ac81-76fd-4091-b40a-2464ca7c3c09
location_href: 00010375-python-eth-utils/python-eth-utils-2.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Join the chat at https://gitter.im/ethereum/eth-utils](https://badges.gitter.im/ethereum/eth-utils.svg)](https://gitter.im/ethereum/eth-utils?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Build Status](https://circleci.com/gh/ethereum/eth-utils.svg?style=shield)](https://circleci.com/gh/ethereum/eth-utils)
  [![PyPI version](https://badge.fury.io/py/eth-utils.svg)](https://badge.fury.io/py/eth-utils)
  [![Python versions](https://img.shields.io/pypi/pyversions/eth-utils.svg)](https://pypi.python.org/pypi/eth-utils)
  [![Docs build](https://readthedocs.org/projects/eth-utils/badge/?version=latest)](http://eth-utils.readthedocs.io/en/latest/?badge=latest)


  Common utility functions for python code that interacts with Ethereum

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



  ```sh
  pip install eth-utils
  ```



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

  - Testing
  - Pull Requests
  - Code Style
  - Documentation



  You can set up your dev environment with:

  ```sh
  git clone git@github.com:ethereum/eth-utils.git
  cd eth-utils
  virtualenv -p python3 venv
  . venv/bin/activate
  pip install -e .[dev]
  pip install -e eth-hash[pycryptodome]
  ```



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

  Show flake8 errors on file change:

  ```sh

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

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

  ```sh

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

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

  Run in one thread, with color and desktop notifications:

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



  To release a new version:

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



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

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

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

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


pkgId: 8e8ba87a9518c413c828d904b780ddbb28b6a6fafaba01cc5c070569070e3e1c
name: python-event-tracking
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: A simple event tracking system.
url: https://github.com/edx/event-tracking
rpm_license: AGPLv3 License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7458be2b-98f8-4981-af43-ee56e58a403f
location_href: 00013458-python-event-tracking/python-event-tracking-2.1.0-1.src.rpm
checksum_type: sha256
description:
  The ``event-tracking`` library tracks context-aware semi-structured system events.
  It captures and stores events with nested data structures in order to truly
  take advantage of schemaless data storage systems.
  Key features:
  * Multiple backends - define custom backends that can be used to persist
    your event data.
  * Nested contexts - allows data to be injected into events even without
    having to pass around all of said data to every location where the events
    are emitted.
  * Django integration - provides a Django app that allows context aware events
    to easily be captured by multi-threaded web applications.
  * MongoDB integration - support writing events out to a mongo collection.
  Example::
      from eventtracking import tracker
      tracker = tracker.get_tracker()
      tracker.enter_context('outer', {'user_id': 10938})
      tracker.emit('navigation.request', {'url': 'http://www.edx.org/some/path/1'})
      with tracker.context({'user_id': 11111, 'session_id': '2987lkjdyoioey'}):
          tracker.emit('navigation.request', {'url': 'http://www.edx.org/some/path/2'})
      tracker.emit(
          'address.create',
          {
              'name': 'foo',
              'address': {
                  'postal_code': '90210',
                  'country': 'United States'
              }
          }
      )
  Running the above example produces the following events::
      {
          "name": "navigation.request",
          "timestamp": ...,
          "context": {
              "user_id": 10938
          },
          "data": {
              "url": "http://www.edx.org/some/path/1"
          }
      },
      {
          "name": "navigation.request",
          "timestamp": ...,
          "context": {
              "user_id": 11111,
              "session_id": "2987lkjdyoioey"
          },
          "data": {
              "url": "http://www.edx.org/some/path/2"
          }
      },
      {
          "name": "address.create",
          "timestamp": ...,
          "context": {
              "user_id": 10938
          },
          "data": {
              "name": "foo",
              "address": {
                  "postal_code": "90210",
                  "country": "United States"
              }
          }
      }


pkgId: 9ea4401b720b6b949362ec34339ccc575d5473f95464d121c8ba8bdf58e7b545
name: python-eventlet
arch: src
version: 0.33.3
epoch: 0
release: 1
summary: Highly concurrent networking library
url: http://eventlet.net
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-09740746-297a-44c8-b71d-ca75f03e8db3
location_href: 00003587-python-eventlet/python-eventlet-0.33.3-1.src.rpm
checksum_type: sha256
description:
  Here's something you can try right on the command line::
      % python3
      >>> import eventlet
      >>> from eventlet.green.urllib.request import urlopen
      >>> gt = eventlet.spawn(urlopen, 'http://eventlet.net')
      >>> gt2 = eventlet.spawn(urlopen, 'http://secondlife.com')
      >>> gt2.wait()
      >>> gt.wait()


pkgId: b45bd9c3b8f631499e590c4f94e7f03fbeb9a779ba1c6d009b39dc023e929de0
name: python-executing
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Get the currently executing AST node of a frame, and other information
url: https://github.com/alexmojaki/executing
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc604130-ac07-45cc-9bd6-432c9bced410
location_href: 00010635-python-executing/python-executing-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/alexmojaki/executing/workflows/Tests/badge.svg?branch=master)](https://github.com/alexmojaki/executing/actions) [![Coverage Status](https://coveralls.io/repos/github/alexmojaki/executing/badge.svg?branch=master)](https://coveralls.io/github/alexmojaki/executing?branch=master) [![Supports Python versions 2.7 and 3.5+, including PyPy](https://img.shields.io/pypi/pyversions/executing.svg)](https://pypi.python.org/pypi/executing)

  This mini-package lets you get information about what a frame is currently doing, particularly the AST node being executed.

  * [Usage](#usage)
      * [Getting the AST node](#getting-the-ast-node)
      * [Getting the source code of the node](#getting-the-source-code-of-the-node)
      * [Getting the `__qualname__` of the current function](#getting-the-__qualname__-of-the-current-function)
      * [The Source class](#the-source-class)
  * [Installation](#installation)
  * [How does it work?](#how-does-it-work)
  * [Is it reliable?](#is-it-reliable)
  * [Which nodes can it identify?](#which-nodes-can-it-identify)
  * [Libraries that use this](#libraries-that-use-this)





  ```python
  import executing

  node = executing.Source.executing(frame).node
  ```

  Then `node` will be an AST node (from the `ast` standard library module) or None if the node couldn't be identified (which may happen often and should always be checked).

  `node` will always be the same instance for multiple calls with frames at the same point of execution.

  If you have a traceback object, pass it directly to `Source.executing()` rather than the `tb_frame` attribute to get the correct node.



  For this you will need to separately install the [`asttokens`](https://github.com/gristlabs/asttokens) library, then obtain an `ASTTokens` object:

  ```python
  executing.Source.executing(frame).source.asttokens()
  ```

  or:

  ```python
  executing.Source.for_frame(frame).asttokens()
  ```

  or use one of the convenience methods:

  ```python
  executing.Source.executing(frame).text()
  executing.Source.executing(frame).text_range()
  ```



  ```python
  executing.Source.executing(frame).code_qualname()
  ```

  or:

  ```python
  executing.Source.for_frame(frame).code_qualname(frame.f_code)
  ```



  Everything goes through the `Source` class. Only one instance of the class is created for each filename. Subclassing it to add more attributes on creation or methods is recommended. The classmethods such as `executing` will respect this. See the source code and docstrings for more detail.



      pip install executing

  If you don't like that you can just copy the file `executing.py`, there are no dependencies (but of course you won't get updates).



  Suppose the frame is executing this line:

  ```python
  self.foo(bar.x)
  ```

  and in particular it's currently obtaining the attribute `self.foo`. Looking at the bytecode, specifically `frame.f_code.co_code[frame.f_lasti]`, we can tell that it's loading an attribute, but it's not obvious which one. We can narrow down the statement being executed using `frame.f_lineno` and find the two `ast.Attribute` nodes representing `self.foo` and `bar.x`. How do we find out which one it is, without recreating the entire compiler in Python?

  The trick is to modify the AST slightly for each candidate expression and observe the changes in the bytecode instructions. We change the AST to this:

  ```python
  (self.foo ** 'longuniqueconstant')(bar.x)
  ```

  and compile it, and the bytecode will be almost the same but there will be two new instructions:

      LOAD_CONST 'longuniqueconstant'
      BINARY_POWER

  and just before that will be a `LOAD_ATTR` instruction corresponding to `self.foo`. Seeing that it's in the same position as the original instruction lets us know we've found our match.



  Yes - if it identifies a node, you can trust that it's identified the correct one. The tests are very thorough - in addition to unit tests which check various situations directly, there are property tests against a large number of files (see the filenames printed in [this build](https://travis-ci.org/alexmojaki/executing/jobs/557970457)) with real code. Specifically, for each file, the tests:

   1. Identify as many nodes as possible from all the bytecode instructions in the file, and assert that they are all distinct
   2. Find all the nodes that should be identifiable, and assert that they were indeed identified somewhere

  In other words, it shows that there is a one-to-one mapping between the nodes and the instructions that can be handled. This leaves very little room for a bug to creep in.

  Furthermore, `executing` checks that the instructions compiled from the modified AST exactly match the original code save for a few small known exceptions. This accounts for all the quirks and optimisations in the interpreter.



  Currently it works in almost all cases for the following `ast` nodes:

   - `Call`, e.g. `self.foo(bar)`
   - `Attribute`, e.g. `point.x`
   - `Subscript`, e.g. `lst[1]`
   - `BinOp`, e.g. `x + y` (doesn't include `and` and `or`)
   - `UnaryOp`, e.g. `-n` (includes `not` but only works sometimes)
   - `Compare` e.g. `a < b` (not for chains such as `0 < p < 1`)

  The plan is to extend to more operations in the future.





  - **[`stack_data`](https://github.com/alexmojaki/stack_data)**: Extracts data from stack frames and tracebacks, particularly to display more useful tracebacks than the default. Also uses another related library of mine: **[`pure_eval`](https://github.com/alexmojaki/pure_eval)**.
  - **[`futurecoder`](https://futurecoder.io/)**: Highlights the executing node in tracebacks using `executing` via `stack_data`, and provides debugging with `snoop`.
  - **[`snoop`](https://github.com/alexmojaki/snoop)**: A feature-rich and convenient debugging library. Uses `executing` to show the operation which caused an exception and to allow the `pp` function to display the source of its arguments.
  - **[`heartrate`](https://github.com/alexmojaki/heartrate)**: A simple real time visualisation of the execution of a Python program. Uses `executing` to highlight currently executing operations, particularly in each frame of the stack trace.
  - **[`sorcery`](https://github.com/alexmojaki/sorcery)**: Dark magic delights in Python. Uses `executing` to let special callables called spells know where they're being called from.



  - **[`IPython`](https://github.com/ipython/ipython/pull/12150)**: Highlights the executing node in tracebacks using `executing` via [`stack_data`](https://github.com/alexmojaki/stack_data).
  - **[`icecream`](https://github.com/gruns/icecream)**: 🍦 Sweet and creamy print debugging. Uses `executing` to identify where `ic` is called and print its arguments.
  - **[`friendly_traceback`](https://github.com/friendly-traceback/friendly-traceback)**: Uses `stack_data` and `executing` to pinpoint the cause of errors and provide helpful explanations.
  - **[`python-devtools`](https://github.com/samuelcolvin/python-devtools)**: Uses `executing` for print debugging similar to `icecream`.
  - **[`sentry_sdk`](https://github.com/getsentry/sentry-python)**: Add the integration `sentry_sdk.integrations.executingExecutingIntegration()` to show the function `__qualname__` in each frame in sentry events.
  - **[`varname`](https://github.com/pwwang/python-varname)**: Dark magics about variable names in python. Uses `executing` to find where its various magical functions like `varname` and `nameof` are called from.


pkgId: d93b06f95c643fb7fb7643cd564c04a45208eae1e7d01e3419914e669daa1f2e
name: python-executor
arch: src
version: 23.2
epoch: 0
release: 1
summary: Programmer friendly subprocess wrapper
url: https://executor.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddfd3399-0e41-4494-8f2b-4398b851b134
location_href: 00013216-python-executor/python-executor-23.2-1.src.rpm
checksum_type: sha256
description:
  The `executor` package is a simple wrapper for Python's subprocess_ module
  that makes it very easy to handle subprocesses on UNIX systems with proper
  escaping of arguments and error checking:
  - An object oriented interface is used to execute commands using sane but
    customizable (and well documented) defaults.
  - Remote commands (executed over SSH_) are supported using the same object
    oriented interface, as are commands inside chroots_ (executed using
    schroot_).
  - There's also support for executing a group of commands concurrently in
    what's called a "command pool". The concurrency level can be customized and
    of course both local and remote commands are supported.
  The package is currently tested on Python 2.7, 3.5, 3.6, 3.7, 3.8 and PyPy. For
  usage instructions please refer to following sections and the documentation_.


pkgId: f7cf0b0e43ba96ca4932c3f990d75c5c62e45b6c49df526f9ea28adb1bb84468
name: python-exif
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Read and modify image EXIF metadata using Python.
url: https://gitlab.com/TNThieding/exif
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-17b77604-b9a7-40f4-922c-d36f11ae0dde
location_href: 00003592-python-exif/python-exif-1.6.0-1.src.rpm
checksum_type: sha256
description:
  [exif] Package


  .. image:: https://www.gitlab.com/TNThieding/exif/badges/master/pipeline.svg
      :target: https://gitlab.com/TNThieding/exif

  .. image:: https://www.gitlab.com/tnthieding/exif/badges/master/coverage.svg
      :target: https://gitlab.com/TNThieding/exif

  .. image:: https://readthedocs.org/projects/exif/badge/?version=latest
      :target: https://exif.readthedocs.io/en/latest/?badge=latest
      :alt: Documentation Status

  .. image:: https://img.shields.io/badge/code%20style-black-000000.svg
      :target: https://github.com/psf/black

  .. image:: http://www.mypy-lang.org/static/mypy_badge.svg
      :target: http://mypy-lang.org/
      :alt: Checked with mypy

  Read and modify image EXIF metadata using Python without any third-party software
  dependencies. For example, batch process image metadata using a Python script.

  .. note::

      I developed this package in 2018 as a hobby; however, I no longer have the same bandwidth
      to work on this project. As always, contributions and bug fixes are welcome and appreciated.
      If this package does not suit your needs in its current form, I encourage you to investigate
      alternative packages such as piexif_, Pillow_, or the like.

      .. _piexif: https://pypi.org/project/piexif/
      .. _Pillow: https://pypi.org/project/Pillow/

  ***********
  Quick Start
  ***********

  Open an image with EXIF metadata using the Python ``open()`` built-in function. Ensure the
  binary mode flag is set. Pass this image file object into the ``exif.Image`` class::

      >>> from exif import Image
      >>> with open('grand_canyon.jpg', 'rb') as image_file:
      ...     my_image = Image(image_file)
      ...
      >>> my_image.has_exif
      True

  List EXIF attributes using the ``list_all()`` method::

      >>> my_image.list_all()
      ['_exif_ifd_pointer', '_gps_ifd_pointer', 'aperture_value', 'brightness_value', 'color_space',
       'components_configuration', 'compression', 'datetime', 'datetime_digitized', 'datetime_original', 'exif_version',
       'exposure_bias_value', 'exposure_mode', 'exposure_program', 'exposure_time', 'f_number', 'flash',
       'flashpix_version', 'focal_length', 'focal_length_in_35mm_film', 'gps_altitude', 'gps_altitude_ref',
       'gps_datestamp', 'gps_dest_bearing', 'gps_dest_bearing_ref', 'gps_horizontal_positioning_error',
       'gps_img_direction', 'gps_img_direction_ref', 'gps_latitude', 'gps_latitude_ref', 'gps_longitude',
       'gps_longitude_ref', 'gps_speed', 'gps_speed_ref', 'gps_timestamp', 'jpeg_interchange_format',
       'jpeg_interchange_format_length', 'lens_make', 'lens_model', 'lens_specification', 'make', 'maker_note',
       'metering_mode', 'model', 'orientation', 'photographic_sensitivity', 'pixel_x_dimension', 'pixel_y_dimension',
       'resolution_unit', 'scene_capture_type', 'scene_type', 'sensing_method', 'shutter_speed_value', 'software',
       'subject_area', 'subsec_time_digitized', 'subsec_time_original', 'white_balance', 'x_resolution',
       'y_and_c_positioning', 'y_resolution']

  Access EXIF metadata tags using Python attribute notation::

      >>> # Read tags with Python "get" notation.
      >>> my_image.gps_latitude
      (36.0, 3.0, 11.08)
      >>> my_image.gps_longitude
      (112.0, 5.0, 4.18)
      >>> my_image.model
      'iPhone 7'
      >>>
      >>> # Modify tags with Python "set" notation.
      >>> my_image.make = "Python"
      >>>
      >>> # Delete tags with Python "del" notation.
      >>> del my_image.gps_latitude
      >>> del my_image.gps_longitude
      >>>
      >>> # Add new tags with Python "set" notation.
      >>> from exif import LightSource
      >>> my_image.light_source = LightSource.DAYLIGHT

  Write the image with modified EXIF metadata to an image file using ``open()`` in binary
  write mode::

      >>> with open('modified_image.jpg', 'wb') as new_image_file:
      ...     new_image_file.write(my_image.get_file())
      ...

  Refer to the `usage page <https://exif.readthedocs.io/en/latest/usage.html>`_ for information and examples of alternative ways to access EXIF tags (e.g.
  with index/item syntax or with methods).


pkgId: a8a624a497a4d2498c0ab9526d0cf438b5614b6e2f3db01e428c664eba14352f
name: python-exiv2
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: Python interface to libexiv2
url: https://github.com/jim-easterbrook/python-exiv2
rpm_license: GNU GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e267b568-3586-4a13-8fa1-c801d13ba9e1
location_href: 00003593-python-exiv2/python-exiv2-0.13.2-1.src.rpm
checksum_type: sha256
description:
  python-exiv2 is a low level interface (or binding) to the exiv2_ C++ library.
  It is built using SWIG_ to automatically generate the interface code.
  The intention is to give direct access to all of the top-level classes in libexiv2_, but with additional "Pythonic" helpers where necessary.
  Not everything in libexiv2 is available in the Python interface.
  If you need something that's not there, please let me know.
  This project has taken over the PyPI exiv2 package created by Michael Vanslembrouck.
  If you need to use Michael's project, it is available at https://bitbucket.org/zmic/exiv2-python/src/master/ and can be installed with pip_::
      pip install exiv2==0.3.1


pkgId: b3380e1a1482ea4e996d2f3bd0f4d8450f259daa07fd8025783d29a76f0f16e9
name: python-expandvars
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Expand system variables Unix style
url: https://github.com/sayanarijit/expandvars
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5c59ae40-5b15-46a4-adfd-111fa1b4a44e
location_href: 00010118-python-expandvars/python-expandvars-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Expand system variables Unix style
  [![PyPI version](https://img.shields.io/pypi/v/expandvars.svg)](https://pypi.org/project/expandvars)
  [![codecov](https://codecov.io/gh/sayanarijit/expandvars/branch/master/graph/badge.svg)](https://codecov.io/gh/sayanarijit/expandvars)


pkgId: aaf8187c5b117c183d801ec7b65c86f7645a372218a77d0df64f514a7742404c
name: python-expecttest
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/ezyang/expecttest
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-48896601-ca15-4b4e-b1e1-1a3ff1e266c4
location_href: 00010722-python-expecttest/python-expecttest-0.1.4-1.src.rpm
checksum_type: sha256
description:
  This library implements expect tests (also known as "golden" tests). Expect
  tests are a method of writing tests where instead of hard-coding the expected
  output of a test, you run the test to get the output, and the test framework
  automatically populates the expected output.  If the output of the test changes,
  you can rerun the test with the environment variable `EXPECTTEST_ACCEPT=1` to
  automatically update the expected output.

  Somewhat unusually, this library implements *inline* expect tests: that is to
  say, the expected output isn't saved to an external file, it is saved directly
  in the Python file (and we modify your Python file when updating the expect
  test.)

  The general recipe for how to use this is as follows:

    1. Write your test and use `assertExpectedInline()` instead of a normal
       `assertEqual`.  Leave the expected argument blank with an empty string:
       ```py
       self.assertExpectedInline(some_func(), "")
       ```

    2. Run your test.  It should fail, and you get an error message about
       accepting the output with `EXPECTTEST_ACCEPT=1`

    3. Rerun the test with `EXPECTTEST_ACCEPT=1`.  Now the previously blank string
       literal will contain the expected value of the test.
       ```py
       self.assertExpectedInline(some_func(), "my_value")
       ```

  Some tips and tricks:

    - Often, you will want to expect test on a multiline string.  This framework
      understands triple-quoted strings, so you can just write `"""my_value"""`
      and it will turn into triple-quoted strings.

    - Take some time thinking about how exactly you want to design the output
      format of the expect test.  It is often profitable to design an output
      representation specifically for expect tests.


pkgId: ab2dec973b5787097f9e9460d17358e50ee767e2e9533ea3bb817a11b331e6de
name: python-expiringdict
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Dictionary with auto-expiring values for caching purposes
url: https://www.mailgun.com/
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bce9d234-3820-43d0-8c8c-052a2747caf9
location_href: 00009631-python-expiringdict/python-expiringdict-1.2.2-1.src.rpm
checksum_type: sha256
description:
  ChangeLog_
  expiringdict is a Python caching library. The core of the library is ExpiringDict class which
  is an ordered dictionary with auto-expiring values for caching purposes. Expiration happens on
  any access, object is locked during cleanup from expired values. ExpiringDict can not store
  more than `max_len` elements - the oldest will be deleted.
  **Note:** Iteration over dict and also keys() do not remove expired values!


pkgId: 3245956cc836d3c7c14f07befe5d36350382851c67d183092716c57b73e43db0
name: python-exrex
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Irregular methods for regular expressions
url: https://github.com/asciimoo/exrex
rpm_license: AGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d218628-c976-4102-8a9f-e8975d80d01e
location_href: 00013075-python-exrex/python-exrex-0.11.0-1.src.rpm
checksum_type: sha256
description:
  Irregular methods for regular expressions.
  Exrex is a command line tool and python module that generates all - or random - matching strings to a given regular expression and more.
  It's pure python, without external dependencies.
  There are regular expressions with infinite matching strings (eg.: `[a-z]+`), in these cases exrex limits the maximum length of the infinite parts.
  Exrex uses generators, so the memory usage does not depend on the number of matching strings.
  [![Version](https://img.shields.io/pypi/v/exrex.svg)](https://crate.io/packages/exrex/)   [![Downloads](https://img.shields.io/pypi/dm/exrex.svg)](https://crate.io/packages/exrex/)
  *Features*
   * Generating all matching strings
   * Generating a random matching string
   * Counting the number of matching strings
   * Simplification of regular expressions

  To install exrex, simply:
  ```bash
  $ pip install exrex
  ```
  or
  ```bash
  $ easy_install exrex
  ```


pkgId: d253af348a19a86e5e6e9c69208617866ffcd14376b951c367fd86e1a11d7137
name: python-extension-helpers
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Utilities for building and installing packages with compiled extensions
url: https://github.com/astropy/extension-helpers
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc66932d-a4c0-423b-8de0-0226d863f3a4
location_href: 00003594-python-extension-helpers/python-extension-helpers-1.0.0-1.src.rpm
checksum_type: sha256
description:
  The **extension-helpers** package includes convenience helpers to assist with
  building Python packages with compiled C/Cython extensions. It is developed by
  the Astropy project but is intended to be general and usable by any Python
  package.
  For more information, see the documentation at http://extension-helpers.readthedocs.io


pkgId: 2c8e455f67f5c272e40a81f3644eceeb200998c1f24b864bf0877803b52f825d
name: python-fab-classic
arch: src
version: 1.19.2
epoch: 0
release: 1
summary: fab-classic is a simple, Pythonic tool for remote execution and deployment.
url: https://github.com/ploxiln/fab-classic
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-69e19651-a57a-414f-90e7-04d7216cf46c
location_href: 00010291-python-fab-classic/python-fab-classic-1.19.2-1.src.rpm
checksum_type: sha256
description:
  fab-classic is `on PyPI <https://pypi.org/project/fab-classic/>`_,
  so you can ``pip install fab-classic``
  Be sure to ``pip uninstall fabric`` first if you happen to have it installed,
  because *fab-classic* uses the same import name "fabric" and entrypoint (tool)
  name "fab".
  Starting with version 1.16, *fab-classic* depends on
  `paramiko-ng <https://github.com/ploxiln/paramiko-ng/>`_ instead of
  `paramiko <https://github.com/paramiko/paramiko/>`_. Both of those packages
  are imported with the name ``paramiko``, and unfortunately that means that you
  should make sure you uninstall *paramiko* before *paramiko-ng* is installed,
  or you will get strange issues (even if things seem to work at first).
  Starting with version 1.18, you can switch back to depending on the package
  named *paramiko* by setting the environment variable ``PARAMIKO_REPLACE=1``
  while installing *fab-classic*::
      PARAMIKO_REPLACE=1 pip install --no-binary fab-classic fab-classic==1.18.0
  (*paramiko-ng* also supports ``PARAMIKO_REPLACE``,
  see `paramiko-ng#installation <https://github.com/ploxiln/paramiko-ng/#installation>`_)


pkgId: 9de2e2db09f1ae0d1840c72e7df5ee441167ac08db7725016d279bc001b36e1b
name: python-fabric
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: High level SSH command execution
url: https://fabfile.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b7dbae5-5a07-4f98-bce1-7d267e7418f2
location_href: 00009609-python-fabric/python-fabric-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Fabric is a high level Python (2.7, 3.4+) library designed to execute shell
  commands remotely over SSH, yielding useful Python objects in return. It builds
  on top of `Invoke <https://pyinvoke.org>`_ (subprocess command execution and
  command-line features) and `Paramiko <https://paramiko.org>`_ (SSH protocol
  implementation), extending their APIs to complement one another and provide
  additional functionality.
  To find out what's new in this version of Fabric, please see `the changelog
  <https://fabfile.org/changelog.html#{}>`_.
  The project maintainer keeps a `roadmap
  <https://bitprophet.org/projects#roadmap>`_ on his website.


pkgId: 9cc32adc672dbb01a427f272dd09174862c7981475751de54cd32cffabf09130
name: python-face
arch: src
version: 22.0.0
epoch: 0
release: 1
description:
  A command-line interface parser and framework, friendly for users,
  full-featured for developers.

url: https://github.com/mahmoud/face
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a83e1b98-e3b8-48b5-96fd-4e92b1252be5
location_href: 00010024-python-face/python-face-22.0.0-1.src.rpm
checksum_type: sha256
summary:
  A command-line application framework (and CLI parser). Friendly for users, full-featured for developers.


pkgId: 6ca188d5124efff8ebbe9611cf1d5c72f53c4894625b458e607213d91de07586
name: python-face_recognition_models
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Models used by the face_recognition package.
url: https://github.com/ageitgey/face_recognition_models
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b19d86b-69a2-4803-9bb8-a70bff2a5d18
location_href: 00013079-python-face-recognition-models/python-face_recognition_models-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This package contains only the models used by `face_recognition <https://github.com/ageitgey/face_recognition>`__.
  See  `face_recognition <https://github.com/ageitgey/face_recognition>`__ for more information.
  These models were created by `Davis King <https://github.com/davisking/dlib-models>`__ and are licensed in the public domain
  or under CC0 1.0 Universal. See LICENSE.


pkgId: 61dcee71faf1fe42e7c1be41579e5253edf7caea30c62c023b75480b28bf2d82
name: python-facebook-sdk
arch: src
version: 3.1.0
epoch: 0
release: 1
url: https://github.com/mobolic/facebook-sdk
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d6e6447d-cb1e-44d2-9451-c7b224078e7e
location_href: 00011411-python-facebook-sdk/python-facebook-sdk-3.1.0-1.src.rpm
checksum_type: sha256
summary:
  This client library is designed to support the Facebook Graph API and the official Facebook JavaScript SDK, which is the canonical way to implement Facebook authentication.


pkgId: 6d3af64a788b174956db504ff7fafa2483e9c8fdff4222395be5a58e0f90afac
name: python-fake-factory
arch: src
version: 9999.9.9
epoch: 0
release: 1
summary: The `fake-factory` package was deprecated on December 15th, 2016. Use the `Faker` package instead.
url: https://github.com/joke2k/faker
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-596dd49d-be7a-460b-85d0-6703a8456ae9
location_href: 00011681-python-fake-factory/python-fake-factory-9999.9.9-1.src.rpm
checksum_type: sha256
description:
  ERROR:
      The `fake-factory` package was deprecated on December 15th, 2016.
      Use the `Faker` package instead.


pkgId: af9f7f7ccdf244fba6ee31ac2e99e6625b62d2338c94087d55829644d9efe046
name: python-falcon
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: The ultra-reliable, fast ASGI+WSGI framework for building data plane APIs at scale.
url: https://falconframework.org
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1b9ee6b6-dfba-47d8-8aa5-9e8493f29d08
location_href: 00003600-python-falcon/python-falcon-3.1.1-1.src.rpm
checksum_type: sha256
description:
  `Falcon <https://falconframework.org>`__ is a minimalist ASGI/WSGI framework for
  building mission-critical REST APIs and microservices, with a focus on
  reliability, correctness, and performance at scale.
  When it comes to building HTTP APIs, other frameworks weigh you down with tons
  of dependencies and unnecessary abstractions. Falcon cuts to the chase with a
  clean design that embraces HTTP and the REST architectural style.
  Falcon apps work with any `WSGI <https://www.python.org/dev/peps/pep-3333/>`_
  or `ASGI <https://asgi.readthedocs.io/en/latest/>`_ server, and run like a
  champ under CPython 3.5+ and PyPy 3.5+ (3.6+ required for ASGI).


pkgId: d60e1b01247ce621f39a28d1e30bb294a5e5db73eaa8f28e7e568068800342c5
name: python-fasjson-client
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: An OpenAPI client for FASJSON
url: https://github.com/fedora-infra/fasjson-client
rpm_license: LGPL-3.0-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5c0030a7-e627-4404-90b4-10330d40652c
location_href: 00003601-python-fasjson-client/python-fasjson-client-1.0.7-1.src.rpm
checksum_type: sha256
description:
  A python client library for the FASJSON API

  This client uses the bravado library to build dynamic api methods based on open-api specs (version 2.0): https://github.com/Yelp/bravado

  The documentation is available at https://fasjson-client.readthedocs.io/



  Licensed under [lgpl-3.0](./LICENSE)


pkgId: bb383112bf7fdbb2bab700553082aa7e582be3bf93ddf67dfb1e64b88df4afc2
name: python-fastai
arch: src
version: 2.7.12
epoch: 0
release: 1
summary: fastai simplifies training fast and accurate neural nets using modern best practices
url: https://github.com/fastai/fastai
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c830a8e-0419-4bf9-a422-4eeb4db03729
location_href: 00010076-python-fastai/python-fastai-2.7.12-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
  ![CI](https://github.com/fastai/fastai/workflows/CI/badge.svg)
  [![PyPI](https://img.shields.io/pypi/v/fastai?color=blue&label=pypi%20version.png)](https://pypi.org/project/fastai/#description)
  [![Conda (channel
  only)](https://img.shields.io/conda/vn/fastai/fastai?color=seagreen&label=conda%20version.png)](https://anaconda.org/fastai/fastai)
  [![Build fastai
  images](https://github.com/fastai/docker-containers/workflows/Build%20fastai%20images/badge.svg)](https://github.com/fastai/docker-containers)
  ![docs](https://github.com/fastai/fastai/workflows/docs/badge.svg)

  You can use fastai without any installation by using [Google
  Colab](https://colab.research.google.com/). In fact, every page of this
  documentation is also available as an interactive notebook - click “Open
  in colab” at the top of any page to open it (be sure to change the Colab
  runtime to “GPU” to have it run fast!) See the fast.ai documentation on
  [Using Colab](https://course.fast.ai/start_colab) for more information.
  You can install fastai on your own machines with conda (highly
  recommended), as long as you’re running Linux or Windows (NB: Mac is not
  supported). For Windows, please see the “Running on Windows” for
  important notes.
  If you’re using
  [miniconda](https://docs.conda.io/en/latest/miniconda.html)
  (recommended) then run (note that if you replace `conda` with
  [mamba](https://github.com/mamba-org/mamba) the install process will be
  much faster and more reliable):
  ``` bash
  conda install -c fastchan fastai
  ```
  …or if you’re using
  [Anaconda](https://www.anaconda.com/products/individual) then run:
  ``` bash
  conda install -c fastchan fastai anaconda
  ```
  To install with pip, use: `pip install fastai`. If you install with pip,
  you should install PyTorch first by following the PyTorch [installation
  instructions](https://pytorch.org/get-started/locally/).
  If you plan to develop fastai yourself, or want to be on the cutting
  edge, you can use an editable install (if you do this, you should also
  use an editable install of
  [fastcore](https://github.com/fastai/fastcore) to go with it.) First
  install PyTorch, and then:
      git clone https://github.com/fastai/fastai
      pip install -e "fastai[dev]"

  The best way to get started with fastai (and deep learning) is to read
  [the
  book](https://www.amazon.com/Deep-Learning-Coders-fastai-PyTorch/dp/1492045527),
  and complete [the free course](https://course.fast.ai).
  To see what’s possible with fastai, take a look at the [Quick
  Start](https://docs.fast.ai/quick_start.html), which shows how to use
  around 5 lines of code to build an image classifier, an image
  segmentation model, a text sentiment model, a recommendation system, and
  a tabular model. For each of the applications, the code is much the
  same.
  Read through the [Tutorials](https://docs.fast.ai/tutorial.html) to
  learn how to train your own models on your own datasets. Use the
  navigation sidebar to look through the fastai documentation. Every
  class, function, and method is documented here.
  To learn about the design and motivation of the library, read the [peer
  reviewed paper](https://www.mdpi.com/2078-2489/11/2/108/htm).

  fastai is a deep learning library which provides practitioners with
  high-level components that can quickly and easily provide
  state-of-the-art results in standard deep learning domains, and provides
  researchers with low-level components that can be mixed and matched to
  build new approaches. It aims to do both things without substantial
  compromises in ease of use, flexibility, or performance. This is
  possible thanks to a carefully layered architecture, which expresses
  common underlying patterns of many deep learning and data processing
  techniques in terms of decoupled abstractions. These abstractions can be
  expressed concisely and clearly by leveraging the dynamism of the
  underlying Python language and the flexibility of the PyTorch library.
  fastai includes:
  - A new type dispatch system for Python along with a semantic type
    hierarchy for tensors
  - A GPU-optimized computer vision library which can be extended in pure
    Python
  - An optimizer which refactors out the common functionality of modern
    optimizers into two basic pieces, allowing optimization algorithms to
    be implemented in 4–5 lines of code
  - A novel 2-way callback system that can access any part of the data,
    model, or optimizer and change it at any point during training
  - A new data block API
  - And much more…
  fastai is organized around two main design goals: to be approachable and
  rapidly productive, while also being deeply hackable and configurable.
  It is built on top of a hierarchy of lower-level APIs which provide
  composable building blocks. This way, a user wanting to rewrite part of
  the high-level API or add particular behavior to suit their needs does
  not have to learn how to use the lowest level.
  <img alt="Layered API" src="https://raw.githubusercontent.com/fastai/fastai/master/images/layered.png" width="345">

  It’s very easy to migrate from plain PyTorch, Ignite, or any other
  PyTorch-based library, or even to use fastai in conjunction with other
  libraries. Generally, you’ll be able to use all your existing data
  processing code, but will be able to reduce the amount of code you
  require for training, and more easily take advantage of modern best
  practices. Here are migration guides from some popular libraries to help
  you on your way:
  - [Plain PyTorch](https://docs.fast.ai/examples/migrating_pytorch.html)
  - [Ignite](https://docs.fast.ai/examples/migrating_ignite.html)
  - [Lightning](https://docs.fast.ai/examples/migrating_lightning.html)
  - [Catalyst](https://docs.fast.ai/examples/migrating_catalyst.html)

  When installing with `mamba` or `conda` replace `-c fastchan` in the
  installation with `-c pytorch -c nvidia -c fastai`, since fastchan is
  not currently supported on Windows.
  Due to python multiprocessing issues on Jupyter and Windows,
  `num_workers` of `Dataloader` is reset to 0 automatically to avoid
  Jupyter hanging. This makes tasks such as computer vision in Jupyter on
  Windows many times slower than on Linux. This limitation doesn’t exist
  if you use fastai from a script.
  See [this
  example](https://github.com/fastai/fastai/blob/master/nbs/examples/dataloader_spawn.py)
  to fully leverage the fastai API on Windows.

  To run the tests in parallel, launch:
  `nbdev_test`
  For all the tests to pass, you’ll need to install the dependencies
  specified as part of dev_requirements in settings.ini
  `pip install -e .[dev]`
  Tests are written using `nbdev`, for example see the documentation for
  `test_eq`.

  After you clone this repository, make sure you have run
  `nbdev_install_hooks` in your terminal. This install Jupyter and git
  hooks to automatically clean, trust, and fix merge conflicts in
  notebooks.
  After making changes in the repo, you should run `nbdev_prepare` and
  make additional and necessary changes in order to pass all the tests.

  For those interested in official docker containers for this project,
  they can be found
  [here](https://github.com/fastai/docker-containers#fastai).


pkgId: cbce8b949747fee2b5b17c1db766b86972d6b76c021a7e155ea5e32b4adf97d5
name: python-fastapi-utils
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Reusable utilities for FastAPI
url: https://fastapi-utils.davidmontague.xyz
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d0559e1-8122-459b-a1d5-8f345e93767e
location_href: 00011337-python-fastapi-utils/python-fastapi-utils-0.2.1-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://fastapi-utils.davidmontague.xyz" target="_blank">https://fastapi-utils.davidmontague.xyz</a>


pkgId: 0adc841a2afa5a1726c507a3fab66d6edd7a8e4e81ec5d87d091378c36bf917e
name: python-fastavro
arch: src
version: 1.7.3
epoch: 0
release: 1
summary: Fast read/write of AVRO files
url: https://github.com/fastavro/fastavro
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e86f784c-0ed7-4304-8222-3ee6706b7125
location_href: 00003604-python-fastavro/python-fastavro-1.7.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/fastavro/fastavro/workflows/Build/badge.svg)](https://github.com/fastavro/fastavro/actions)
  [![Documentation Status](https://readthedocs.org/projects/fastavro/badge/?version=latest)](http://fastavro.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/fastavro/fastavro/branch/master/graph/badge.svg)](https://codecov.io/gh/fastavro/fastavro)


  Because the Apache Python `avro` package is written in pure Python, it is
  relatively slow. In one test case, it takes about 14 seconds to iterate through
  a file of 10,000 records. By comparison, the JAVA `avro` SDK reads the same file in
  1.9 seconds.

  The `fastavro` library was written to offer performance comparable to the Java
  library. With regular CPython, `fastavro` uses C extensions which allow it to
  iterate the same 10,000 record file in 1.7 seconds. With PyPy, this drops to 1.5
  seconds (to be fair, the JAVA benchmark is doing some extra JSON
  encoding/decoding).

  `fastavro` supports the following Python versions:

  * Python 3.7
  * Python 3.8
  * Python 3.9
  * Python 3.10
  * Python 3.11
  * PyPy3



  * File Writer
  * File Reader (iterating via records or blocks)
  * Schemaless Writer
  * Schemaless Reader
  * JSON Writer
  * JSON Reader
  * Codecs (Snappy, Deflate, Zstandard, Bzip2, LZ4, XZ)
  * Schema resolution
  * Aliases
  * Logical Types
  * Parsing schemas into the canonical form
  * Schema fingerprinting



  * Anything involving Avro's RPC features

  [Cython]: http://cython.org/



  Documentation is available at http://fastavro.readthedocs.io/en/latest/


  `fastavro` is available both on [PyPI](http://pypi.python.org/pypi)

      pip install fastavro

  and on [conda-forge](https://conda-forge.github.io) `conda` channel.

      conda install -c conda-forge fastavro



  * Bugs and new feature requests typically start as GitHub issues where they can be discussed. I try to resolve these as time affords, but PRs are welcome from all.
  * Get approval from discussing on the GitHub issue before opening the pull request
  * Tests must be passing for pull request to be considered

  Developer requirements can be installed with `pip install -r developer_requirements.txt`.
  If those are installed, you can run the tests with `./run-tests.sh`. If you have trouble
  installing those dependencies, you can run `docker build .` to run the tests inside
  a Docker container. This won't test on all versions of Python or on PyPy, so it's possible
  to still get CI failures after making a pull request, but we can work through those errors
  if/when they happen. `.run-tests.sh` only covers the Cython tests. In order to test the
  pure Python implementation, comment out `python setup.py build_ext --inplace`
  and re-run.

  NOTE: Some tests might fail when running the tests locally. An example of this
  is this codec tests. If the supporting codec library is not available, the test
  will fail. These failures can be ignored since the tests will on pull requests
  and will be run in the correct environments with the correct dependencies set up.



  We release both to [PyPI][pypi] and to [conda-forge][conda-forge].

  We assume you have [twine][twine] installed and that you've created your own
  fork of [fastavro-feedstock][feedstock].

  * Make sure the tests pass
  * Run `make tag`
  * Wait for all artifacts to be built and published the the Github release
  * Run `make publish`
  * The conda-forge PR should get created and merged automatically

  [conda-forge]: https://conda-forge.org/
  [feedstock]: https://github.com/conda-forge/fastavro-feedstock
  [pypi]: https://pypi.python.org/pypi
  [twine]: https://pypi.python.org/pypi/twine




  See the [ChangeLog]

  [ChangeLog]: https://github.com/fastavro/fastavro/blob/master/ChangeLog



  [Project Home](https://github.com/fastavro/fastavro)


pkgId: 0c7e6970e9f908360b69578eedc26f408393722f5ccffaff4d11442ab54596b8
name: python-fastavro-debuginfo
arch: aarch64
version: 1.7.3
epoch: 0
release: 1
summary: Debug information for package python-fastavro
url: https://github.com/fastavro/fastavro
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e86f784c-0ed7-4304-8222-3ee6706b7125
rpm_sourcerpm: python-fastavro-1.7.3-1.src.rpm
location_href: 00003604-python-fastavro/python-fastavro-debuginfo-1.7.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-fastavro.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: dca5720f6ddcea0abf82a1dc46523a4e80f06a17963e7ae6b3c8ae588ac9abbe
name: python-fastavro-debugsource
arch: aarch64
version: 1.7.3
epoch: 0
release: 1
summary: Debug sources for package python-fastavro
url: https://github.com/fastavro/fastavro
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e86f784c-0ed7-4304-8222-3ee6706b7125
rpm_sourcerpm: python-fastavro-1.7.3-1.src.rpm
location_href: 00003604-python-fastavro/python-fastavro-debugsource-1.7.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-fastavro.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: d1804c9e58c870c3448d122ce8ce0475655721a508e85f72ce4c3cd06b47fe9d
name: python-fastcache
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: C implementation of Python 3 functools.lru_cache
url: https://github.com/pbrady/fastcache
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d9f57350-fb60-4a50-a0d7-c648612e528d
location_href: 00003605-python-fastcache/python-fastcache-1.1.0-1.src.rpm
checksum_type: sha256
description:
  C implementation of Python 3 functools.lru_cache.  Provides speedup of 10-30x
  over standard library.  Passes test suite from standard library for lru_cache.

  Provides 2 Least Recently Used caching function decorators:

    clru_cache - built-in (faster)
               >>> from fastcache import clru_cache, __version__
               >>> __version__
               '1.1.0'
               >>> @clru_cache(maxsize=325, typed=False)
               ... def fib(n):
               ...     """Terrible Fibonacci number generator."""
               ...     return n if n < 2 else fib(n-1) + fib(n-2)
               ...
               >>> fib(300)
               222232244629420445529739893461909967206666939096499764990979600
               >>> fib.cache_info()
               CacheInfo(hits=298, misses=301, maxsize=325, currsize=301)
               >>> print(fib.__doc__)
               Terrible Fibonacci number generator.
               >>> fib.cache_clear()
               >>> fib.cache_info()
               CacheInfo(hits=0, misses=0, maxsize=325, currsize=0)
               >>> fib.__wrapped__(300)
               222232244629420445529739893461909967206666939096499764990979600
               >>> type(fib)
               >>> <class 'fastcache.clru_cache'>

    lru_cache  - python wrapper around clru_cache
               >>> from fastcache import lru_cache
               >>> @lru_cache(maxsize=128, typed=False)
               ... def f(a, b):
               ...     pass
               ...
               >>> type(f)
               >>> <class 'function'>


    (c)lru_cache(maxsize=128, typed=False, state=None, unhashable='error')

        Least-recently-used cache decorator.

        If *maxsize* is set to None, the LRU features are disabled and the cache
        can grow without bound.

        If *typed* is True, arguments of different types will be cached separately.
        For example, f(3.0) and f(3) will be treated as distinct calls with
        distinct results.

        If *state* is a list or dict, the items will be incorporated into the
        argument hash.

        The result of calling the cached function with unhashable (mutable)
        arguments depends on the value of *unhashable*:

            If *unhashable* is 'error', a TypeError will be raised.

            If *unhashable* is 'warning', a UserWarning will be raised, and
            the wrapped function will be called with the supplied arguments.
            A miss will be recorded in the cache statistics.

            If *unhashable* is 'ignore', the wrapped function will be called
            with the supplied arguments. A miss will will be recorded in
            the cache statistics.

        View the cache statistics named tuple (hits, misses, maxsize, currsize)
        with f.cache_info().  Clear the cache and statistics with f.cache_clear().
        Access the underlying function with f.__wrapped__.

        See:  http://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used


pkgId: 2ba1c6d3f10dd93050993f488d92acf11da317fc1d8b97e8172934bfadb0f69a
name: python-fastly
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A Python Fastly API client library
url: https://github.com/fastly/fastly-py
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49a0a814-2815-4db8-b82f-05e4b49d392a
location_href: 00013513-python-fastly/python-fastly-1.3.0-1.src.rpm
checksum_type: sha256
description:
  *AclApi* | [**create_acl**](docs/AclApi.md#create_acl) | **POST** /service/{service_id}/version/{version_id}/acl | Create a new ACL
  *AclApi* | [**delete_acl**](docs/AclApi.md#delete_acl) | **DELETE** /service/{service_id}/version/{version_id}/acl/{acl_name} | Delete an ACL
  *AclApi* | [**get_acl**](docs/AclApi.md#get_acl) | **GET** /service/{service_id}/version/{version_id}/acl/{acl_name} | Describe an ACL
  *AclApi* | [**list_acls**](docs/AclApi.md#list_acls) | **GET** /service/{service_id}/version/{version_id}/acl | List ACLs
  *AclApi* | [**update_acl**](docs/AclApi.md#update_acl) | **PUT** /service/{service_id}/version/{version_id}/acl/{acl_name} | Update an ACL
  *AclEntryApi* | [**bulk_update_acl_entries**](docs/AclEntryApi.md#bulk_update_acl_entries) | **PATCH** /service/{service_id}/acl/{acl_id}/entries | Update multiple ACL entries
  *AclEntryApi* | [**create_acl_entry**](docs/AclEntryApi.md#create_acl_entry) | **POST** /service/{service_id}/acl/{acl_id}/entry | Create an ACL entry
  *AclEntryApi* | [**delete_acl_entry**](docs/AclEntryApi.md#delete_acl_entry) | **DELETE** /service/{service_id}/acl/{acl_id}/entry/{acl_entry_id} | Delete an ACL entry
  *AclEntryApi* | [**get_acl_entry**](docs/AclEntryApi.md#get_acl_entry) | **GET** /service/{service_id}/acl/{acl_id}/entry/{acl_entry_id} | Describe an ACL entry
  *AclEntryApi* | [**list_acl_entries**](docs/AclEntryApi.md#list_acl_entries) | **GET** /service/{service_id}/acl/{acl_id}/entries | List ACL entries
  *AclEntryApi* | [**update_acl_entry**](docs/AclEntryApi.md#update_acl_entry) | **PATCH** /service/{service_id}/acl/{acl_id}/entry/{acl_entry_id} | Update an ACL entry
  *ApexRedirectApi* | [**delete_apex_redirect**](docs/ApexRedirectApi.md#delete_apex_redirect) | **DELETE** /apex-redirects/{apex_redirect_id} | Delete an apex redirect
  *ApexRedirectApi* | [**get_apex_redirect**](docs/ApexRedirectApi.md#get_apex_redirect) | **GET** /apex-redirects/{apex_redirect_id} | Get an apex redirect
  *ApexRedirectApi* | [**list_apex_redirects**](docs/ApexRedirectApi.md#list_apex_redirects) | **GET** /service/{service_id}/version/{version_id}/apex-redirects | List apex redirects
  *ApexRedirectApi* | [**update_apex_redirect**](docs/ApexRedirectApi.md#update_apex_redirect) | **PUT** /apex-redirects/{apex_redirect_id} | Update an apex redirect
  *BackendApi* | [**create_backend**](docs/BackendApi.md#create_backend) | **POST** /service/{service_id}/version/{version_id}/backend | Create a backend
  *BackendApi* | [**delete_backend**](docs/BackendApi.md#delete_backend) | **DELETE** /service/{service_id}/version/{version_id}/backend/{backend_name} | Delete a backend
  *BackendApi* | [**get_backend**](docs/BackendApi.md#get_backend) | **GET** /service/{service_id}/version/{version_id}/backend/{backend_name} | Describe a backend
  *BackendApi* | [**list_backends**](docs/BackendApi.md#list_backends) | **GET** /service/{service_id}/version/{version_id}/backend | List backends
  *BackendApi* | [**update_backend**](docs/BackendApi.md#update_backend) | **PUT** /service/{service_id}/version/{version_id}/backend/{backend_name} | Update a backend
  *BillingApi* | [**get_invoice**](docs/BillingApi.md#get_invoice) | **GET** /billing/v2/year/{year}/month/{month} | Get an invoice
  *BillingApi* | [**get_invoice_by_id**](docs/BillingApi.md#get_invoice_by_id) | **GET** /billing/v2/account_customers/{customer_id}/invoices/{invoice_id} | Get an invoice
  *BillingApi* | [**get_invoice_mtd**](docs/BillingApi.md#get_invoice_mtd) | **GET** /billing/v2/account_customers/{customer_id}/mtd_invoice | Get month-to-date billing estimate
  *BillingAddressApi* | [**add_billing_addr**](docs/BillingAddressApi.md#add_billing_addr) | **POST** /customer/{customer_id}/billing_address | Add a billing address to a customer
  *BillingAddressApi* | [**delete_billing_addr**](docs/BillingAddressApi.md#delete_billing_addr) | **DELETE** /customer/{customer_id}/billing_address | Delete a billing address
  *BillingAddressApi* | [**get_billing_addr**](docs/BillingAddressApi.md#get_billing_addr) | **GET** /customer/{customer_id}/billing_address | Get a billing address
  *BillingAddressApi* | [**update_billing_addr**](docs/BillingAddressApi.md#update_billing_addr) | **PATCH** /customer/{customer_id}/billing_address | Update a billing address
  *CacheSettingsApi* | [**create_cache_settings**](docs/CacheSettingsApi.md#create_cache_settings) | **POST** /service/{service_id}/version/{version_id}/cache_settings | Create a cache settings object
  *CacheSettingsApi* | [**delete_cache_settings**](docs/CacheSettingsApi.md#delete_cache_settings) | **DELETE** /service/{service_id}/version/{version_id}/cache_settings/{cache_settings_name} | Delete a cache settings object
  *CacheSettingsApi* | [**get_cache_settings**](docs/CacheSettingsApi.md#get_cache_settings) | **GET** /service/{service_id}/version/{version_id}/cache_settings/{cache_settings_name} | Get a cache settings object
  *CacheSettingsApi* | [**list_cache_settings**](docs/CacheSettingsApi.md#list_cache_settings) | **GET** /service/{service_id}/version/{version_id}/cache_settings | List cache settings objects
  *CacheSettingsApi* | [**update_cache_settings**](docs/CacheSettingsApi.md#update_cache_settings) | **PUT** /service/{service_id}/version/{version_id}/cache_settings/{cache_settings_name} | Update a cache settings object
  *ConditionApi* | [**create_condition**](docs/ConditionApi.md#create_condition) | **POST** /service/{service_id}/version/{version_id}/condition | Create a condition
  *ConditionApi* | [**delete_condition**](docs/ConditionApi.md#delete_condition) | **DELETE** /service/{service_id}/version/{version_id}/condition/{condition_name} | Delete a condition
  *ConditionApi* | [**get_condition**](docs/ConditionApi.md#get_condition) | **GET** /service/{service_id}/version/{version_id}/condition/{condition_name} | Describe a condition
  *ConditionApi* | [**list_conditions**](docs/ConditionApi.md#list_conditions) | **GET** /service/{service_id}/version/{version_id}/condition | List conditions
  *ConditionApi* | [**update_condition**](docs/ConditionApi.md#update_condition) | **PUT** /service/{service_id}/version/{version_id}/condition/{condition_name} | Update a condition
  *ContactApi* | [**delete_contact**](docs/ContactApi.md#delete_contact) | **DELETE** /customer/{customer_id}/contact/{contact_id} | Delete a contact
  *ContactApi* | [**list_contacts**](docs/ContactApi.md#list_contacts) | **GET** /customer/{customer_id}/contacts | List contacts
  *ContentApi* | [**content_check**](docs/ContentApi.md#content_check) | **GET** /content/edge_check | Check status of content in each POP&#39;s cache
  *CustomerApi* | [**delete_customer**](docs/CustomerApi.md#delete_customer) | **DELETE** /customer/{customer_id} | Delete a customer
  *CustomerApi* | [**get_customer**](docs/CustomerApi.md#get_customer) | **GET** /customer/{customer_id} | Get a customer
  *CustomerApi* | [**get_logged_in_customer**](docs/CustomerApi.md#get_logged_in_customer) | **GET** /current_customer | Get the logged in customer
  *CustomerApi* | [**list_users**](docs/CustomerApi.md#list_users) | **GET** /customer/{customer_id}/users | List users
  *CustomerApi* | [**update_customer**](docs/CustomerApi.md#update_customer) | **PUT** /customer/{customer_id} | Update a customer
  *DictionaryApi* | [**create_dictionary**](docs/DictionaryApi.md#create_dictionary) | **POST** /service/{service_id}/version/{version_id}/dictionary | Create an edge dictionary
  *DictionaryApi* | [**delete_dictionary**](docs/DictionaryApi.md#delete_dictionary) | **DELETE** /service/{service_id}/version/{version_id}/dictionary/{dictionary_name} | Delete an edge dictionary
  *DictionaryApi* | [**get_dictionary**](docs/DictionaryApi.md#get_dictionary) | **GET** /service/{service_id}/version/{version_id}/dictionary/{dictionary_name} | Get an edge dictionary
  *DictionaryApi* | [**list_dictionaries**](docs/DictionaryApi.md#list_dictionaries) | **GET** /service/{service_id}/version/{version_id}/dictionary | List edge dictionaries
  *DictionaryApi* | [**update_dictionary**](docs/DictionaryApi.md#update_dictionary) | **PUT** /service/{service_id}/version/{version_id}/dictionary/{dictionary_name} | Update an edge dictionary
  *DictionaryInfoApi* | [**get_dictionary_info**](docs/DictionaryInfoApi.md#get_dictionary_info) | **GET** /service/{service_id}/version/{version_id}/dictionary/{dictionary_id}/info | Get edge dictionary metadata
  *DictionaryItemApi* | [**create_dictionary_item**](docs/DictionaryItemApi.md#create_dictionary_item) | **POST** /service/{service_id}/dictionary/{dictionary_id}/item | Create an entry in an edge dictionary
  *DictionaryItemApi* | [**delete_dictionary_item**](docs/DictionaryItemApi.md#delete_dictionary_item) | **DELETE** /service/{service_id}/dictionary/{dictionary_id}/item/{dictionary_item_key} | Delete an item from an edge dictionary
  *DictionaryItemApi* | [**get_dictionary_item**](docs/DictionaryItemApi.md#get_dictionary_item) | **GET** /service/{service_id}/dictionary/{dictionary_id}/item/{dictionary_item_key} | Get an item from an edge dictionary
  *DictionaryItemApi* | [**list_dictionary_items**](docs/DictionaryItemApi.md#list_dictionary_items) | **GET** /service/{service_id}/dictionary/{dictionary_id}/items | List items in an edge dictionary
  *DictionaryItemApi* | [**update_dictionary_item**](docs/DictionaryItemApi.md#update_dictionary_item) | **PATCH** /service/{service_id}/dictionary/{dictionary_id}/item/{dictionary_item_key} | Update an entry in an edge dictionary
  *DictionaryItemApi* | [**upsert_dictionary_item**](docs/DictionaryItemApi.md#upsert_dictionary_item) | **PUT** /service/{service_id}/dictionary/{dictionary_id}/item/{dictionary_item_key} | Insert or update an entry in an edge dictionary
  *DiffApi* | [**diff_service_versions**](docs/DiffApi.md#diff_service_versions) | **GET** /service/{service_id}/diff/from/{from_version_id}/to/{to_version_id} | Diff two service versions
  *DirectorApi* | [**create_director**](docs/DirectorApi.md#create_director) | **POST** /service/{service_id}/version/{version_id}/director | Create a director
  *DirectorApi* | [**delete_director**](docs/DirectorApi.md#delete_director) | **DELETE** /service/{service_id}/version/{version_id}/director/{director_name} | Delete a director
  *DirectorApi* | [**get_director**](docs/DirectorApi.md#get_director) | **GET** /service/{service_id}/version/{version_id}/director/{director_name} | Get a director
  *DirectorApi* | [**list_directors**](docs/DirectorApi.md#list_directors) | **GET** /service/{service_id}/version/{version_id}/director | List directors
  *DirectorBackendApi* | [**create_director_backend**](docs/DirectorBackendApi.md#create_director_backend) | **POST** /service/{service_id}/version/{version_id}/director/{director_name}/backend/{backend_name} | Create a director-backend relationship
  *DirectorBackendApi* | [**delete_director_backend**](docs/DirectorBackendApi.md#delete_director_backend) | **DELETE** /service/{service_id}/version/{version_id}/director/{director_name}/backend/{backend_name} | Delete a director-backend relationship
  *DirectorBackendApi* | [**get_director_backend**](docs/DirectorBackendApi.md#get_director_backend) | **GET** /service/{service_id}/version/{version_id}/director/{director_name}/backend/{backend_name} | Get a director-backend relationship
  *DomainApi* | [**check_domain**](docs/DomainApi.md#check_domain) | **GET** /service/{service_id}/version/{version_id}/domain/{domain_name}/check | Validate DNS configuration for a single domain on a service
  *DomainApi* | [**check_domains**](docs/DomainApi.md#check_domains) | **GET** /service/{service_id}/version/{version_id}/domain/check_all | Validate DNS configuration for all domains on a service
  *DomainApi* | [**create_domain**](docs/DomainApi.md#create_domain) | **POST** /service/{service_id}/version/{version_id}/domain | Add a domain name to a service
  *DomainApi* | [**delete_domain**](docs/DomainApi.md#delete_domain) | **DELETE** /service/{service_id}/version/{version_id}/domain/{domain_name} | Remove a domain from a service
  *DomainApi* | [**get_domain**](docs/DomainApi.md#get_domain) | **GET** /service/{service_id}/version/{version_id}/domain/{domain_name} | Describe a domain
  *DomainApi* | [**list_domains**](docs/DomainApi.md#list_domains) | **GET** /service/{service_id}/version/{version_id}/domain | List domains
  *DomainApi* | [**update_domain**](docs/DomainApi.md#update_domain) | **PUT** /service/{service_id}/version/{version_id}/domain/{domain_name} | Update a domain
  *DomainOwnershipsApi* | [**list_domain_ownerships**](docs/DomainOwnershipsApi.md#list_domain_ownerships) | **GET** /domain-ownerships | List domain-ownerships
  *EnabledProductsApi* | [**disable_product**](docs/EnabledProductsApi.md#disable_product) | **DELETE** /enabled-products/{product_id}/services/{service_id} | Disable a product
  *EnabledProductsApi* | [**enable_product**](docs/EnabledProductsApi.md#enable_product) | **PUT** /enabled-products/{product_id}/services/{service_id} | Enable a product
  *EnabledProductsApi* | [**get_enabled_product**](docs/EnabledProductsApi.md#get_enabled_product) | **GET** /enabled-products/{product_id}/services/{service_id} | Get enabled product
  *EventsApi* | [**get_event**](docs/EventsApi.md#get_event) | **GET** /events/{event_id} | Get an event
  *EventsApi* | [**list_events**](docs/EventsApi.md#list_events) | **GET** /events | List events
  *GzipApi* | [**create_gzip_config**](docs/GzipApi.md#create_gzip_config) | **POST** /service/{service_id}/version/{version_id}/gzip | Create a gzip configuration
  *GzipApi* | [**delete_gzip_config**](docs/GzipApi.md#delete_gzip_config) | **DELETE** /service/{service_id}/version/{version_id}/gzip/{gzip_name} | Delete a gzip configuration
  *GzipApi* | [**get_gzip_configs**](docs/GzipApi.md#get_gzip_configs) | **GET** /service/{service_id}/version/{version_id}/gzip/{gzip_name} | Get a gzip configuration
  *GzipApi* | [**list_gzip_configs**](docs/GzipApi.md#list_gzip_configs) | **GET** /service/{service_id}/version/{version_id}/gzip | List gzip configurations
  *GzipApi* | [**update_gzip_config**](docs/GzipApi.md#update_gzip_config) | **PUT** /service/{service_id}/version/{version_id}/gzip/{gzip_name} | Update a gzip configuration
  *HeaderApi* | [**create_header_object**](docs/HeaderApi.md#create_header_object) | **POST** /service/{service_id}/version/{version_id}/header | Create a Header object
  *HeaderApi* | [**delete_header_object**](docs/HeaderApi.md#delete_header_object) | **DELETE** /service/{service_id}/version/{version_id}/header/{header_name} | Delete a Header object
  *HeaderApi* | [**get_header_object**](docs/HeaderApi.md#get_header_object) | **GET** /service/{service_id}/version/{version_id}/header/{header_name} | Get a Header object
  *HeaderApi* | [**list_header_objects**](docs/HeaderApi.md#list_header_objects) | **GET** /service/{service_id}/version/{version_id}/header | List Header objects
  *HeaderApi* | [**update_header_object**](docs/HeaderApi.md#update_header_object) | **PUT** /service/{service_id}/version/{version_id}/header/{header_name} | Update a Header object
  *HealthcheckApi* | [**create_healthcheck**](docs/HealthcheckApi.md#create_healthcheck) | **POST** /service/{service_id}/version/{version_id}/healthcheck | Create a health check
  *HealthcheckApi* | [**delete_healthcheck**](docs/HealthcheckApi.md#delete_healthcheck) | **DELETE** /service/{service_id}/version/{version_id}/healthcheck/{healthcheck_name} | Delete a health check
  *HealthcheckApi* | [**get_healthcheck**](docs/HealthcheckApi.md#get_healthcheck) | **GET** /service/{service_id}/version/{version_id}/healthcheck/{healthcheck_name} | Get a health check
  *HealthcheckApi* | [**list_healthchecks**](docs/HealthcheckApi.md#list_healthchecks) | **GET** /service/{service_id}/version/{version_id}/healthcheck | List health checks
  *HealthcheckApi* | [**update_healthcheck**](docs/HealthcheckApi.md#update_healthcheck) | **PUT** /service/{service_id}/version/{version_id}/healthcheck/{healthcheck_name} | Update a health check
  *HistoricalApi* | [**get_hist_stats**](docs/HistoricalApi.md#get_hist_stats) | **GET** /stats | Get historical stats
  *HistoricalApi* | [**get_hist_stats_aggregated**](docs/HistoricalApi.md#get_hist_stats_aggregated) | **GET** /stats/aggregate | Get aggregated historical stats
  *HistoricalApi* | [**get_hist_stats_field**](docs/HistoricalApi.md#get_hist_stats_field) | **GET** /stats/field/{field} | Get historical stats for a single field
  *HistoricalApi* | [**get_hist_stats_service**](docs/HistoricalApi.md#get_hist_stats_service) | **GET** /stats/service/{service_id} | Get historical stats for a single service
  *HistoricalApi* | [**get_hist_stats_service_field**](docs/HistoricalApi.md#get_hist_stats_service_field) | **GET** /stats/service/{service_id}/field/{field} | Get historical stats for a single service/field combination
  *HistoricalApi* | [**get_regions**](docs/HistoricalApi.md#get_regions) | **GET** /stats/regions | Get region codes
  *HistoricalApi* | [**get_usage**](docs/HistoricalApi.md#get_usage) | **GET** /stats/usage | Get usage statistics
  *HistoricalApi* | [**get_usage_month**](docs/HistoricalApi.md#get_usage_month) | **GET** /stats/usage_by_month | Get month-to-date usage statistics
  *HistoricalApi* | [**get_usage_service**](docs/HistoricalApi.md#get_usage_service) | **GET** /stats/usage_by_service | Get usage statistics per service
  *Http3Api* | [**create_http3**](docs/Http3Api.md#create_http3) | **POST** /service/{service_id}/version/{version_id}/http3 | Enable support for HTTP/3
  *Http3Api* | [**delete_http3**](docs/Http3Api.md#delete_http3) | **DELETE** /service/{service_id}/version/{version_id}/http3 | Disable support for HTTP/3
  *Http3Api* | [**get_http3**](docs/Http3Api.md#get_http3) | **GET** /service/{service_id}/version/{version_id}/http3 | Get HTTP/3 status
  *IamPermissionsApi* | [**list_permissions**](docs/IamPermissionsApi.md#list_permissions) | **GET** /permissions | List permissions
  *IamRolesApi* | [**delete_a_role**](docs/IamRolesApi.md#delete_a_role) | **DELETE** /roles/{role_id} | Delete a role
  *IamRolesApi* | [**get_a_role**](docs/IamRolesApi.md#get_a_role) | **GET** /roles/{role_id} | Get a role
  *IamRolesApi* | [**list_role_permissions**](docs/IamRolesApi.md#list_role_permissions) | **GET** /roles/{role_id}/permissions | List permissions in a role
  *IamRolesApi* | [**list_roles**](docs/IamRolesApi.md#list_roles) | **GET** /roles | List roles
  *IamServiceGroupsApi* | [**delete_a_service_group**](docs/IamServiceGroupsApi.md#delete_a_service_group) | **DELETE** /service-groups/{service_group_id} | Delete a service group
  *IamServiceGroupsApi* | [**get_a_service_group**](docs/IamServiceGroupsApi.md#get_a_service_group) | **GET** /service-groups/{service_group_id} | Get a service group
  *IamServiceGroupsApi* | [**list_service_group_services**](docs/IamServiceGroupsApi.md#list_service_group_services) | **GET** /service-groups/{service_group_id}/services | List services to a service group
  *IamServiceGroupsApi* | [**list_service_groups**](docs/IamServiceGroupsApi.md#list_service_groups) | **GET** /service-groups | List service groups
  *IamUserGroupsApi* | [**delete_a_user_group**](docs/IamUserGroupsApi.md#delete_a_user_group) | **DELETE** /user-groups/{user_group_id} | Delete a user group
  *IamUserGroupsApi* | [**get_a_user_group**](docs/IamUserGroupsApi.md#get_a_user_group) | **GET** /user-groups/{user_group_id} | Get a user group
  *IamUserGroupsApi* | [**list_user_group_members**](docs/IamUserGroupsApi.md#list_user_group_members) | **GET** /user-groups/{user_group_id}/members | List members of a user group
  *IamUserGroupsApi* | [**list_user_group_roles**](docs/IamUserGroupsApi.md#list_user_group_roles) | **GET** /user-groups/{user_group_id}/roles | List roles in a user group
  *IamUserGroupsApi* | [**list_user_group_service_groups**](docs/IamUserGroupsApi.md#list_user_group_service_groups) | **GET** /user-groups/{user_group_id}/service-groups | List service groups in a user group
  *IamUserGroupsApi* | [**list_user_groups**](docs/IamUserGroupsApi.md#list_user_groups) | **GET** /user-groups | List user groups
  *InvitationsApi* | [**create_invitation**](docs/InvitationsApi.md#create_invitation) | **POST** /invitations | Create an invitation
  *InvitationsApi* | [**delete_invitation**](docs/InvitationsApi.md#delete_invitation) | **DELETE** /invitations/{invitation_id} | Delete an invitation
  *InvitationsApi* | [**list_invitations**](docs/InvitationsApi.md#list_invitations) | **GET** /invitations | List invitations
  *LoggingAzureblobApi* | [**create_log_azure**](docs/LoggingAzureblobApi.md#create_log_azure) | **POST** /service/{service_id}/version/{version_id}/logging/azureblob | Create an Azure Blob Storage log endpoint
  *LoggingAzureblobApi* | [**delete_log_azure**](docs/LoggingAzureblobApi.md#delete_log_azure) | **DELETE** /service/{service_id}/version/{version_id}/logging/azureblob/{logging_azureblob_name} | Delete the Azure Blob Storage log endpoint
  *LoggingAzureblobApi* | [**get_log_azure**](docs/LoggingAzureblobApi.md#get_log_azure) | **GET** /service/{service_id}/version/{version_id}/logging/azureblob/{logging_azureblob_name} | Get an Azure Blob Storage log endpoint
  *LoggingAzureblobApi* | [**list_log_azure**](docs/LoggingAzureblobApi.md#list_log_azure) | **GET** /service/{service_id}/version/{version_id}/logging/azureblob | List Azure Blob Storage log endpoints
  *LoggingAzureblobApi* | [**update_log_azure**](docs/LoggingAzureblobApi.md#update_log_azure) | **PUT** /service/{service_id}/version/{version_id}/logging/azureblob/{logging_azureblob_name} | Update an Azure Blob Storage log endpoint
  *LoggingBigqueryApi* | [**create_log_bigquery**](docs/LoggingBigqueryApi.md#create_log_bigquery) | **POST** /service/{service_id}/version/{version_id}/logging/bigquery | Create a BigQuery log endpoint
  *LoggingBigqueryApi* | [**delete_log_bigquery**](docs/LoggingBigqueryApi.md#delete_log_bigquery) | **DELETE** /service/{service_id}/version/{version_id}/logging/bigquery/{logging_bigquery_name} | Delete a BigQuery log endpoint
  *LoggingBigqueryApi* | [**get_log_bigquery**](docs/LoggingBigqueryApi.md#get_log_bigquery) | **GET** /service/{service_id}/version/{version_id}/logging/bigquery/{logging_bigquery_name} | Get a BigQuery log endpoint
  *LoggingBigqueryApi* | [**list_log_bigquery**](docs/LoggingBigqueryApi.md#list_log_bigquery) | **GET** /service/{service_id}/version/{version_id}/logging/bigquery | List BigQuery log endpoints
  *LoggingBigqueryApi* | [**update_log_bigquery**](docs/LoggingBigqueryApi.md#update_log_bigquery) | **PUT** /service/{service_id}/version/{version_id}/logging/bigquery/{logging_bigquery_name} | Update a BigQuery log endpoint
  *LoggingCloudfilesApi* | [**create_log_cloudfiles**](docs/LoggingCloudfilesApi.md#create_log_cloudfiles) | **POST** /service/{service_id}/version/{version_id}/logging/cloudfiles | Create a Cloud Files log endpoint
  *LoggingCloudfilesApi* | [**delete_log_cloudfiles**](docs/LoggingCloudfilesApi.md#delete_log_cloudfiles) | **DELETE** /service/{service_id}/version/{version_id}/logging/cloudfiles/{logging_cloudfiles_name} | Delete the Cloud Files log endpoint
  *LoggingCloudfilesApi* | [**get_log_cloudfiles**](docs/LoggingCloudfilesApi.md#get_log_cloudfiles) | **GET** /service/{service_id}/version/{version_id}/logging/cloudfiles/{logging_cloudfiles_name} | Get a Cloud Files log endpoint
  *LoggingCloudfilesApi* | [**list_log_cloudfiles**](docs/LoggingCloudfilesApi.md#list_log_cloudfiles) | **GET** /service/{service_id}/version/{version_id}/logging/cloudfiles | List Cloud Files log endpoints
  *LoggingCloudfilesApi* | [**update_log_cloudfiles**](docs/LoggingCloudfilesApi.md#update_log_cloudfiles) | **PUT** /service/{service_id}/version/{version_id}/logging/cloudfiles/{logging_cloudfiles_name} | Update the Cloud Files log endpoint
  *LoggingDatadogApi* | [**create_log_datadog**](docs/LoggingDatadogApi.md#create_log_datadog) | **POST** /service/{service_id}/version/{version_id}/logging/datadog | Create a Datadog log endpoint
  *LoggingDatadogApi* | [**delete_log_datadog**](docs/LoggingDatadogApi.md#delete_log_datadog) | **DELETE** /service/{service_id}/version/{version_id}/logging/datadog/{logging_datadog_name} | Delete a Datadog log endpoint
  *LoggingDatadogApi* | [**get_log_datadog**](docs/LoggingDatadogApi.md#get_log_datadog) | **GET** /service/{service_id}/version/{version_id}/logging/datadog/{logging_datadog_name} | Get a Datadog log endpoint
  *LoggingDatadogApi* | [**list_log_datadog**](docs/LoggingDatadogApi.md#list_log_datadog) | **GET** /service/{service_id}/version/{version_id}/logging/datadog | List Datadog log endpoints
  *LoggingDatadogApi* | [**update_log_datadog**](docs/LoggingDatadogApi.md#update_log_datadog) | **PUT** /service/{service_id}/version/{version_id}/logging/datadog/{logging_datadog_name} | Update a Datadog log endpoint
  *LoggingDigitaloceanApi* | [**create_log_digocean**](docs/LoggingDigitaloceanApi.md#create_log_digocean) | **POST** /service/{service_id}/version/{version_id}/logging/digitalocean | Create a DigitalOcean Spaces log endpoint
  *LoggingDigitaloceanApi* | [**delete_log_digocean**](docs/LoggingDigitaloceanApi.md#delete_log_digocean) | **DELETE** /service/{service_id}/version/{version_id}/logging/digitalocean/{logging_digitalocean_name} | Delete a DigitalOcean Spaces log endpoint
  *LoggingDigitaloceanApi* | [**get_log_digocean**](docs/LoggingDigitaloceanApi.md#get_log_digocean) | **GET** /service/{service_id}/version/{version_id}/logging/digitalocean/{logging_digitalocean_name} | Get a DigitalOcean Spaces log endpoint
  *LoggingDigitaloceanApi* | [**list_log_digocean**](docs/LoggingDigitaloceanApi.md#list_log_digocean) | **GET** /service/{service_id}/version/{version_id}/logging/digitalocean | List DigitalOcean Spaces log endpoints
  *LoggingDigitaloceanApi* | [**update_log_digocean**](docs/LoggingDigitaloceanApi.md#update_log_digocean) | **PUT** /service/{service_id}/version/{version_id}/logging/digitalocean/{logging_digitalocean_name} | Update a DigitalOcean Spaces log endpoint
  *LoggingElasticsearchApi* | [**create_log_elasticsearch**](docs/LoggingElasticsearchApi.md#create_log_elasticsearch) | **POST** /service/{service_id}/version/{version_id}/logging/elasticsearch | Create an Elasticsearch log endpoint
  *LoggingElasticsearchApi* | [**delete_log_elasticsearch**](docs/LoggingElasticsearchApi.md#delete_log_elasticsearch) | **DELETE** /service/{service_id}/version/{version_id}/logging/elasticsearch/{logging_elasticsearch_name} | Delete an Elasticsearch log endpoint
  *LoggingElasticsearchApi* | [**get_log_elasticsearch**](docs/LoggingElasticsearchApi.md#get_log_elasticsearch) | **GET** /service/{service_id}/version/{version_id}/logging/elasticsearch/{logging_elasticsearch_name} | Get an Elasticsearch log endpoint
  *LoggingElasticsearchApi* | [**list_log_elasticsearch**](docs/LoggingElasticsearchApi.md#list_log_elasticsearch) | **GET** /service/{service_id}/version/{version_id}/logging/elasticsearch | List Elasticsearch log endpoints
  *LoggingElasticsearchApi* | [**update_log_elasticsearch**](docs/LoggingElasticsearchApi.md#update_log_elasticsearch) | **PUT** /service/{service_id}/version/{version_id}/logging/elasticsearch/{logging_elasticsearch_name} | Update an Elasticsearch log endpoint
  *LoggingFtpApi* | [**create_log_ftp**](docs/LoggingFtpApi.md#create_log_ftp) | **POST** /service/{service_id}/version/{version_id}/logging/ftp | Create an FTP log endpoint
  *LoggingFtpApi* | [**delete_log_ftp**](docs/LoggingFtpApi.md#delete_log_ftp) | **DELETE** /service/{service_id}/version/{version_id}/logging/ftp/{logging_ftp_name} | Delete an FTP log endpoint
  *LoggingFtpApi* | [**get_log_ftp**](docs/LoggingFtpApi.md#get_log_ftp) | **GET** /service/{service_id}/version/{version_id}/logging/ftp/{logging_ftp_name} | Get an FTP log endpoint
  *LoggingFtpApi* | [**list_log_ftp**](docs/LoggingFtpApi.md#list_log_ftp) | **GET** /service/{service_id}/version/{version_id}/logging/ftp | List FTP log endpoints
  *LoggingFtpApi* | [**update_log_ftp**](docs/LoggingFtpApi.md#update_log_ftp) | **PUT** /service/{service_id}/version/{version_id}/logging/ftp/{logging_ftp_name} | Update an FTP log endpoint
  *LoggingGcsApi* | [**create_log_gcs**](docs/LoggingGcsApi.md#create_log_gcs) | **POST** /service/{service_id}/version/{version_id}/logging/gcs | Create a GCS log endpoint
  *LoggingGcsApi* | [**delete_log_gcs**](docs/LoggingGcsApi.md#delete_log_gcs) | **DELETE** /service/{service_id}/version/{version_id}/logging/gcs/{logging_gcs_name} | Delete a GCS log endpoint
  *LoggingGcsApi* | [**get_log_gcs**](docs/LoggingGcsApi.md#get_log_gcs) | **GET** /service/{service_id}/version/{version_id}/logging/gcs/{logging_gcs_name} | Get a GCS log endpoint
  *LoggingGcsApi* | [**list_log_gcs**](docs/LoggingGcsApi.md#list_log_gcs) | **GET** /service/{service_id}/version/{version_id}/logging/gcs | List GCS log endpoints
  *LoggingGcsApi* | [**update_log_gcs**](docs/LoggingGcsApi.md#update_log_gcs) | **PUT** /service/{service_id}/version/{version_id}/logging/gcs/{logging_gcs_name} | Update a GCS log endpoint
  *LoggingHerokuApi* | [**create_log_heroku**](docs/LoggingHerokuApi.md#create_log_heroku) | **POST** /service/{service_id}/version/{version_id}/logging/heroku | Create a Heroku log endpoint
  *LoggingHerokuApi* | [**delete_log_heroku**](docs/LoggingHerokuApi.md#delete_log_heroku) | **DELETE** /service/{service_id}/version/{version_id}/logging/heroku/{logging_heroku_name} | Delete the Heroku log endpoint
  *LoggingHerokuApi* | [**get_log_heroku**](docs/LoggingHerokuApi.md#get_log_heroku) | **GET** /service/{service_id}/version/{version_id}/logging/heroku/{logging_heroku_name} | Get a Heroku log endpoint
  *LoggingHerokuApi* | [**list_log_heroku**](docs/LoggingHerokuApi.md#list_log_heroku) | **GET** /service/{service_id}/version/{version_id}/logging/heroku | List Heroku log endpoints
  *LoggingHerokuApi* | [**update_log_heroku**](docs/LoggingHerokuApi.md#update_log_heroku) | **PUT** /service/{service_id}/version/{version_id}/logging/heroku/{logging_heroku_name} | Update the Heroku log endpoint
  *LoggingHoneycombApi* | [**create_log_honeycomb**](docs/LoggingHoneycombApi.md#create_log_honeycomb) | **POST** /service/{service_id}/version/{version_id}/logging/honeycomb | Create a Honeycomb log endpoint
  *LoggingHoneycombApi* | [**delete_log_honeycomb**](docs/LoggingHoneycombApi.md#delete_log_honeycomb) | **DELETE** /service/{service_id}/version/{version_id}/logging/honeycomb/{logging_honeycomb_name} | Delete the Honeycomb log endpoint
  *LoggingHoneycombApi* | [**get_log_honeycomb**](docs/LoggingHoneycombApi.md#get_log_honeycomb) | **GET** /service/{service_id}/version/{version_id}/logging/honeycomb/{logging_honeycomb_name} | Get a Honeycomb log endpoint
  *LoggingHoneycombApi* | [**list_log_honeycomb**](docs/LoggingHoneycombApi.md#list_log_honeycomb) | **GET** /service/{service_id}/version/{version_id}/logging/honeycomb | List Honeycomb log endpoints
  *LoggingHoneycombApi* | [**update_log_honeycomb**](docs/LoggingHoneycombApi.md#update_log_honeycomb) | **PUT** /service/{service_id}/version/{version_id}/logging/honeycomb/{logging_honeycomb_name} | Update a Honeycomb log endpoint
  *LoggingHttpsApi* | [**create_log_https**](docs/LoggingHttpsApi.md#create_log_https) | **POST** /service/{service_id}/version/{version_id}/logging/https | Create an HTTPS log endpoint
  *LoggingHttpsApi* | [**delete_log_https**](docs/LoggingHttpsApi.md#delete_log_https) | **DELETE** /service/{service_id}/version/{version_id}/logging/https/{logging_https_name} | Delete an HTTPS log endpoint
  *LoggingHttpsApi* | [**get_log_https**](docs/LoggingHttpsApi.md#get_log_https) | **GET** /service/{service_id}/version/{version_id}/logging/https/{logging_https_name} | Get an HTTPS log endpoint
  *LoggingHttpsApi* | [**list_log_https**](docs/LoggingHttpsApi.md#list_log_https) | **GET** /service/{service_id}/version/{version_id}/logging/https | List HTTPS log endpoints
  *LoggingHttpsApi* | [**update_log_https**](docs/LoggingHttpsApi.md#update_log_https) | **PUT** /service/{service_id}/version/{version_id}/logging/https/{logging_https_name} | Update an HTTPS log endpoint
  *LoggingKafkaApi* | [**create_log_kafka**](docs/LoggingKafkaApi.md#create_log_kafka) | **POST** /service/{service_id}/version/{version_id}/logging/kafka | Create a Kafka log endpoint
  *LoggingKafkaApi* | [**delete_log_kafka**](docs/LoggingKafkaApi.md#delete_log_kafka) | **DELETE** /service/{service_id}/version/{version_id}/logging/kafka/{logging_kafka_name} | Delete the Kafka log endpoint
  *LoggingKafkaApi* | [**get_log_kafka**](docs/LoggingKafkaApi.md#get_log_kafka) | **GET** /service/{service_id}/version/{version_id}/logging/kafka/{logging_kafka_name} | Get a Kafka log endpoint
  *LoggingKafkaApi* | [**list_log_kafka**](docs/LoggingKafkaApi.md#list_log_kafka) | **GET** /service/{service_id}/version/{version_id}/logging/kafka | List Kafka log endpoints
  *LoggingKinesisApi* | [**create_log_kinesis**](docs/LoggingKinesisApi.md#create_log_kinesis) | **POST** /service/{service_id}/version/{version_id}/logging/kinesis | Create  an Amazon Kinesis log endpoint
  *LoggingKinesisApi* | [**delete_log_kinesis**](docs/LoggingKinesisApi.md#delete_log_kinesis) | **DELETE** /service/{service_id}/version/{version_id}/logging/kinesis/{logging_kinesis_name} | Delete the Amazon Kinesis log endpoint
  *LoggingKinesisApi* | [**get_log_kinesis**](docs/LoggingKinesisApi.md#get_log_kinesis) | **GET** /service/{service_id}/version/{version_id}/logging/kinesis/{logging_kinesis_name} | Get an Amazon Kinesis log endpoint
  *LoggingKinesisApi* | [**list_log_kinesis**](docs/LoggingKinesisApi.md#list_log_kinesis) | **GET** /service/{service_id}/version/{version_id}/logging/kinesis | List Amazon Kinesis log endpoints
  *LoggingLogentriesApi* | [**create_log_logentries**](docs/LoggingLogentriesApi.md#create_log_logentries) | **POST** /service/{service_id}/version/{version_id}/logging/logentries | Create a Logentries log endpoint
  *LoggingLogentriesApi* | [**delete_log_logentries**](docs/LoggingLogentriesApi.md#delete_log_logentries) | **DELETE** /service/{service_id}/version/{version_id}/logging/logentries/{logging_logentries_name} | Delete a Logentries log endpoint
  *LoggingLogentriesApi* | [**get_log_logentries**](docs/LoggingLogentriesApi.md#get_log_logentries) | **GET** /service/{service_id}/version/{version_id}/logging/logentries/{logging_logentries_name} | Get a Logentries log endpoint
  *LoggingLogentriesApi* | [**list_log_logentries**](docs/LoggingLogentriesApi.md#list_log_logentries) | **GET** /service/{service_id}/version/{version_id}/logging/logentries | List Logentries log endpoints
  *LoggingLogentriesApi* | [**update_log_logentries**](docs/LoggingLogentriesApi.md#update_log_logentries) | **PUT** /service/{service_id}/version/{version_id}/logging/logentries/{logging_logentries_name} | Update a Logentries log endpoint
  *LoggingLogglyApi* | [**create_log_loggly**](docs/LoggingLogglyApi.md#create_log_loggly) | **POST** /service/{service_id}/version/{version_id}/logging/loggly | Create a Loggly log endpoint
  *LoggingLogglyApi* | [**delete_log_loggly**](docs/LoggingLogglyApi.md#delete_log_loggly) | **DELETE** /service/{service_id}/version/{version_id}/logging/loggly/{logging_loggly_name} | Delete a Loggly log endpoint
  *LoggingLogglyApi* | [**get_log_loggly**](docs/LoggingLogglyApi.md#get_log_loggly) | **GET** /service/{service_id}/version/{version_id}/logging/loggly/{logging_loggly_name} | Get a Loggly log endpoint
  *LoggingLogglyApi* | [**list_log_loggly**](docs/LoggingLogglyApi.md#list_log_loggly) | **GET** /service/{service_id}/version/{version_id}/logging/loggly | List Loggly log endpoints
  *LoggingLogglyApi* | [**update_log_loggly**](docs/LoggingLogglyApi.md#update_log_loggly) | **PUT** /service/{service_id}/version/{version_id}/logging/loggly/{logging_loggly_name} | Update a Loggly log endpoint
  *LoggingLogshuttleApi* | [**create_log_logshuttle**](docs/LoggingLogshuttleApi.md#create_log_logshuttle) | **POST** /service/{service_id}/version/{version_id}/logging/logshuttle | Create a Log Shuttle log endpoint
  *LoggingLogshuttleApi* | [**delete_log_logshuttle**](docs/LoggingLogshuttleApi.md#delete_log_logshuttle) | **DELETE** /service/{service_id}/version/{version_id}/logging/logshuttle/{logging_logshuttle_name} | Delete a Log Shuttle log endpoint
  *LoggingLogshuttleApi* | [**get_log_logshuttle**](docs/LoggingLogshuttleApi.md#get_log_logshuttle) | **GET** /service/{service_id}/version/{version_id}/logging/logshuttle/{logging_logshuttle_name} | Get a Log Shuttle log endpoint
  *LoggingLogshuttleApi* | [**list_log_logshuttle**](docs/LoggingLogshuttleApi.md#list_log_logshuttle) | **GET** /service/{service_id}/version/{version_id}/logging/logshuttle | List Log Shuttle log endpoints
  *LoggingLogshuttleApi* | [**update_log_logshuttle**](docs/LoggingLogshuttleApi.md#update_log_logshuttle) | **PUT** /service/{service_id}/version/{version_id}/logging/logshuttle/{logging_logshuttle_name} | Update a Log Shuttle log endpoint
  *LoggingNewrelicApi* | [**create_log_newrelic**](docs/LoggingNewrelicApi.md#create_log_newrelic) | **POST** /service/{service_id}/version/{version_id}/logging/newrelic | Create a New Relic log endpoint
  *LoggingNewrelicApi* | [**delete_log_newrelic**](docs/LoggingNewrelicApi.md#delete_log_newrelic) | **DELETE** /service/{service_id}/version/{version_id}/logging/newrelic/{logging_newrelic_name} | Delete a New Relic log endpoint
  *LoggingNewrelicApi* | [**get_log_newrelic**](docs/LoggingNewrelicApi.md#get_log_newrelic) | **GET** /service/{service_id}/version/{version_id}/logging/newrelic/{logging_newrelic_name} | Get a New Relic log endpoint
  *LoggingNewrelicApi* | [**list_log_newrelic**](docs/LoggingNewrelicApi.md#list_log_newrelic) | **GET** /service/{service_id}/version/{version_id}/logging/newrelic | List New Relic log endpoints
  *LoggingNewrelicApi* | [**update_log_newrelic**](docs/LoggingNewrelicApi.md#update_log_newrelic) | **PUT** /service/{service_id}/version/{version_id}/logging/newrelic/{logging_newrelic_name} | Update a New Relic log endpoint
  *LoggingOpenstackApi* | [**create_log_openstack**](docs/LoggingOpenstackApi.md#create_log_openstack) | **POST** /service/{service_id}/version/{version_id}/logging/openstack | Create an OpenStack log endpoint
  *LoggingOpenstackApi* | [**delete_log_openstack**](docs/LoggingOpenstackApi.md#delete_log_openstack) | **DELETE** /service/{service_id}/version/{version_id}/logging/openstack/{logging_openstack_name} | Delete an OpenStack log endpoint
  *LoggingOpenstackApi* | [**get_log_openstack**](docs/LoggingOpenstackApi.md#get_log_openstack) | **GET** /service/{service_id}/version/{version_id}/logging/openstack/{logging_openstack_name} | Get an OpenStack log endpoint
  *LoggingOpenstackApi* | [**list_log_openstack**](docs/LoggingOpenstackApi.md#list_log_openstack) | **GET** /service/{service_id}/version/{version_id}/logging/openstack | List OpenStack log endpoints
  *LoggingOpenstackApi* | [**update_log_openstack**](docs/LoggingOpenstackApi.md#update_log_openstack) | **PUT** /service/{service_id}/version/{version_id}/logging/openstack/{logging_openstack_name} | Update an OpenStack log endpoint
  *LoggingPapertrailApi* | [**create_log_papertrail**](docs/LoggingPapertrailApi.md#create_log_papertrail) | **POST** /service/{service_id}/version/{version_id}/logging/papertrail | Create a Papertrail log endpoint
  *LoggingPapertrailApi* | [**delete_log_papertrail**](docs/LoggingPapertrailApi.md#delete_log_papertrail) | **DELETE** /service/{service_id}/version/{version_id}/logging/papertrail/{logging_papertrail_name} | Delete a Papertrail log endpoint
  *LoggingPapertrailApi* | [**get_log_papertrail**](docs/LoggingPapertrailApi.md#get_log_papertrail) | **GET** /service/{service_id}/version/{version_id}/logging/papertrail/{logging_papertrail_name} | Get a Papertrail log endpoint
  *LoggingPapertrailApi* | [**list_log_papertrail**](docs/LoggingPapertrailApi.md#list_log_papertrail) | **GET** /service/{service_id}/version/{version_id}/logging/papertrail | List Papertrail log endpoints
  *LoggingPapertrailApi* | [**update_log_papertrail**](docs/LoggingPapertrailApi.md#update_log_papertrail) | **PUT** /service/{service_id}/version/{version_id}/logging/papertrail/{logging_papertrail_name} | Update a Papertrail log endpoint
  *LoggingPubsubApi* | [**create_log_gcp_pubsub**](docs/LoggingPubsubApi.md#create_log_gcp_pubsub) | **POST** /service/{service_id}/version/{version_id}/logging/pubsub | Create a GCP Cloud Pub/Sub log endpoint
  *LoggingPubsubApi* | [**delete_log_gcp_pubsub**](docs/LoggingPubsubApi.md#delete_log_gcp_pubsub) | **DELETE** /service/{service_id}/version/{version_id}/logging/pubsub/{logging_google_pubsub_name} | Delete a GCP Cloud Pub/Sub log endpoint
  *LoggingPubsubApi* | [**get_log_gcp_pubsub**](docs/LoggingPubsubApi.md#get_log_gcp_pubsub) | **GET** /service/{service_id}/version/{version_id}/logging/pubsub/{logging_google_pubsub_name} | Get a GCP Cloud Pub/Sub log endpoint
  *LoggingPubsubApi* | [**list_log_gcp_pubsub**](docs/LoggingPubsubApi.md#list_log_gcp_pubsub) | **GET** /service/{service_id}/version/{version_id}/logging/pubsub | List GCP Cloud Pub/Sub log endpoints
  *LoggingPubsubApi* | [**update_log_gcp_pubsub**](docs/LoggingPubsubApi.md#update_log_gcp_pubsub) | **PUT** /service/{service_id}/version/{version_id}/logging/pubsub/{logging_google_pubsub_name} | Update a GCP Cloud Pub/Sub log endpoint
  *LoggingS3Api* | [**create_log_aws_s3**](docs/LoggingS3Api.md#create_log_aws_s3) | **POST** /service/{service_id}/version/{version_id}/logging/s3 | Create an AWS S3 log endpoint
  *LoggingS3Api* | [**delete_log_aws_s3**](docs/LoggingS3Api.md#delete_log_aws_s3) | **DELETE** /service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name} | Delete an AWS S3 log endpoint
  *LoggingS3Api* | [**get_log_aws_s3**](docs/LoggingS3Api.md#get_log_aws_s3) | **GET** /service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name} | Get an AWS S3 log endpoint
  *LoggingS3Api* | [**list_log_aws_s3**](docs/LoggingS3Api.md#list_log_aws_s3) | **GET** /service/{service_id}/version/{version_id}/logging/s3 | List AWS S3 log endpoints
  *LoggingS3Api* | [**update_log_aws_s3**](docs/LoggingS3Api.md#update_log_aws_s3) | **PUT** /service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name} | Update an AWS S3 log endpoint
  *LoggingScalyrApi* | [**create_log_scalyr**](docs/LoggingScalyrApi.md#create_log_scalyr) | **POST** /service/{service_id}/version/{version_id}/logging/scalyr | Create a Scalyr log endpoint
  *LoggingScalyrApi* | [**delete_log_scalyr**](docs/LoggingScalyrApi.md#delete_log_scalyr) | **DELETE** /service/{service_id}/version/{version_id}/logging/scalyr/{logging_scalyr_name} | Delete the Scalyr log endpoint
  *LoggingScalyrApi* | [**get_log_scalyr**](docs/LoggingScalyrApi.md#get_log_scalyr) | **GET** /service/{service_id}/version/{version_id}/logging/scalyr/{logging_scalyr_name} | Get a Scalyr log endpoint
  *LoggingScalyrApi* | [**list_log_scalyr**](docs/LoggingScalyrApi.md#list_log_scalyr) | **GET** /service/{service_id}/version/{version_id}/logging/scalyr | List Scalyr log endpoints
  *LoggingScalyrApi* | [**update_log_scalyr**](docs/LoggingScalyrApi.md#update_log_scalyr) | **PUT** /service/{service_id}/version/{version_id}/logging/scalyr/{logging_scalyr_name} | Update the Scalyr log endpoint
  *LoggingSftpApi* | [**create_log_sftp**](docs/LoggingSftpApi.md#create_log_sftp) | **POST** /service/{service_id}/version/{version_id}/logging/sftp | Create an SFTP log endpoint
  *LoggingSftpApi* | [**delete_log_sftp**](docs/LoggingSftpApi.md#delete_log_sftp) | **DELETE** /service/{service_id}/version/{version_id}/logging/sftp/{logging_sftp_name} | Delete an SFTP log endpoint
  *LoggingSftpApi* | [**get_log_sftp**](docs/LoggingSftpApi.md#get_log_sftp) | **GET** /service/{service_id}/version/{version_id}/logging/sftp/{logging_sftp_name} | Get an SFTP log endpoint
  *LoggingSftpApi* | [**list_log_sftp**](docs/LoggingSftpApi.md#list_log_sftp) | **GET** /service/{service_id}/version/{version_id}/logging/sftp | List SFTP log endpoints
  *LoggingSftpApi* | [**update_log_sftp**](docs/LoggingSftpApi.md#update_log_sftp) | **PUT** /service/{service_id}/version/{version_id}/logging/sftp/{logging_sftp_name} | Update an SFTP log endpoint
  *LoggingSplunkApi* | [**create_log_splunk**](docs/LoggingSplunkApi.md#create_log_splunk) | **POST** /service/{service_id}/version/{version_id}/logging/splunk | Create a Splunk log endpoint
  *LoggingSplunkApi* | [**delete_log_splunk**](docs/LoggingSplunkApi.md#delete_log_splunk) | **DELETE** /service/{service_id}/version/{version_id}/logging/splunk/{logging_splunk_name} | Delete a Splunk log endpoint
  *LoggingSplunkApi* | [**get_log_splunk**](docs/LoggingSplunkApi.md#get_log_splunk) | **GET** /service/{service_id}/version/{version_id}/logging/splunk/{logging_splunk_name} | Get a Splunk log endpoint
  *LoggingSplunkApi* | [**list_log_splunk**](docs/LoggingSplunkApi.md#list_log_splunk) | **GET** /service/{service_id}/version/{version_id}/logging/splunk | List Splunk log endpoints
  *LoggingSplunkApi* | [**update_log_splunk**](docs/LoggingSplunkApi.md#update_log_splunk) | **PUT** /service/{service_id}/version/{version_id}/logging/splunk/{logging_splunk_name} | Update a Splunk log endpoint
  *LoggingSumologicApi* | [**create_log_sumologic**](docs/LoggingSumologicApi.md#create_log_sumologic) | **POST** /service/{service_id}/version/{version_id}/logging/sumologic | Create a Sumologic log endpoint
  *LoggingSumologicApi* | [**delete_log_sumologic**](docs/LoggingSumologicApi.md#delete_log_sumologic) | **DELETE** /service/{service_id}/version/{version_id}/logging/sumologic/{logging_sumologic_name} | Delete a Sumologic log endpoint
  *LoggingSumologicApi* | [**get_log_sumologic**](docs/LoggingSumologicApi.md#get_log_sumologic) | **GET** /service/{service_id}/version/{version_id}/logging/sumologic/{logging_sumologic_name} | Get a Sumologic log endpoint
  *LoggingSumologicApi* | [**list_log_sumologic**](docs/LoggingSumologicApi.md#list_log_sumologic) | **GET** /service/{service_id}/version/{version_id}/logging/sumologic | List Sumologic log endpoints
  *LoggingSumologicApi* | [**update_log_sumologic**](docs/LoggingSumologicApi.md#update_log_sumologic) | **PUT** /service/{service_id}/version/{version_id}/logging/sumologic/{logging_sumologic_name} | Update a Sumologic log endpoint
  *LoggingSyslogApi* | [**create_log_syslog**](docs/LoggingSyslogApi.md#create_log_syslog) | **POST** /service/{service_id}/version/{version_id}/logging/syslog | Create a syslog log endpoint
  *LoggingSyslogApi* | [**delete_log_syslog**](docs/LoggingSyslogApi.md#delete_log_syslog) | **DELETE** /service/{service_id}/version/{version_id}/logging/syslog/{logging_syslog_name} | Delete a syslog log endpoint
  *LoggingSyslogApi* | [**get_log_syslog**](docs/LoggingSyslogApi.md#get_log_syslog) | **GET** /service/{service_id}/version/{version_id}/logging/syslog/{logging_syslog_name} | Get a syslog log endpoint
  *LoggingSyslogApi* | [**list_log_syslog**](docs/LoggingSyslogApi.md#list_log_syslog) | **GET** /service/{service_id}/version/{version_id}/logging/syslog | List Syslog log endpoints
  *LoggingSyslogApi* | [**update_log_syslog**](docs/LoggingSyslogApi.md#update_log_syslog) | **PUT** /service/{service_id}/version/{version_id}/logging/syslog/{logging_syslog_name} | Update a syslog log endpoint
  *MutualAuthenticationApi* | [**create_mutual_tls_authentication**](docs/MutualAuthenticationApi.md#create_mutual_tls_authentication) | **POST** /tls/mutual_authentications | Create a Mutual Authentication
  *MutualAuthenticationApi* | [**delete_mutual_tls**](docs/MutualAuthenticationApi.md#delete_mutual_tls) | **DELETE** /tls/mutual_authentications/{mutual_authentication_id} | Delete a Mutual TLS
  *MutualAuthenticationApi* | [**get_mutual_authentication**](docs/MutualAuthenticationApi.md#get_mutual_authentication) | **GET** /tls/mutual_authentications/{mutual_authentication_id} | Get a Mutual Authentication
  *MutualAuthenticationApi* | [**list_mutual_authentications**](docs/MutualAuthenticationApi.md#list_mutual_authentications) | **GET** /tls/mutual_authentications | List Mutual Authentications
  *MutualAuthenticationApi* | [**patch_mutual_authentication**](docs/MutualAuthenticationApi.md#patch_mutual_authentication) | **PATCH** /tls/mutual_authentications/{mutual_authentication_id} | Update a Mutual Authentication
  *ObjectStoreApi* | [**create_store**](docs/ObjectStoreApi.md#create_store) | **POST** /resources/stores/object | Create an object store.
  *ObjectStoreApi* | [**delete_store**](docs/ObjectStoreApi.md#delete_store) | **DELETE** /resources/stores/object/{store_id} | Delete an object store.
  *ObjectStoreApi* | [**get_store**](docs/ObjectStoreApi.md#get_store) | **GET** /resources/stores/object/{store_id} | Describe an object store.
  *ObjectStoreApi* | [**get_stores**](docs/ObjectStoreApi.md#get_stores) | **GET** /resources/stores/object | List object stores.
  *ObjectStoreItemApi* | [**delete_key_from_store**](docs/ObjectStoreItemApi.md#delete_key_from_store) | **DELETE** /resources/stores/object/{store_id}/keys/{key_name} | Delete object store item.
  *ObjectStoreItemApi* | [**get_keys**](docs/ObjectStoreItemApi.md#get_keys) | **GET** /resources/stores/object/{store_id}/keys | List object store keys.
  *ObjectStoreItemApi* | [**get_value_for_key**](docs/ObjectStoreItemApi.md#get_value_for_key) | **GET** /resources/stores/object/{store_id}/keys/{key_name} | Get the value of an object store item
  *ObjectStoreItemApi* | [**set_value_for_key**](docs/ObjectStoreItemApi.md#set_value_for_key) | **PUT** /resources/stores/object/{store_id}/keys/{key_name} | Insert an item into an object store
  *PackageApi* | [**get_package**](docs/PackageApi.md#get_package) | **GET** /service/{service_id}/version/{version_id}/package | Get details of the service&#39;s Compute@Edge package.
  *PackageApi* | [**put_package**](docs/PackageApi.md#put_package) | **PUT** /service/{service_id}/version/{version_id}/package | Upload a Compute@Edge package.
  *PoolApi* | [**create_server_pool**](docs/PoolApi.md#create_server_pool) | **POST** /service/{service_id}/version/{version_id}/pool | Create a server pool
  *PoolApi* | [**delete_server_pool**](docs/PoolApi.md#delete_server_pool) | **DELETE** /service/{service_id}/version/{version_id}/pool/{pool_name} | Delete a server pool
  *PoolApi* | [**get_server_pool**](docs/PoolApi.md#get_server_pool) | **GET** /service/{service_id}/version/{version_id}/pool/{pool_name} | Get a server pool
  *PoolApi* | [**list_server_pools**](docs/PoolApi.md#list_server_pools) | **GET** /service/{service_id}/version/{version_id}/pool | List server pools
  *PoolApi* | [**update_server_pool**](docs/PoolApi.md#update_server_pool) | **PUT** /service/{service_id}/version/{version_id}/pool/{pool_name} | Update a server pool
  *PopApi* | [**list_pops**](docs/PopApi.md#list_pops) | **GET** /datacenters | List Fastly POPs
  *PublicIpListApi* | [**list_fastly_ips**](docs/PublicIpListApi.md#list_fastly_ips) | **GET** /public-ip-list | List Fastly&#39;s public IPs
  *PublishApi* | [**publish**](docs/PublishApi.md#publish) | **POST** /service/{service_id}/publish/ | Send messages to Fanout subscribers
  *PurgeApi* | [**purge_all**](docs/PurgeApi.md#purge_all) | **POST** /service/{service_id}/purge_all | Purge everything from a service
  *PurgeApi* | [**purge_single_url**](docs/PurgeApi.md#purge_single_url) | **POST** /purge/{cached_url} | Purge a URL
  *PurgeApi* | [**purge_tag**](docs/PurgeApi.md#purge_tag) | **POST** /service/{service_id}/purge/{surrogate_key} | Purge by surrogate key tag
  *RateLimiterApi* | [**delete_rate_limiter**](docs/RateLimiterApi.md#delete_rate_limiter) | **DELETE** /rate-limiters/{rate_limiter_id} | Delete a rate limiter
  *RateLimiterApi* | [**get_rate_limiter**](docs/RateLimiterApi.md#get_rate_limiter) | **GET** /rate-limiters/{rate_limiter_id} | Get a rate limiter
  *RateLimiterApi* | [**list_rate_limiters**](docs/RateLimiterApi.md#list_rate_limiters) | **GET** /service/{service_id}/version/{version_id}/rate-limiters | List rate limiters
  *RealtimeApi* | [**get_stats_last120_seconds**](docs/RealtimeApi.md#get_stats_last120_seconds) | **GET** /v1/channel/{service_id}/ts/h | Get real-time data for the last 120 seconds
  *RealtimeApi* | [**get_stats_last120_seconds_limit_entries**](docs/RealtimeApi.md#get_stats_last120_seconds_limit_entries) | **GET** /v1/channel/{service_id}/ts/h/limit/{max_entries} | Get a limited number of real-time data entries
  *RealtimeApi* | [**get_stats_last_second**](docs/RealtimeApi.md#get_stats_last_second) | **GET** /v1/channel/{service_id}/ts/{timestamp_in_seconds} | Get real-time data from specified time
  *RequestSettingsApi* | [**delete_request_settings**](docs/RequestSettingsApi.md#delete_request_settings) | **DELETE** /service/{service_id}/version/{version_id}/request_settings/{request_settings_name} | Delete a Request Settings object
  *RequestSettingsApi* | [**get_request_settings**](docs/RequestSettingsApi.md#get_request_settings) | **GET** /service/{service_id}/version/{version_id}/request_settings/{request_settings_name} | Get a Request Settings object
  *RequestSettingsApi* | [**list_request_settings**](docs/RequestSettingsApi.md#list_request_settings) | **GET** /service/{service_id}/version/{version_id}/request_settings | List Request Settings objects
  *RequestSettingsApi* | [**update_request_settings**](docs/RequestSettingsApi.md#update_request_settings) | **PUT** /service/{service_id}/version/{version_id}/request_settings/{request_settings_name} | Update a Request Settings object
  *ResourceApi* | [**create_resource**](docs/ResourceApi.md#create_resource) | **POST** /service/{service_id}/version/{version_id}/resource | Create a resource link
  *ResourceApi* | [**delete_resource**](docs/ResourceApi.md#delete_resource) | **DELETE** /service/{service_id}/version/{version_id}/resource/{id} | Delete a resource link
  *ResourceApi* | [**get_resource**](docs/ResourceApi.md#get_resource) | **GET** /service/{service_id}/version/{version_id}/resource/{id} | Display a resource link
  *ResourceApi* | [**list_resources**](docs/ResourceApi.md#list_resources) | **GET** /service/{service_id}/version/{version_id}/resource | List resource links
  *ResourceApi* | [**update_resource**](docs/ResourceApi.md#update_resource) | **PUT** /service/{service_id}/version/{version_id}/resource/{id} | Update a resource link
  *ResponseObjectApi* | [**delete_response_object**](docs/ResponseObjectApi.md#delete_response_object) | **DELETE** /service/{service_id}/version/{version_id}/response_object/{response_object_name} | Delete a Response Object
  *ResponseObjectApi* | [**get_response_object**](docs/ResponseObjectApi.md#get_response_object) | **GET** /service/{service_id}/version/{version_id}/response_object/{response_object_name} | Get a Response object
  *ResponseObjectApi* | [**list_response_objects**](docs/ResponseObjectApi.md#list_response_objects) | **GET** /service/{service_id}/version/{version_id}/response_object | List Response objects
  *ServerApi* | [**create_pool_server**](docs/ServerApi.md#create_pool_server) | **POST** /service/{service_id}/pool/{pool_id}/server | Add a server to a pool
  *ServerApi* | [**delete_pool_server**](docs/ServerApi.md#delete_pool_server) | **DELETE** /service/{service_id}/pool/{pool_id}/server/{server_id} | Delete a server from a pool
  *ServerApi* | [**get_pool_server**](docs/ServerApi.md#get_pool_server) | **GET** /service/{service_id}/pool/{pool_id}/server/{server_id} | Get a pool server
  *ServerApi* | [**list_pool_servers**](docs/ServerApi.md#list_pool_servers) | **GET** /service/{service_id}/pool/{pool_id}/servers | List servers in a pool
  *ServerApi* | [**update_pool_server**](docs/ServerApi.md#update_pool_server) | **PUT** /service/{service_id}/pool/{pool_id}/server/{server_id} | Update a server
  *ServiceApi* | [**create_service**](docs/ServiceApi.md#create_service) | **POST** /service | Create a service
  *ServiceApi* | [**delete_service**](docs/ServiceApi.md#delete_service) | **DELETE** /service/{service_id} | Delete a service
  *ServiceApi* | [**get_service**](docs/ServiceApi.md#get_service) | **GET** /service/{service_id} | Get a service
  *ServiceApi* | [**get_service_detail**](docs/ServiceApi.md#get_service_detail) | **GET** /service/{service_id}/details | Get service details
  *ServiceApi* | [**list_service_domains**](docs/ServiceApi.md#list_service_domains) | **GET** /service/{service_id}/domain | List the domains within a service
  *ServiceApi* | [**list_services**](docs/ServiceApi.md#list_services) | **GET** /service | List services
  *ServiceApi* | [**search_service**](docs/ServiceApi.md#search_service) | **GET** /service/search | Search for a service by name
  *ServiceApi* | [**update_service**](docs/ServiceApi.md#update_service) | **PUT** /service/{service_id} | Update a service
  *ServiceAuthorizationsApi* | [**create_service_authorization**](docs/ServiceAuthorizationsApi.md#create_service_authorization) | **POST** /service-authorizations | Create service authorization
  *ServiceAuthorizationsApi* | [**delete_service_authorization**](docs/ServiceAuthorizationsApi.md#delete_service_authorization) | **DELETE** /service-authorizations/{service_authorization_id} | Delete service authorization
  *ServiceAuthorizationsApi* | [**list_service_authorization**](docs/ServiceAuthorizationsApi.md#list_service_authorization) | **GET** /service-authorizations | List service authorizations
  *ServiceAuthorizationsApi* | [**show_service_authorization**](docs/ServiceAuthorizationsApi.md#show_service_authorization) | **GET** /service-authorizations/{service_authorization_id} | Show service authorization
  *ServiceAuthorizationsApi* | [**update_service_authorization**](docs/ServiceAuthorizationsApi.md#update_service_authorization) | **PATCH** /service-authorizations/{service_authorization_id} | Update service authorization
  *SettingsApi* | [**get_service_settings**](docs/SettingsApi.md#get_service_settings) | **GET** /service/{service_id}/version/{version_id}/settings | Get service settings
  *SettingsApi* | [**update_service_settings**](docs/SettingsApi.md#update_service_settings) | **PUT** /service/{service_id}/version/{version_id}/settings | Update service settings
  *SnippetApi* | [**create_snippet**](docs/SnippetApi.md#create_snippet) | **POST** /service/{service_id}/version/{version_id}/snippet | Create a snippet
  *SnippetApi* | [**delete_snippet**](docs/SnippetApi.md#delete_snippet) | **DELETE** /service/{service_id}/version/{version_id}/snippet/{snippet_name} | Delete a snippet
  *SnippetApi* | [**get_snippet**](docs/SnippetApi.md#get_snippet) | **GET** /service/{service_id}/version/{version_id}/snippet/{snippet_name} | Get a versioned snippet
  *SnippetApi* | [**get_snippet_dynamic**](docs/SnippetApi.md#get_snippet_dynamic) | **GET** /service/{service_id}/snippet/{snippet_id} | Get a dynamic snippet
  *SnippetApi* | [**list_snippets**](docs/SnippetApi.md#list_snippets) | **GET** /service/{service_id}/version/{version_id}/snippet | List snippets
  *SnippetApi* | [**update_snippet_dynamic**](docs/SnippetApi.md#update_snippet_dynamic) | **PUT** /service/{service_id}/snippet/{snippet_id} | Update a dynamic snippet
  *StarApi* | [**create_service_star**](docs/StarApi.md#create_service_star) | **POST** /stars | Create a star
  *StarApi* | [**delete_service_star**](docs/StarApi.md#delete_service_star) | **DELETE** /stars/{star_id} | Delete a star
  *StarApi* | [**get_service_star**](docs/StarApi.md#get_service_star) | **GET** /stars/{star_id} | Get a star
  *StarApi* | [**list_service_stars**](docs/StarApi.md#list_service_stars) | **GET** /stars | List stars
  *StatsApi* | [**get_service_stats**](docs/StatsApi.md#get_service_stats) | **GET** /service/{service_id}/stats/summary | Get stats for a service
  *TlsActivationsApi* | [**create_tls_activation**](docs/TlsActivationsApi.md#create_tls_activation) | **POST** /tls/activations | Enable TLS for a domain using a custom certificate
  *TlsActivationsApi* | [**delete_tls_activation**](docs/TlsActivationsApi.md#delete_tls_activation) | **DELETE** /tls/activations/{tls_activation_id} | Disable TLS on a domain
  *TlsActivationsApi* | [**get_tls_activation**](docs/TlsActivationsApi.md#get_tls_activation) | **GET** /tls/activations/{tls_activation_id} | Get a TLS activation
  *TlsActivationsApi* | [**list_tls_activations**](docs/TlsActivationsApi.md#list_tls_activations) | **GET** /tls/activations | List TLS activations
  *TlsActivationsApi* | [**update_tls_activation**](docs/TlsActivationsApi.md#update_tls_activation) | **PATCH** /tls/activations/{tls_activation_id} | Update a certificate
  *TlsBulkCertificatesApi* | [**delete_bulk_tls_cert**](docs/TlsBulkCertificatesApi.md#delete_bulk_tls_cert) | **DELETE** /tls/bulk/certificates/{certificate_id} | Delete a certificate
  *TlsBulkCertificatesApi* | [**get_tls_bulk_cert**](docs/TlsBulkCertificatesApi.md#get_tls_bulk_cert) | **GET** /tls/bulk/certificates/{certificate_id} | Get a certificate
  *TlsBulkCertificatesApi* | [**list_tls_bulk_certs**](docs/TlsBulkCertificatesApi.md#list_tls_bulk_certs) | **GET** /tls/bulk/certificates | List certificates
  *TlsBulkCertificatesApi* | [**update_bulk_tls_cert**](docs/TlsBulkCertificatesApi.md#update_bulk_tls_cert) | **PATCH** /tls/bulk/certificates/{certificate_id} | Update a certificate
  *TlsBulkCertificatesApi* | [**upload_tls_bulk_cert**](docs/TlsBulkCertificatesApi.md#upload_tls_bulk_cert) | **POST** /tls/bulk/certificates | Upload a certificate
  *TlsCertificatesApi* | [**create_tls_cert**](docs/TlsCertificatesApi.md#create_tls_cert) | **POST** /tls/certificates | Create a TLS certificate
  *TlsCertificatesApi* | [**delete_tls_cert**](docs/TlsCertificatesApi.md#delete_tls_cert) | **DELETE** /tls/certificates/{tls_certificate_id} | Delete a TLS certificate
  *TlsCertificatesApi* | [**get_tls_cert**](docs/TlsCertificatesApi.md#get_tls_cert) | **GET** /tls/certificates/{tls_certificate_id} | Get a TLS certificate
  *TlsCertificatesApi* | [**list_tls_certs**](docs/TlsCertificatesApi.md#list_tls_certs) | **GET** /tls/certificates | List TLS certificates
  *TlsCertificatesApi* | [**update_tls_cert**](docs/TlsCertificatesApi.md#update_tls_cert) | **PATCH** /tls/certificates/{tls_certificate_id} | Update a TLS certificate
  *TlsConfigurationsApi* | [**get_tls_config**](docs/TlsConfigurationsApi.md#get_tls_config) | **GET** /tls/configurations/{tls_configuration_id} | Get a TLS configuration
  *TlsConfigurationsApi* | [**list_tls_configs**](docs/TlsConfigurationsApi.md#list_tls_configs) | **GET** /tls/configurations | List TLS configurations
  *TlsConfigurationsApi* | [**update_tls_config**](docs/TlsConfigurationsApi.md#update_tls_config) | **PATCH** /tls/configurations/{tls_configuration_id} | Update a TLS configuration
  *TlsCsrsApi* | [**create_csr**](docs/TlsCsrsApi.md#create_csr) | **POST** /tls/certificate_signing_requests | Create CSR
  *TlsDomainsApi* | [**list_tls_domains**](docs/TlsDomainsApi.md#list_tls_domains) | **GET** /tls/domains | List TLS domains
  *TlsPrivateKeysApi* | [**create_tls_key**](docs/TlsPrivateKeysApi.md#create_tls_key) | **POST** /tls/private_keys | Create a TLS private key
  *TlsPrivateKeysApi* | [**delete_tls_key**](docs/TlsPrivateKeysApi.md#delete_tls_key) | **DELETE** /tls/private_keys/{tls_private_key_id} | Delete a TLS private key
  *TlsPrivateKeysApi* | [**get_tls_key**](docs/TlsPrivateKeysApi.md#get_tls_key) | **GET** /tls/private_keys/{tls_private_key_id} | Get a TLS private key
  *TlsPrivateKeysApi* | [**list_tls_keys**](docs/TlsPrivateKeysApi.md#list_tls_keys) | **GET** /tls/private_keys | List TLS private keys
  *TlsSubscriptionsApi* | [**create_globalsign_email_challenge**](docs/TlsSubscriptionsApi.md#create_globalsign_email_challenge) | **POST** /tls/subscriptions/{tls_subscription_id}/authorizations/{tls_authorization_id}/globalsign_email_challenges | Creates a GlobalSign email challenge.
  *TlsSubscriptionsApi* | [**create_tls_sub**](docs/TlsSubscriptionsApi.md#create_tls_sub) | **POST** /tls/subscriptions | Create a TLS subscription
  *TlsSubscriptionsApi* | [**delete_globalsign_email_challenge**](docs/TlsSubscriptionsApi.md#delete_globalsign_email_challenge) | **DELETE** /tls/subscriptions/{tls_subscription_id}/authorizations/{tls_authorization_id}/globalsign_email_challenges/{globalsign_email_challenge_id} | Delete a GlobalSign email challenge
  *TlsSubscriptionsApi* | [**delete_tls_sub**](docs/TlsSubscriptionsApi.md#delete_tls_sub) | **DELETE** /tls/subscriptions/{tls_subscription_id} | Delete a TLS subscription
  *TlsSubscriptionsApi* | [**get_tls_sub**](docs/TlsSubscriptionsApi.md#get_tls_sub) | **GET** /tls/subscriptions/{tls_subscription_id} | Get a TLS subscription
  *TlsSubscriptionsApi* | [**list_tls_subs**](docs/TlsSubscriptionsApi.md#list_tls_subs) | **GET** /tls/subscriptions | List TLS subscriptions
  *TlsSubscriptionsApi* | [**patch_tls_sub**](docs/TlsSubscriptionsApi.md#patch_tls_sub) | **PATCH** /tls/subscriptions/{tls_subscription_id} | Update a TLS subscription
  *TokensApi* | [**get_token_current**](docs/TokensApi.md#get_token_current) | **GET** /tokens/self | Get the current token
  *TokensApi* | [**list_tokens_customer**](docs/TokensApi.md#list_tokens_customer) | **GET** /customer/{customer_id}/tokens | List tokens for a customer
  *TokensApi* | [**list_tokens_user**](docs/TokensApi.md#list_tokens_user) | **GET** /tokens | List tokens for the authenticated user
  *TokensApi* | [**revoke_token**](docs/TokensApi.md#revoke_token) | **DELETE** /tokens/{token_id} | Revoke a token
  *TokensApi* | [**revoke_token_current**](docs/TokensApi.md#revoke_token_current) | **DELETE** /tokens/self | Revoke the current token
  *UserApi* | [**create_user**](docs/UserApi.md#create_user) | **POST** /user | Create a user
  *UserApi* | [**delete_user**](docs/UserApi.md#delete_user) | **DELETE** /user/{user_id} | Delete a user
  *UserApi* | [**get_current_user**](docs/UserApi.md#get_current_user) | **GET** /current_user | Get the current user
  *UserApi* | [**get_user**](docs/UserApi.md#get_user) | **GET** /user/{user_id} | Get a user
  *UserApi* | [**request_password_reset**](docs/UserApi.md#request_password_reset) | **POST** /user/{user_login}/password/request_reset | Request a password reset
  *UserApi* | [**update_user**](docs/UserApi.md#update_user) | **PUT** /user/{user_id} | Update a user
  *UserApi* | [**update_user_password**](docs/UserApi.md#update_user_password) | **POST** /current_user/password | Update the user&#39;s password
  *VclApi* | [**create_custom_vcl**](docs/VclApi.md#create_custom_vcl) | **POST** /service/{service_id}/version/{version_id}/vcl | Create a custom VCL file
  *VclApi* | [**delete_custom_vcl**](docs/VclApi.md#delete_custom_vcl) | **DELETE** /service/{service_id}/version/{version_id}/vcl/{vcl_name} | Delete a custom VCL file
  *VclApi* | [**get_custom_vcl**](docs/VclApi.md#get_custom_vcl) | **GET** /service/{service_id}/version/{version_id}/vcl/{vcl_name} | Get a custom VCL file
  *VclApi* | [**get_custom_vcl_boilerplate**](docs/VclApi.md#get_custom_vcl_boilerplate) | **GET** /service/{service_id}/version/{version_id}/boilerplate | Get boilerplate VCL
  *VclApi* | [**get_custom_vcl_generated**](docs/VclApi.md#get_custom_vcl_generated) | **GET** /service/{service_id}/version/{version_id}/generated_vcl | Get the generated VCL for a service
  *VclApi* | [**get_custom_vcl_raw**](docs/VclApi.md#get_custom_vcl_raw) | **GET** /service/{service_id}/version/{version_id}/vcl/{vcl_name}/download | Download a custom VCL file
  *VclApi* | [**lint_vcl_default**](docs/VclApi.md#lint_vcl_default) | **POST** /vcl_lint | Lint (validate) VCL using a default set of flags.
  *VclApi* | [**lint_vcl_for_service**](docs/VclApi.md#lint_vcl_for_service) | **POST** /service/{service_id}/lint | Lint (validate) VCL using flags set for the service.
  *VclApi* | [**list_custom_vcl**](docs/VclApi.md#list_custom_vcl) | **GET** /service/{service_id}/version/{version_id}/vcl | List custom VCL files
  *VclApi* | [**set_custom_vcl_main**](docs/VclApi.md#set_custom_vcl_main) | **PUT** /service/{service_id}/version/{version_id}/vcl/{vcl_name}/main | Set a custom VCL file as main
  *VclApi* | [**update_custom_vcl**](docs/VclApi.md#update_custom_vcl) | **PUT** /service/{service_id}/version/{version_id}/vcl/{vcl_name} | Update a custom VCL file
  *VclDiffApi* | [**vcl_diff_service_versions**](docs/VclDiffApi.md#vcl_diff_service_versions) | **GET** /service/{service_id}/vcl/diff/from/{from_version_id}/to/{to_version_id} | Get a comparison of the VCL changes between two service versions
  *VersionApi* | [**activate_service_version**](docs/VersionApi.md#activate_service_version) | **PUT** /service/{service_id}/version/{version_id}/activate | Activate a service version
  *VersionApi* | [**clone_service_version**](docs/VersionApi.md#clone_service_version) | **PUT** /service/{service_id}/version/{version_id}/clone | Clone a service version
  *VersionApi* | [**create_service_version**](docs/VersionApi.md#create_service_version) | **POST** /service/{service_id}/version | Create a service version
  *VersionApi* | [**deactivate_service_version**](docs/VersionApi.md#deactivate_service_version) | **PUT** /service/{service_id}/version/{version_id}/deactivate | Deactivate a service version
  *VersionApi* | [**get_service_version**](docs/VersionApi.md#get_service_version) | **GET** /service/{service_id}/version/{version_id} | Get a version of a service
  *VersionApi* | [**list_service_versions**](docs/VersionApi.md#list_service_versions) | **GET** /service/{service_id}/version | List versions of a service
  *VersionApi* | [**lock_service_version**](docs/VersionApi.md#lock_service_version) | **PUT** /service/{service_id}/version/{version_id}/lock | Lock a service version
  *VersionApi* | [**update_service_version**](docs/VersionApi.md#update_service_version) | **PUT** /service/{service_id}/version/{version_id} | Update a service version
  *VersionApi* | [**validate_service_version**](docs/VersionApi.md#validate_service_version) | **GET** /service/{service_id}/version/{version_id}/validate | Validate a service version
  *WafActiveRulesApi* | [**bulk_update_waf_active_rules**](docs/WafActiveRulesApi.md#bulk_update_waf_active_rules) | **PATCH** /waf/firewalls/{firewall_id}/versions/{version_id}/active-rules/bulk | Update multiple active rules
  *WafActiveRulesApi* | [**create_waf_active_rule**](docs/WafActiveRulesApi.md#create_waf_active_rule) | **POST** /waf/firewalls/{firewall_id}/versions/{version_id}/active-rules | Add a rule to a WAF as an active rule
  *WafActiveRulesApi* | [**create_waf_active_rules_tag**](docs/WafActiveRulesApi.md#create_waf_active_rules_tag) | **POST** /waf/firewalls/{firewall_id}/versions/{version_id}/tags/{waf_tag_name}/active-rules | Create active rules by tag
  *WafActiveRulesApi* | [**delete_waf_active_rule**](docs/WafActiveRulesApi.md#delete_waf_active_rule) | **DELETE** /waf/firewalls/{firewall_id}/versions/{version_id}/active-rules/{waf_rule_id} | Delete an active rule
  *WafActiveRulesApi* | [**get_waf_active_rule**](docs/WafActiveRulesApi.md#get_waf_active_rule) | **GET** /waf/firewalls/{firewall_id}/versions/{version_id}/active-rules/{waf_rule_id} | Get an active WAF rule object
  *WafActiveRulesApi* | [**list_waf_active_rules**](docs/WafActiveRulesApi.md#list_waf_active_rules) | **GET** /waf/firewalls/{firewall_id}/versions/{version_id}/active-rules | List active rules on a WAF
  *WafActiveRulesApi* | [**update_waf_active_rule**](docs/WafActiveRulesApi.md#update_waf_active_rule) | **PATCH** /waf/firewalls/{firewall_id}/versions/{version_id}/active-rules/{waf_rule_id} | Update an active rule
  *WafExclusionsApi* | [**create_waf_rule_exclusion**](docs/WafExclusionsApi.md#create_waf_rule_exclusion) | **POST** /waf/firewalls/{firewall_id}/versions/{firewall_version_number}/exclusions | Create a WAF rule exclusion
  *WafExclusionsApi* | [**delete_waf_rule_exclusion**](docs/WafExclusionsApi.md#delete_waf_rule_exclusion) | **DELETE** /waf/firewalls/{firewall_id}/versions/{firewall_version_number}/exclusions/{exclusion_number} | Delete a WAF rule exclusion
  *WafExclusionsApi* | [**get_waf_rule_exclusion**](docs/WafExclusionsApi.md#get_waf_rule_exclusion) | **GET** /waf/firewalls/{firewall_id}/versions/{firewall_version_number}/exclusions/{exclusion_number} | Get a WAF rule exclusion
  *WafExclusionsApi* | [**list_waf_rule_exclusions**](docs/WafExclusionsApi.md#list_waf_rule_exclusions) | **GET** /waf/firewalls/{firewall_id}/versions/{firewall_version_number}/exclusions | List WAF rule exclusions
  *WafExclusionsApi* | [**update_waf_rule_exclusion**](docs/WafExclusionsApi.md#update_waf_rule_exclusion) | **PATCH** /waf/firewalls/{firewall_id}/versions/{firewall_version_number}/exclusions/{exclusion_number} | Update a WAF rule exclusion
  *WafFirewallVersionsApi* | [**clone_waf_firewall_version**](docs/WafFirewallVersionsApi.md#clone_waf_firewall_version) | **PUT** /waf/firewalls/{firewall_id}/versions/{firewall_version_number}/clone | Clone a firewall version
  *WafFirewallVersionsApi* | [**create_waf_firewall_version**](docs/WafFirewallVersionsApi.md#create_waf_firewall_version) | **POST** /waf/firewalls/{firewall_id}/versions | Create a firewall version
  *WafFirewallVersionsApi* | [**deploy_activate_waf_firewall_version**](docs/WafFirewallVersionsApi.md#deploy_activate_waf_firewall_version) | **PUT** /waf/firewalls/{firewall_id}/versions/{firewall_version_number}/activate | Deploy or activate a firewall version
  *WafFirewallVersionsApi* | [**get_waf_firewall_version**](docs/WafFirewallVersionsApi.md#get_waf_firewall_version) | **GET** /waf/firewalls/{firewall_id}/versions/{firewall_version_number} | Get a firewall version
  *WafFirewallVersionsApi* | [**list_waf_firewall_versions**](docs/WafFirewallVersionsApi.md#list_waf_firewall_versions) | **GET** /waf/firewalls/{firewall_id}/versions | List firewall versions
  *WafFirewallVersionsApi* | [**update_waf_firewall_version**](docs/WafFirewallVersionsApi.md#update_waf_firewall_version) | **PATCH** /waf/firewalls/{firewall_id}/versions/{firewall_version_number} | Update a firewall version
  *WafFirewallsApi* | [**create_waf_firewall**](docs/WafFirewallsApi.md#create_waf_firewall) | **POST** /waf/firewalls | Create a firewall
  *WafFirewallsApi* | [**delete_waf_firewall**](docs/WafFirewallsApi.md#delete_waf_firewall) | **DELETE** /waf/firewalls/{firewall_id} | Delete a firewall
  *WafFirewallsApi* | [**get_waf_firewall**](docs/WafFirewallsApi.md#get_waf_firewall) | **GET** /waf/firewalls/{firewall_id} | Get a firewall
  *WafFirewallsApi* | [**list_waf_firewalls**](docs/WafFirewallsApi.md#list_waf_firewalls) | **GET** /waf/firewalls | List firewalls
  *WafFirewallsApi* | [**update_waf_firewall**](docs/WafFirewallsApi.md#update_waf_firewall) | **PATCH** /waf/firewalls/{firewall_id} | Update a firewall
  *WafRuleRevisionsApi* | [**get_waf_rule_revision**](docs/WafRuleRevisionsApi.md#get_waf_rule_revision) | **GET** /waf/rules/{waf_rule_id}/revisions/{waf_rule_revision_number} | Get a revision of a rule
  *WafRuleRevisionsApi* | [**list_waf_rule_revisions**](docs/WafRuleRevisionsApi.md#list_waf_rule_revisions) | **GET** /waf/rules/{waf_rule_id}/revisions | List revisions for a rule
  *WafRulesApi* | [**get_waf_rule**](docs/WafRulesApi.md#get_waf_rule) | **GET** /waf/rules/{waf_rule_id} | Get a rule
  *WafRulesApi* | [**list_waf_rules**](docs/WafRulesApi.md#list_waf_rules) | **GET** /waf/rules | List available WAF rules
  *WafTagsApi* | [**list_waf_tags**](docs/WafTagsApi.md#list_waf_tags) | **GET** /waf/tags | List tags

  The fastly-py API client currently does not support the following endpoints:
  - [`/automation-tokens/{id}/services`](https://developer.fastly.com/reference/api/auth-tokens/automation) (GET)
  - [`/automation-tokens/{id}`](https://developer.fastly.com/reference/api/auth-tokens/automation) (DELETE, GET)
  - [`/automation-tokens`](https://developer.fastly.com/reference/api/auth-tokens/automation) (GET, POST)
  - [`/customer/{customer_id}/contacts`](https://developer.fastly.com/reference/api/account/contact) (POST)
  - [`/docs/section/{section}`](https://developer.fastly.com/reference/api/utils/docs) (GET)
  - [`/docs/subject/{subject}`](https://developer.fastly.com/reference/api/utils/docs) (GET)
  - [`/metrics/domains/services/{service_id}`](https://developer.fastly.com/reference/api/metrics-stats/domain-inspector/historical) (GET)
  - [`/metrics/origins/services/{service_id}`](https://developer.fastly.com/reference/api/metrics-stats/origin-inspector/historical) (GET)
  - [`/rate-limiters/{rate_limiter_id}`](https://developer.fastly.com/reference/api/vcl-services/rate-limiter) (PUT)
  - [`/resources/stores/config/{config_store_id}/info`](https://developer.fastly.com/reference/api/services/resources/config-store) (GET)
  - [`/resources/stores/config/{config_store_id}/item/{config_store_item_key}`](https://developer.fastly.com/reference/api/services/resources/config-store-item) (DELETE, GET, PATCH, PUT)
  - [`/resources/stores/config/{config_store_id}/item`](https://developer.fastly.com/reference/api/services/resources/config-store-item) (POST)
  - [`/resources/stores/config/{config_store_id}/items`](https://developer.fastly.com/reference/api/services/resources/config-store-item) (GET, PATCH)
  - [`/resources/stores/config/{config_store_id}/services`](https://developer.fastly.com/reference/api/services/resources/config-store) (GET)
  - [`/resources/stores/config/{config_store_id}`](https://developer.fastly.com/reference/api/services/resources/config-store) (DELETE, GET, PUT)
  - [`/resources/stores/config`](https://developer.fastly.com/reference/api/services/resources/config-store) (GET, POST)
  - [`/resources/stores/secret/client-key`](https://developer.fastly.com/reference/api/services/resources/secret-store) (POST)
  - [`/resources/stores/secret/signing-key`](https://developer.fastly.com/reference/api/services/resources/secret-store) (GET)
  - [`/resources/stores/secret/{store_id}/secrets/{secret_name}`](https://developer.fastly.com/reference/api/services/resources/secret) (DELETE, GET)
  - [`/resources/stores/secret/{store_id}/secrets`](https://developer.fastly.com/reference/api/services/resources/secret) (GET, POST)
  - [`/resources/stores/secret/{store_id}`](https://developer.fastly.com/reference/api/services/resources/secret-store) (DELETE, GET)
  - [`/resources/stores/secret`](https://developer.fastly.com/reference/api/services/resources/secret-store) (GET, POST)
  - [`/roles/{role_id}/permissions`](https://developer.fastly.com/reference/api/account/roles) (DELETE, POST)
  - [`/roles/{role_id}`](https://developer.fastly.com/reference/api/account/roles) (PATCH)
  - [`/roles`](https://developer.fastly.com/reference/api/account/roles) (POST)
  - [`/service-authorizations`](https://developer.fastly.com/reference/api/account/service-authorization) (DELETE, PATCH)
  - [`/service-groups/{service_group_id}/services`](https://developer.fastly.com/reference/api/account/service-groups) (DELETE, POST)
  - [`/service-groups/{service_group_id}`](https://developer.fastly.com/reference/api/account/service-groups) (PATCH)
  - [`/service-groups`](https://developer.fastly.com/reference/api/account/service-groups) (POST)
  - [`/service/{service_id}/dictionary/{dictionary_id}/items`](https://developer.fastly.com/reference/api/dictionaries/dictionary-item) (PATCH)
  - [`/service/{service_id}/purge`](https://developer.fastly.com/reference/api/purging) (POST)
  - [`/service/{service_id}/version/{version_id}/apex-redirects`](https://developer.fastly.com/reference/api/vcl-services/apex-redirect) (POST)
  - [`/service/{service_id}/version/{version_id}/director/{director_name}`](https://developer.fastly.com/reference/api/load-balancing/directors/director) (PUT)
  - [`/service/{service_id}/version/{version_id}/generated_vcl/content`](https://developer.fastly.com/reference/api/vcl-services/vcl) (GET)
  - [`/service/{service_id}/version/{version_id}/logging/kafka/{logging_kafka_name}`](https://developer.fastly.com/reference/api/logging/kafka) (PUT)
  - [`/service/{service_id}/version/{version_id}/logging/kinesis/{logging_kinesis_name}`](https://developer.fastly.com/reference/api/logging/kinesis) (PUT)
  - [`/service/{service_id}/version/{version_id}/rate-limiters`](https://developer.fastly.com/reference/api/vcl-services/rate-limiter) (POST)
  - [`/service/{service_id}/version/{version_id}/request_settings`](https://developer.fastly.com/reference/api/vcl-services/request-settings) (POST)
  - [`/service/{service_id}/version/{version_id}/response_object/{response_object_name}`](https://developer.fastly.com/reference/api/vcl-services/response-object) (PUT)
  - [`/service/{service_id}/version/{version_id}/response_object`](https://developer.fastly.com/reference/api/vcl-services/response-object) (POST)
  - [`/service/{service_id}/version/{version_id}/snippet/{snippet_name}`](https://developer.fastly.com/reference/api/vcl-services/snippet) (PUT)
  - [`/service/{service_id}/version/{version_id}/vcl/{vcl_name}/content`](https://developer.fastly.com/reference/api/vcl-services/vcl) (GET)
  - [`/service/{service_id}/version/{version_id}/wafs/{firewall_id}`](https://developer.fastly.com/reference/api/legacy-waf/firewall) (GET, PATCH)
  - [`/service/{service_id}/version/{version_id}/wafs`](https://developer.fastly.com/reference/api/legacy-waf/firewall) (GET, POST)
  - [`/service/{service_id}/wafs/{firewall_id}/owasp`](https://developer.fastly.com/reference/api/legacy-waf/owasp) (GET, PATCH, POST)
  - [`/service/{service_id}/wafs/{firewall_id}/rule_statuses`](https://developer.fastly.com/reference/api/legacy-waf/rule-status) (GET, POST)
  - [`/service/{service_id}/wafs/{firewall_id}/rules/{waf_rule_id}/rule_status`](https://developer.fastly.com/reference/api/legacy-waf/rule-status) (GET, PATCH)
  - [`/service/{service_id}/wafs/{firewall_id}/ruleset/preview`](https://developer.fastly.com/reference/api/legacy-waf/ruleset) (GET)
  - [`/service/{service_id}/wafs/{firewall_id}/ruleset`](https://developer.fastly.com/reference/api/legacy-waf/ruleset) (GET, PATCH)
  - [`/service/{service_id}/wafs/{firewall_id}/update_statuses/{update_status_id}`](https://developer.fastly.com/reference/api/legacy-waf/update-status) (GET)
  - [`/service/{service_id}/wafs/{firewall_id}/update_statuses`](https://developer.fastly.com/reference/api/legacy-waf/update-status) (GET)
  - [`/sudo`](https://developer.fastly.com/reference/api/utils/sudo) (POST)
  - [`/tls/activations/{tls_activation_id}`](https://developer.fastly.com/reference/api/tls/mutual-tls/activations) (GET, PATCH)
  - [`/tls/activations`](https://developer.fastly.com/reference/api/tls/mutual-tls/activations) (GET)
  - [`/tokens`](https://developer.fastly.com/reference/api/auth-tokens/user) (DELETE, POST)
  - [`/user-groups/{user_group_id}/members`](https://developer.fastly.com/reference/api/account/user-groups) (DELETE, POST)
  - [`/user-groups/{user_group_id}/roles`](https://developer.fastly.com/reference/api/account/user-groups) (DELETE, POST)
  - [`/user-groups/{user_group_id}/service-groups`](https://developer.fastly.com/reference/api/account/user-groups) (DELETE, POST)
  - [`/user-groups/{user_group_id}`](https://developer.fastly.com/reference/api/account/user-groups) (PATCH)
  - [`/user-groups`](https://developer.fastly.com/reference/api/account/user-groups) (POST)
  - [`/v1/channel/{service_id}/ts/h/limit/{max_entries}`](https://developer.fastly.com/reference/api/metrics-stats/origin-insights) (GET)
  - [`/v1/channel/{service_id}/ts/h`](https://developer.fastly.com/reference/api/metrics-stats/origin-insights) (GET)
  - [`/v1/channel/{service_id}/ts/{start_timestamp}`](https://developer.fastly.com/reference/api/metrics-stats/origin-insights) (GET)
  - [`/v1/domains/{service_id}/ts/h/limit/{max_entries}`](https://developer.fastly.com/reference/api/metrics-stats/domain-inspector/real-time) (GET)
  - [`/v1/domains/{service_id}/ts/h`](https://developer.fastly.com/reference/api/metrics-stats/domain-inspector/real-time) (GET)
  - [`/v1/domains/{service_id}/ts/{start_timestamp}`](https://developer.fastly.com/reference/api/metrics-stats/domain-inspector/real-time) (GET)
  - [`/v1/origins/{service_id}/ts/h/limit/{max_entries}`](https://developer.fastly.com/reference/api/metrics-stats/origin-inspector/real-time) (GET)
  - [`/v1/origins/{service_id}/ts/h`](https://developer.fastly.com/reference/api/metrics-stats/origin-inspector/real-time) (GET)
  - [`/v1/origins/{service_id}/ts/{start_timestamp}`](https://developer.fastly.com/reference/api/metrics-stats/origin-inspector/real-time) (GET)
  - [`/waf/firewalls/{firewall_id}/versions/{version_id}/active-rules`](https://developer.fastly.com/reference/api/waf/rules/active) (DELETE)
  - [`/wafs/configuration_sets/{configuration_set_id}/relationships/wafs`](https://developer.fastly.com/reference/api/legacy-waf/configuration-set) (GET, PATCH)
  - [`/wafs/configuration_sets`](https://developer.fastly.com/reference/api/legacy-waf/configuration-set) (GET)
  - [`/wafs/rules/{waf_rule_id}/vcl`](https://developer.fastly.com/reference/api/legacy-waf/rule) (GET)
  - [`/wafs/rules/{waf_rule_id}`](https://developer.fastly.com/reference/api/legacy-waf/rule) (GET)
  - [`/wafs/rules`](https://developer.fastly.com/reference/api/legacy-waf/rule) (GET)
  - [`/wafs/tags`](https://developer.fastly.com/reference/api/legacy-waf/tag) (GET)
  - [`/wafs/{firewall_id}/disable`](https://developer.fastly.com/reference/api/legacy-waf/firewall) (PATCH)
  - [`/wafs/{firewall_id}/enable`](https://developer.fastly.com/reference/api/legacy-waf/firewall) (PATCH)
  - [`/wafs/{firewall_id}/rules/{waf_rule_id}/vcl`](https://developer.fastly.com/reference/api/legacy-waf/rule) (GET)
  - [`/wafs/{firewall_id}`](https://developer.fastly.com/reference/api/legacy-waf/firewall) (GET)
  - [`/wafs`](https://developer.fastly.com/reference/api/legacy-waf/firewall) (GET)
  If you encounter any non-security-related bug or unexpected behavior, please [file an issue][bug]
  using the bug report template.
  [bug]: https://github.com/fastly/fastly-py/issues/new?labels=bug

  Please see our [SECURITY.md](./SECURITY.md) for guidance on reporting security-related issues.

  [MIT](./LICENSE).


