# packages

pkgId: 071eccc2c77814f0d8be798711a6e5d46a00a7ee3578c2c9aa0795e4a7f97b23
name: python-manuel
arch: src
version: 1.12.4
epoch: 0
release: 1
summary: Manuel lets you build tested documentation.
url: http://pypi.python.org/pypi/manuel
rpm_license: Apache Software License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5d6a8288-40c3-4277-a144-e8d34672ccd1
location_href: 00004153-python-manuel/python-manuel-1.12.4-1.src.rpm
checksum_type: sha256
description:
  To work on Manuel, check out the code and then run `make` to build a development
  environment.
  To run the tests, run ``make test``. To run all checks, run ``make check``.
  See the `Makefile` for more useful targets.


pkgId: de451222e56633f987221ea4b43aac54c4f919499419fb2bf6c4d2bd96f25452
name: python-mapclassify
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Classification Schemes for Choropleth Maps.
url: https://github.com/pysal/mapclassify
rpm_license: 3-Clause BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e0c496bb-8885-430e-99b8-bb3c3aa0187e
location_href: 00004154-python-mapclassify/python-mapclassify-2.5.0-1.src.rpm
checksum_type: sha256
description:
  (   -inf,  -52.88] |     0
  ( -52.88,    2.57] |    15
  (   2.57,    9.36] |    14
  (   9.36,   39.53] |    14
  (  39.53,   94.97] |     6
  (  94.97, 4111.45] |     9
  ```

  ```python
  >>> mapclassify.EqualInterval(y)
  EqualInterval


pkgId: 1e84a7052559faaa26f0a06ec2c213cb3e3d5fc45f55c65e758b0ce5406e8414
name: python-marisa-trie
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Static memory-efficient and fast Trie-like structures for Python.
url: https://github.com/kmike/marisa-trie
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-504cc869-bca8-41ae-a2af-f715c65bb7fd
location_href: 00011378-python-marisa-trie/python-marisa-trie-0.8.0-1.src.rpm
checksum_type: sha256
description:
  Static memory-efficient Trie-like structures for Python (2.7 and 3.4+)
  based on `marisa-trie`_ C++ library.
  String data in a MARISA-trie may take up to 50x-100x less memory than
  in a standard Python dict; the raw lookup speed is comparable; trie also
  provides fast advanced methods like prefix search.
      There are official SWIG-based Python bindings included
      in C++ library distribution; this package provides alternative
      Cython-based pip-installable Python bindings.


pkgId: fac04e7d28e9d97ee2b776bc7ad12cb84aeafe48982660449cac325cbef7028f
name: python-marisa-trie-debuginfo
arch: aarch64
version: 0.8.0
epoch: 0
release: 1
summary: Debug information for package python-marisa-trie
url: https://github.com/kmike/marisa-trie
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-504cc869-bca8-41ae-a2af-f715c65bb7fd
rpm_sourcerpm: python-marisa-trie-0.8.0-1.src.rpm
location_href: 00011378-python-marisa-trie/python-marisa-trie-debuginfo-0.8.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-marisa-trie.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 777c5478bf0ca565b6b45696b72035e34403db5d7989df45d13099819492e5ea
name: python-marisa-trie-debugsource
arch: aarch64
version: 0.8.0
epoch: 0
release: 1
summary: Debug sources for package python-marisa-trie
url: https://github.com/kmike/marisa-trie
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-504cc869-bca8-41ae-a2af-f715c65bb7fd
rpm_sourcerpm: python-marisa-trie-0.8.0-1.src.rpm
location_href: 00011378-python-marisa-trie/python-marisa-trie-debugsource-0.8.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-marisa-trie.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 9a6c0bfb009fe1ffae4077563ad822bff1f23ccabf3f1d0bcf7aad98e86240cd
name: python-markdown-include
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: A Python-Markdown extension which provides an 'include' function
url: https://pypi.org/project/markdown-include/
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-06a28206-dd8b-4e65-aff2-92830de5be3b
location_href: 00012542-python-markdown-include/python-markdown-include-0.8.1-1.src.rpm
checksum_type: sha256
description:
  This is an extension to [Python-Markdown](https://pythonhosted.org/Markdown/)
  which provides an "include" function, similar to that found in
  LaTeX (and also the C pre-processor and Fortran). I originally wrote it for my
  [FORD](https://github.com/cmacmackin/ford) Fortran auto-documentation generator.



  This module can now be installed using ``pip``.

      pip install markdown-include


  Use the unittest module
  ```bash
  python -m unittest discover unittests/
  ```


  This module can be used in a program in the following way:

  ```python
  import markdown
  html = markdown.markdown(source, extensions=['markdown_include.include'])
  ```

  Markdown-Include can also be included in MkDocs projects like below:

  ```yaml
  markdown_extensions:
      - markdown_include.include:
          base_path: docs
  ```

  The syntax for use within your Markdown files is ``{!filename!}``. This
  statement will be replaced by the contents of ``filename``. Markdown-Include
  will work recursively, so any included files within ``filename`` will also be
  included. This replacement is done prior to any other
  Markdown processing, so any Markdown syntax that you want can be used within
  your included files. Note that this is a change from the previous version.
  It was felt that this syntax was less likely to conflict with any code
  fragments present in the Markdown.

  By default, all file-names are evaluated relative to the location from which
  Markdown is being called. If you would like to change the directory relative to
  which paths are evaluated, then this can be done by specifying the extension
  setting ``base_path``.



  You can also define specific lines or line ranges to include by specifying `lines`:

  ```Markdown
  {!filename!lines=1  3 8-10  2}
  ```

  `lines` takes a sequence of integers separated by spaces (one or more), or it can also
  take line ranges specified with a start line and an end line separated by a dash (`-`).

  In the example above, it would read the file called `filename` and include the lines
  `1`, `3`, `8`, `9`, `10`, `2`.

  Notice that line `9` was not explicitly set. But it was still included as part of the
  range `8-10`.

  Also, notice that line `2` is set *after* the range `8-10`. This means that the
  line `2` in `filename` will be included *after* (below) the range `8-10`.

  You can use this to include lines in a different order than the original file. But it
  also means that if you want to preserve the original order, you have to pay attention
  to the order in which you specify the lines.



  The following settings can be specified when initialising the plugin.

  - __base_path__: Default location from which to evaluate relative
    paths for the include statement. (Default: the run-directory.)
  - __encoding__: Encoding of the files used by the include statement. (Default: utf-8.)
  - __inheritHeadingDepth__ : If true, increases headings on include
    file by amount of previous heading. Combiens with headingOffset
    option, below. (Default: False.)
  - __headingOffset__: Increases heading depth by a specific ammount, in
    addition to the inheritHeadingDepth Option. (Default: 0)
  - __throwException__: When true, if the extension is unable to find an
    included file it will throw an exception which the user can
    catch. If false (default), a warning will be printed and Markdown
    will continue parsing the file.



  An example of setting the base path and file encoding is given below:
  ```python
  import markdown
  from markdown_include.include import MarkdownInclude


  markdown_include = MarkdownInclude(
      configs={'base_path':'/srv/content/', 'encoding': 'iso-8859-1'}
  )
  html = markdown.markdown(source, extensions=[markdown_include])
  ```

  Included files can inherit the heading depth of the location
  ``inheritHeadingDepth``, as well as receive a specific offset, ``headingOffset``
  For example, consider the  files
  ```markdown
  Source file


  {!included_file.md!}



  {!included_file.md!}
  ```

  and included_file.md

  ```markdown

  More included file content.
  End of included content.
  ```
  Then running the script
  ```python
  import markdown
  from markdown_include.include import MarkdownInclude


  markdown_include = MarkdownInclude(
      configs={'inheritHeadingDepth':True}
  )
  html = markdown.markdown(source, extensions=[markdown_include])
  ```
  produces
  ```html
  <p>Source file</p>
  <h1>Heading Level 1 of main file</h1>
  <h2>This heading will be one level deeper from the previous heading</h2>
  <p>More included file content.</p>
  <p>End of included content.</p>
  <h2>Heading Level 2 of main file</h2>
  <h3>This heading will be one level deeper from the previous heading</h3>
  <p>More included file content.</p>
  <p>End of included content.</p>
  ```




  Modified to work with Python-Markdown 3.4. This makes the plugin
  incompatible with versions < 3.0.

  - Added ability ot offset headers in the included file so they fall under the header level in which the include occurs
  - Add option to throw exception when can't find an include file (instead of printing a warning)
  - Fixed stripping of last character in file, so only occurs if it is a new-line
  - Some behind-the-scenes improvement to code and documentation

  Bugfix for a syntax error.

  Corrected some errors in documentation and merged in commits of
  [diegobz](https://github.com/diegobz) to add support for encoding and tidy up
  the source code.

  Fixed problem related to passing configurations to the extension.

  Added support for Python 3.

  Changed the API to be less likely to conflict with other syntax.

  Initial release.


pkgId: 31539c3d14a234447d0e50f6578ed22a4eab75cb71dad4bc1a8f83299972e47e
name: python-markdown2
arch: src
version: 2.4.8
epoch: 0
release: 1
summary: A fast and complete Python implementation of Markdown
url: https://github.com/trentm/python-markdown2
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-da6ad51b-4103-4931-b97b-cbd196b7160e
location_href: 00007504-python-markdown2/python-markdown2-2.4.8-1.src.rpm
checksum_type: sha256
description:
  markdown2: A fast and complete Python implementation of Markdown.

  Markdown is a text-to-HTML filter; it translates an easy-to-read /
  easy-to-write structured text format into HTML.  Markdown's text
  format is most similar to that of plain text email, and supports
  features such as headers, *emphasis*, code blocks, blockquotes, and
  links.  -- http://daringfireball.net/projects/markdown/

  This is a fast and complete Python implementation of the Markdown
  spec. See http://github.com/trentm/python-markdown2 for more info.


pkgId: c9a8dbd81c9fe4313c495eacbc2a2bcc99387aaacd0e8f43d89432b963449527
name: python-marketorestpython
arch: src
version: 0.5.23
epoch: 0
release: 1
summary: Python Client for the Marketo REST API
url: https://github.com/jepcastelein/marketo-rest-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd0dd944-9588-4719-8dae-f38a1a4bfb55
location_href: 00011800-python-marketorestpython/python-marketorestpython-0.5.23-1.src.rpm
checksum_type: sha256
description:
  Marketo Python REST is a Python client that wraps the Marketo Rest API.
  Originally developed by asamat with contributions from sandipsinha and osamakhn


pkgId: e177b993a18a1d93c66f0a1e471bc355af9578bd8f53c91e932726e759919108
name: python-marshmallow-jsonschema
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: JSON Schema Draft v7 (http://json-schema.org/) formatting with marshmallow
url: https://github.com/fuhrysteve/marshmallow-jsonschema
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-14cae044-6342-4304-a41e-fd902a0176a7
location_href: 00012882-python-marshmallow-jsonschema/python-marshmallow-jsonschema-0.13.0-1.src.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/fuhrysteve/marshmallow-jsonschema/workflows/build/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/fuhrysteve/marshmallow-jsonschema/badge.svg?branch=master)](https://coveralls.io/github/fuhrysteve/marshmallow-jsonschema?branch=master)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)

   marshmallow-jsonschema translates marshmallow schemas into
   JSON Schema Draft v7 compliant jsonschema. See http://json-schema.org/



  What are the use cases for this? Let's say you have a
  marshmallow schema in python, but you want to render your
  schema as a form in another system (for example: a web browser
  or mobile device).



  Requires python>=3.6 and marshmallow>=3.11. (For python 2 & marshmallow 2 support, please use marshmallow-jsonschema<0.11)

  ```
  pip install marshmallow-jsonschema
  ```



  * [react-jsonschema-form](https://github.com/mozilla-services/react-jsonschema-form) (recommended)
    * See below extension for this excellent library!
  * https://github.com/brutusin/json-forms
  * https://github.com/jdorn/json-editor
  * https://github.com/ulion/jsonform





  ```python
  from marshmallow import Schema, fields
  from marshmallow_jsonschema import JSONSchema

  class UserSchema(Schema):
      username = fields.String()
      age = fields.Integer()
      birthday = fields.Date()

  user_schema = UserSchema()

  json_schema = JSONSchema()
  json_schema.dump(user_schema)
  ```

  Yields:

  ```python
  {'properties': {'age': {'format': 'integer',
                          'title': 'age',
                          'type': 'number'},
                  'birthday': {'format': 'date',
                               'title': 'birthday',
                               'type': 'string'},
                  'username': {'title': 'username', 'type': 'string'}},
   'required': [],
   'type': 'object'}
  ```



  ```python
  from marshmallow import Schema, fields
  from marshmallow_jsonschema import JSONSchema
  from tests import UserSchema


  class Athlete(object):
      user_schema = UserSchema()

      def __init__(self):
          self.name = 'sam'


  class AthleteSchema(Schema):
      user_schema = fields.Nested(JSONSchema)
      name = fields.String()


  athlete = Athlete()
  athlete_schema = AthleteSchema()

  athlete_schema.dump(athlete)
  ```



  ![Screenshot](http://i.imgur.com/jJv1wFk.png)

  This example renders a form not dissimilar to how [wtforms](https://github.com/wtforms/wtforms) might render a form.

  However rather than rendering the form in python, the JSON Schema is rendered using the
  javascript library [brutusin/json-forms](https://github.com/brutusin/json-forms).


  ```python
  from flask import Flask, jsonify
  from marshmallow import Schema, fields
  from marshmallow_jsonschema import JSONSchema

  app = Flask(__name__)


  class UserSchema(Schema):
      name = fields.String()
      address = fields.String()


  @app.route('/schema')
  def schema():
      schema = UserSchema()
      return jsonify(JSONSchema().dump(schema))


  @app.route('/')
  def home():
      return '''<!DOCTYPE html>
  <head>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/brutusin.json-forms/1.3.0/css/brutusin-json-forms.css"><Paste>
  <script src="https://code.jquery.com/jquery-1.12.1.min.js" integrity="sha256-I1nTg78tSrZev3kjvfdM5A5Ak/blglGzlaZANLPDl3I=" crossorigin="anonymous"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.string/3.3.4/underscore.string.min.js"></script>
  <script src="https://cdn.jsdelivr.net/brutusin.json-forms/1.3.0/js/brutusin-json-forms.min.js"></script>
  <script>
  $(document).ready(function() {
      $.ajax({
          url: '/schema'
          , success: function(data) {
              var container = document.getElementById('myform');
              var BrutusinForms = brutusin["json-forms"];
              var bf = BrutusinForms.create(data);
              bf.render(container);
          }
      });
  });
  </script>
  </head>
  <body>
  <div id="myform"></div>
  </body>
  </html>
  '''


  if __name__ == '__main__':
      app.run(host='0.0.0.0', debug=True)

  ```





  Simply add a `_jsonschema_type_mapping` method to your field
  so we know how it ought to get serialized to JSON Schema.

  A common use case for this is creating a dropdown menu using
  enum (see Gender below).


  ```python
  class Colour(fields.Field):

      def _jsonschema_type_mapping(self):
          return {
              'type': 'string',
          }

      def _serialize(self, value, attr, obj):
          r, g, b = value
          r = "%02X" % (r,)
          g = "%02X" % (g,)
          b = "%02X" % (b,)
          return '#' + r + g + b

  class Gender(fields.String):
      def _jsonschema_type_mapping(self):
          return {
              'type': 'string',
              'enum': ['Male', 'Female']
          }


  class UserSchema(Schema):
      name = fields.String(required=True)
      favourite_colour = Colour()
      gender = Gender()

  schema = UserSchema()
  json_schema = JSONSchema()
  json_schema.dump(schema)
  ```




  [react-jsonschema-form](https://react-jsonschema-form.readthedocs.io/en/latest/)
  is a library for rendering jsonschemas as a form using React. It is very powerful
  and full featured.. the catch is that it requires a proprietary
  [`uiSchema`](https://react-jsonschema-form.readthedocs.io/en/latest/form-customization/#the-uischema-object)
  to provide advanced control how the form is rendered.
  [Here's a live playground](https://rjsf-team.github.io/react-jsonschema-form/)

  *(new in version 0.10.0)*

  ```python
  from marshmallow_jsonschema.extensions import ReactJsonSchemaFormJSONSchema

  class MySchema(Schema):
      first_name = fields.String(
          metadata={
              'ui:autofocus': True,
          }
      )
      last_name = fields.String()

      class Meta:
          react_uischema_extra = {
              'ui:order': [
                  'first_name',
                  'last_name',
              ]
          }


  json_schema_obj = ReactJsonSchemaFormJSONSchema()
  schema = MySchema()


  data = json_schema_obj.dump(schema)


  ui_schema_json = json_schema_obj.dump_uischema(schema)


pkgId: 7c8c778e2bbc6647fc0c8770462af481adc7307a10d77f7b59d5995715f25c04
name: python-marshmallow-sqlalchemy
arch: src
version: 0.29.0
epoch: 0
release: 1
summary: SQLAlchemy integration with the marshmallow (de)serialization library
url: https://github.com/marshmallow-code/marshmallow-sqlalchemy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-65b6b284-fb2d-4b7f-8176-9308caeceb4b
location_href: 00009311-python-marshmallow-sqlalchemy/python-marshmallow-sqlalchemy-0.29.0-1.src.rpm
checksum_type: sha256
description:
      import sqlalchemy as sa
      from sqlalchemy.ext.declarative import declarative_base
      from sqlalchemy.orm import scoped_session, sessionmaker, relationship, backref
      engine = sa.create_engine("sqlite:///:memory:")
      session = scoped_session(sessionmaker(bind=engine))
      Base = declarative_base()
      class Author(Base):
          __tablename__ = "authors"
          id = sa.Column(sa.Integer, primary_key=True)
          name = sa.Column(sa.String, nullable=False)
          def __repr__(self):
              return "<Author(name={self.name!r})>".format(self=self)
      class Book(Base):
          __tablename__ = "books"
          id = sa.Column(sa.Integer, primary_key=True)
          title = sa.Column(sa.String)
          author_id = sa.Column(sa.Integer, sa.ForeignKey("authors.id"))
          author = relationship("Author", backref=backref("books"))
      Base.metadata.create_all(engine)


pkgId: 981fdfded9010474ab128a21ae51d3efd5f2fa20e819f5821550136a89752674
name: python-marshmallow3-annotations
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Marrying marshmallow3 and annotations
url: https://github.com/dkunitsk/marshmallow3-annotations
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-74305249-1426-403e-9cbe-e283639242fa
location_href: 00011433-python-marshmallow3-annotations/python-marshmallow3-annotations-1.1.0-1.src.rpm
checksum_type: sha256
description:
  This is a fork of [marshmallow-annotations](https://github.com/justanr/marshmallow-annotations) which has been minimally
  patched to be marshmallow 3.0.0+ compatible. All credit goes to the original author.

  It is available on [PyPI](https://pypi.org/project/marshmallow3-annotations/).


pkgId: d280423447910e036c57e0755cb837b8836260c30296fb47d7d30ee94b073f99
name: python-mashumaro
arch: src
version: 3.6
epoch: 0
release: 1
summary: Fast serialization library on top of dataclasses
url: https://github.com/Fatal1ty/mashumaro
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d8879999-7ad6-4ac1-9f4a-e9fcdad5f8a3
location_href: 00009677-python-mashumaro/python-mashumaro-3.6-1.src.rpm
checksum_type: sha256
description:
  * [Installation](#installation)
  * [Changelog](#changelog)
  * [Supported serialization formats](#supported-serialization-formats)
  * [Supported data types](#supported-data-types)
  * [Usage example](#usage-example)
  * [How does it work?](#how-does-it-work)
  * [Benchmark](#benchmark)
  * [Serialization mixins](#serialization-mixins)
    * [`DataClassDictMixin`](#dataclassdictmixin)
    * [`DataClassJSONMixin`](#dataclassjsonmixin)
    * [`DataClassORJSONMixin`](#dataclassorjsonmixin)
    * [`DataClassMessagePackMixin`](#dataclassmessagepackmixin)
    * [`DataClassYAMLMixin`](#dataclassyamlmixin)
    * [`DataClassTOMLMixin`](#dataclasstomlmixin)
  * [Customization](#customization)
      * [`SerializableType` interface](#serializabletype-interface)
        * [User-defined types](#user-defined-types)
        * [User-defined generic types](#user-defined-generic-types)
      * [`SerializationStrategy`](#serializationstrategy)
        * [Third-party types](#third-party-types)
        * [Third-party generic types](#third-party-generic-types)
      * [Field options](#field-options)
          * [`serialize` option](#serialize-option)
          * [`deserialize` option](#deserialize-option)
          * [`serialization_strategy` option](#serialization_strategy-option)
          * [`alias` option](#alias-option)
      * [Config options](#config-options)
          * [`debug` config option](#debug-config-option)
          * [`code_generation_options` config option](#code_generation_options-config-option)
          * [`serialization_strategy` config option](#serialization_strategy-config-option)
          * [`aliases` config option](#aliases-config-option)
          * [`serialize_by_alias` config option](#serialize_by_alias-config-option)
          * [`omit_none` config option](#omit_none-config-option)
          * [`namedtuple_as_dict` config option](#namedtuple_as_dict-config-option)
          * [`allow_postponed_evaluation` config option](#allow_postponed_evaluation-config-option)
          * [`dialect` config option](#dialect-config-option)
          * [`orjson_options`](#orjson_options-config-option)
      * [Passing field values as is](#passing-field-values-as-is)
      * [Dialects](#dialects)
        * [`serialization_strategy` dialect option](#serialization_strategy-dialect-option)
        * [`omit_none` dialect option](#omit_none-dialect-option)
        * [Changing the default dialect](#changing-the-default-dialect)
      * [Code generation options](#code-generation-options)
          * [Add `omit_none` keyword argument](#add-omit_none-keyword-argument)
          * [Add `by_alias` keyword argument](#add-by_alias-keyword-argument)
          * [Add `dialect` keyword argument](#add-dialect-keyword-argument)
      * [Generic dataclasses](#generic-dataclasses)
        * [Generic dataclass inheritance](#generic-dataclass-inheritance)
        * [Generic dataclass in a field type](#generic-dataclass-in-a-field-type)
      * [`GenericSerializableType` interface](#genericserializabletype-interface)
      * [Serialization hooks](#serialization-hooks)
          * [Before deserialization](#before-deserialization)
          * [After deserialization](#after-deserialization)
          * [Before serialization](#before-serialization)
          * [After serialization](#after-serialization)
  * [JSON Schema](#json-schema)
      * [Building JSON Schema](#building-json-schema)
      * [JSON Schema constraints](#json-schema-constraints)
      * [Extending JSON Schema](#extending-json-schema)
      * [JSON Schema and custom serialization methods](#json-schema-and-custom-serialization-methods)


pkgId: c8849b4fc293942d216d67043627900eb80a3fa58dabf0c16b95f582ceb46604
name: python-matplotlib-inline
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Inline Matplotlib backend for Jupyter
url: https://github.com/ipython/matplotlib-inline
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-075bda95-adca-4fde-b084-2d7647577705
location_href: 00009034-python-matplotlib-inline/python-matplotlib-inline-0.1.6-1.src.rpm
checksum_type: sha256
description:
  This package provides support for matplotlib to display figures directly inline in the Jupyter notebook and related clients, as shown below.



  With conda:

  ```bash
  conda install -c conda-forge matplotlib-inline
  ```

  With pip:

  ```bash
  pip install matplotlib-inline
  ```



  Note that in current versions of JupyterLab and Jupyter Notebook, the explicit use of the `%matplotlib inline` directive is not needed anymore, though other third-party clients may still require it.

  This will produce a figure immediately below:

  ```python
  %matplotlib inline

  import matplotlib.pyplot as plt
  import numpy as np

  x = np.linspace(0, 3*np.pi, 500)
  plt.plot(x, np.sin(x**2))
  plt.title('A simple chirp');
  ```



  Licensed under the terms of the BSD 3-Clause License, by the IPython Development Team (see `LICENSE` file).

  BSD 3-Clause License

  Copyright (c) 2019-2022, IPython Development Team.
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

  1. Redistributions of source code must retain the above copyright notice, this
     list of conditions and the following disclaimer.

  2. Redistributions in binary form must reproduce the above copyright notice,
     this list of conditions and the following disclaimer in the documentation
     and/or other materials provided with the distribution.

  3. Neither the name of the copyright holder nor the names of its
     contributors may be used to endorse or promote products derived from
     this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: c4b26314f21576efb50e2126b924e8e6ce5228f5bad0a2dc952f37fa720effdd
name: python-matplotlib-scalebar
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Artist for matplotlib to display a scale bar
url: https://github.com/ppinard/matplotlib-scalebar
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95a6182d-be81-441c-a3f2-9344467aff5d
location_href: 00004171-python-matplotlib-scalebar/python-matplotlib-scalebar-0.8.1-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/ppinard/matplotlib-scalebar/workflows/CI/badge.svg)
  ![PyPI](https://img.shields.io/pypi/v/matplotlib-scalebar)

  Provides a new artist for [matplotlib](https://matplotlib.org) to display a scale bar, aka micron bar.
  It is particularly useful when displaying calibrated images plotted using
  `plt.imshow(...)`.

  ![Example of scale bar](doc/splashscreen.png)

  The artist supports customization either directly from the **ScaleBar** object or from the matplotlibrc.



  Easiest way to install using `pip`:

  ```bash
  pip install matplotlib-scalebar
  ```

  For development installation from the git repository:

  ```bash
  git clone git@github.com:ppinard/matplotlib-scalebar.git
  pip install -e matplotlib-scalebar
  ```



  There are many ways to customize the scale bar.
  Examples and explanations of the arguments of the **ScaleBar** class are given [below](#scalebar-arguments), but here is a quick start guide.

  The constructor arguments *dx* and *units* specify the pixel dimension.
  For example `ScaleBar(0.2, 'um')` indicates that each pixel is equal to 0.2 micrometer.
  By default, the scale bar uses SI units of length (e.g. m, cm, um, km, etc.).
  See examples below for other system of units.

  In this example, we load a sample image from the matplotlib library, create a subplot, plot image, create scale bar and add scale bar as an "artist" of the subplot.

  ```python
  import numpy as np
  import matplotlib.pyplot as plt
  import matplotlib.cbook as cbook
  from matplotlib_scalebar.scalebar import ScaleBar


  with cbook.get_sample_data("s1045.ima.gz") as dfile:
      im = np.frombuffer(dfile.read(), np.uint16).reshape((256, 256))


  fig, ax = plt.subplots()
  ax.axis("off")


  ax.imshow(im, cmap="gray")


  scalebar = ScaleBar(0.08, "cm", length_fraction=0.25)
  ax.add_artist(scalebar)


  plt.show()
  ```

  ![Example of scale bar](doc/getting_started.png)



  Here are arguments of the **ScaleBar** class constructor and examples how to use them.

  ```python
  scalebar = ScaleBar(
          dx,
          units="m",
          dimension="si-length",
          label=None,
          length_fraction=None,
          height_fraction=None,
          width_fraction=None,
          location=None,
          pad=None,
          border_pad=None,
          sep=None,
          frameon=None,
          color=None,
          box_color=None,
          box_alpha=None,
          scale_loc=None,
          label_loc=None,
          font_properties=None,
          label_formatter=None,
          scale_formatter=None,
          fixed_value=None,
          fixed_units=None,
          animated=False,
          rotation=None,
      )
  ```

  Each argument can also be changed afterwards using their respective property.

  ```python
  scalebar.dx = 2.0
  ```

  The following schematic illustrates the nomenclature used in the definition of the arguments.

  ![nomenclature](doc/nomenclature.png)



  Size of one pixel in *units* specified by the next argument.

  Set *dx* to 1.0 if the axes image has already been calibrated by setting its *extent*.

  ```python
  fig, ax = plt.subplots()
  ax.axis("off")

  ax.imshow(im, cmap="gray", extent=[0, 20.48, 0, 20.48])

  scalebar = ScaleBar(1, "cm", length_fraction=0.25)
  ax.add_artist(scalebar)
  ```

  ![dx with extent](doc/argument_dx.png)

  **Special notes for geospatial plots**:
  If you are plotting geospatial coordinates (such as scatterplots of the location of structures, [geopandas](http://geopandas.org) geodataframe plots, etc.), *dx* needs to be set differently depending on the coordinate system:

  * For UTM based coordinate system, where the X and Y are in meters, simply set `dx = 1`.
  * For WGS or NAD based coordinate system, where X and Y are in latitude (Y) and longitude (X), compute the distance between two points at the latitude (Y) you wish to have the scale represented and are also one full degree of longitude (X) apart, in meters. For example, `dx = great_circle_distance((X, Y), (X + 1, Y))`



  Units of *dx*.
  The units needs to be valid for the specified *dimension*.
  Default: `m`.



  Dimension of *dx* and *units*. It can either be equal:

  * `si-length` (default): scale bar showing km, m, cm, etc.
  * `imperial-length`: scale bar showing in, ft, yd, mi, etc.
  * `si-length-reciprocal`: scale bar showing 1/m, 1/cm, etc.
  * `pixel-length`: scale bar showing px, kpx, Mpx, etc.
  * `angle`: scale bar showing °, ʹ (minute of arc) or ʹʹ (second of arc)
  * a `matplotlib_scalebar.dimension._Dimension` object

  ```python
  fig, ax = plt.subplots()
  ax.axis("off")

  ax.imshow(im, cmap="gray")

  scalebar = ScaleBar(0.0315, "in", dimension="imperial-length", length_fraction=0.25)
  ax.add_artist(scalebar)
  ```

  ![imperial dimension](doc/argument_dimension.png)



  Optional label associated with the scale bar.
  Default: `None`, no label is shown.
  The position of the label with respect to the scale bar can be adjusted using *label_loc* argument.



  Desired length of the scale bar as a fraction of the subplot's width.
  Default: `None`, value from matplotlibrc or `0.2`.
  The actual length of the scale bar is automatically determined based on the specified pixel size (*dx* and *units*) and the contraint that the scale value can only take the following numbers: 1, 2, 5, 10, 15, 20, 25, 50, 75, 100, 125, 150, 200, 500 or 750.
  If you want a specific value, see [*fixed_value*](#fixed_value) and [*fixed_units*](#fixed_units).

  In the example below, the scale bar for a *length_fraction* of 0.25 and 0.5 is the same because the scale cannot have a value between 2 and 5 mm.

  ![length fraction](doc/argument_length_fraction.png)



  **Deprecated**, use *width_fraction*.



  Width of the scale bar as a fraction of the subplot's height.
  Default: `None`, value from matplotlibrc or `0.01`.



  A location code, same as matplotlib's legend, either: `upper right`, `upper left`, `lower left`, `lower right`, `right`, `center left`, `center right`, `lower center`, `upper center` or `center`.
  Default: `None`, value from matplotlibrc or `upper right`.



  Alias for *location*.



  Padding inside the box, as a fraction of the font size.
  Default: `None`, value from matplotlibrc or `0.2`.



  Padding outside the box, fraction of the font size.
  Default: `None`, value from matplotlibrc or `0.1`.



  Separation in points between the scale bar and scale, and between the scale bar and label.
  Default: `None`, value from matplotlibrc or `5`.



  Whether to draw a box behind the scale bar, scale and label.
  Default: `None`, value from matplotlibrc or `True`.



  Color for the scale bar, scale and label.
  Default: `None`, value from matplotlibrc or `k` (black).



  Background color of the box.
  Default: `None`, value from matplotlibrc or `w` (white).



  Transparency of box.
  Default: `None`, value from matplotlibrc or `1.0` (opaque).



  Location of the scale with respect to the scale bar.
  Either `bottom`, `top`, `left`, `right`, `none`.
  Default: `None`, value from matplotlibrc or `bottom`.
  If `"none"`, no scale is shown.

  ![scale_loc](doc/argument_scale_loc.png)



  Location of the label with respect to the scale bar.
  Either `bottom`, `top`, `left`, `right`, `none`.
  Default: `None`, value from matplotlibrc or `top`.
  If `"none"`, no label is shown.



  Font properties of the scale and label text, specified either as `dict` or `str`.
  See [`FontProperties`](https://matplotlib.org/api/font_manager_api.html#matplotlib.font_manager.FontProperties) for the arguments.
  Default: `None`, default font properties of matplotlib.



  **Deprecated**, use *scale_formatter*.



  Custom function called to format the scale.
  Needs to take 2 arguments - the scale value and the unit.
  Default: `None` which results in

  ```python
  scale_formatter = lambda value, unit: f"{value} {unit}"
  ```



  Value for the scale.
  The length of the scale bar is calculated based on the specified pixel size *dx*.
  Default: `None`, the value is automatically determined based on *length_fraction*.



  Units of the *fixed_value*.
  Default: `None`, if *fixed value* is not `None`, the units of *dx* are used.



  Animation state.
  Default: `False`



  Whether to create a scale bar based on the x-axis (default) or y-axis.
  *rotation* can either be `horizontal` or `vertical`.
  Note you might have to adjust *scale_loc* and *label_loc* to achieve desired layout.
  Default: `None`, value from matplotlibrc or `horizontal`.

  ```python
  fig, ax = plt.subplots()
  ax.axis("off")

  ax.imshow(im, cmap="gray")

  scalebar = ScaleBar(
      0.08,
      "cm",
      length_fraction=0.25,
      rotation="vertical",
      scale_loc="right",
      border_pad=1,
      pad=0.5,
  )
  ax.add_artist(scalebar)
  ```

  ![rotation](doc/argument_rotation.png)





  * Remove useless shebangs ([#47][i47])
  * Correct License trove classifier ([#48][i48])



  * Fix missing `_all_deprecated` in future matplotlib (> 3.5) ([#44][i44])
  * Add ability to hide scale and label ([#41][i41])



  * Fix deprecation warning in matplotlib >= 3.4 of `minimumdescent` ([#36][i36])



  * Fix scalebar location validation from rcParams ([#35](i35))



  * Add rotation to display scale bar for the y-axis ([#30][i30])
  * New documentation ([#32][i32])
  * Deprecate argument *height_fraction*, replaced by *width_fraction* ([#32][i32])
  * Deprecate argument *label_formatter*, replaced by *scale_formatter* ([#32][i32])
  * Add alias *loc* for *location* ([#32][i32])
  * Fix deprecation warning in matplotlib >= 3.3 of `validate_legend_loc` ([#33][i33])



  * Fix reciprocal unit ([#29][i29])



  * Add notes about for geospatial plots ([#20][i20])



  * Add angular units ([#19][i19])
  * Add blit support and fix documentation ([#22][i22])
  * Fix issue with getting the wrong preferred values for the scale bar ([#23][i23])
  * Package LICENSE file to distribution ([#24][i24])



  * Remove leftover print statement ([#18][i18])



  * Add pixel unit ([#12][i12])
  * Display micro symbol in text mode ([#15][i15])
  * Fix error in length of scale bar; the bar was drawn with an edge around it which made it longer than the actual size ([#14][i14])



  * Fix deprecated usage of is_string_like ([#11][i11])



  * Add possibility to specified a fixed value for the scale bar ([#9][i9])



  [@maweigert](https://github.com/maweigert),
  [@crosbyla](https://github.com/crosbyla),
  [@joschkazj](https://github.com/joschkazj),
  [@AKuederle](https://github.com/AKuederle),
  [@habi](https://github.com/habi),
  [@huangziwei](https://github.com/huangziwei),
  [@SirJohnFranklin](https://github.com/SirJohnFranklin),
  [@alexandrejaguar](https://github.com/alexandrejaguar),
  [@parishcm](https://github.com/parishcm),
  [@wiai](https://github.com/wiai),
  [@cosmicshear](https://github.com/cosmicshear),
  [@ericore](https://github.com/ericore),
  [@seangrogan](https://github.com/seangrogan),
  [@PhilipeRLeal](https://github.com/PhilipeRLeal),
  [@din14970](https://github.com/din14970),
  [@SarthakJariwala](https://github.com/SarthakJariwala),
  [@k1moradi](https://github.com/k1moradi),
  [@anntzer](https://github.com/anntzer),
  [@bugalo](https://github.com/bugalo),
  [@musicinmybrain](https://github.com/musicinmybrain)



  License under the BSD License, compatible with matplotlib.

  Copyright (c) 2015-2022 Philippe Pinard

  [i9]: https://github.com/ppinard/matplotlib-scalebar/issues/9
  [i11]: https://github.com/ppinard/matplotlib-scalebar/issues/11
  [i12]: https://github.com/ppinard/matplotlib-scalebar/issues/12
  [i14]: https://github.com/ppinard/matplotlib-scalebar/issues/14
  [i15]: https://github.com/ppinard/matplotlib-scalebar/issues/15
  [i18]: https://github.com/ppinard/matplotlib-scalebar/issues/18
  [i19]: https://github.com/ppinard/matplotlib-scalebar/issues/19
  [i20]: https://github.com/ppinard/matplotlib-scalebar/issues/20
  [i22]: https://github.com/ppinard/matplotlib-scalebar/issues/22
  [i23]: https://github.com/ppinard/matplotlib-scalebar/issues/23
  [i24]: https://github.com/ppinard/matplotlib-scalebar/issues/24
  [i29]: https://github.com/ppinard/matplotlib-scalebar/issues/29
  [i30]: https://github.com/ppinard/matplotlib-scalebar/issues/30
  [i32]: https://github.com/ppinard/matplotlib-scalebar/issues/32
  [i33]: https://github.com/ppinard/matplotlib-scalebar/issues/33
  [i35]: https://github.com/ppinard/matplotlib-scalebar/issues/35
  [i36]: https://github.com/ppinard/matplotlib-scalebar/issues/36
  [i41]: https://github.com/ppinard/matplotlib-scalebar/issues/41
  [i44]: https://github.com/ppinard/matplotlib-scalebar/pull/44
  [i47]: https://github.com/ppinard/matplotlib-scalebar/pull/47
  [i48]: https://github.com/ppinard/matplotlib-scalebar/pull/48


pkgId: a1458a8961d2c75d0bd627a9f23efd94c43483aad3c943e9a57cc67f9289eec9
name: python-matrix-nio
arch: src
version: 0.20.1
epoch: 0
release: 1
summary: A Python Matrix client library, designed according to sans I/O principles.
url: https://github.com/poljar/matrix-nio
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c2927159-907b-43be-ba75-6746a5e4873e
location_href: 00004173-python-matrix-nio/python-matrix-nio-0.20.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/github/workflow/status/poljar/matrix-nio/Build%20Status?style=flat-square)](https://github.com/poljar/matrix-nio/actions)
  [![codecov](https://img.shields.io/codecov/c/github/poljar/matrix-nio/master.svg?style=flat-square)](https://codecov.io/gh/poljar/matrix-nio)
  [![license](https://img.shields.io/badge/license-ISC-blue.svg?style=flat-square)](https://github.com/poljar/matrix-nio/blob/master/LICENSE.md)
  [![Documentation Status](https://readthedocs.org/projects/matrix-nio/badge/?version=latest&style=flat-square)](https://matrix-nio.readthedocs.io/en/latest/?badge=latest)
  [![#nio](https://img.shields.io/badge/matrix-%23nio:matrix.org-blue.svg?style=flat-square)](https://matrix.to/#/!JiiOHXrIUCtcOJsZCa:matrix.org?via=matrix.org&via=maunium.net&via=t2l.io)
  nio is a multilayered [Matrix](https://matrix.org/) client library. The
  underlying base layer doesn't do any network IO on its own, but on top of that
  is a full fledged batteries-included asyncio layer using
  [aiohttp](https://github.com/aio-libs/aiohttp/). File IO is only done if you
  enable end-to-end encryption (E2EE).


pkgId: d8b4d275437a80aebf8cf0af2f2f236443f7ba5f1c3bdf16806f992ad8da1007
name: python-matrix-synapse-ldap3
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: An LDAP3 auth provider for Synapse
url: https://github.com/matrix-org/matrix-synapse-ldap3
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b930477d-04fc-4bbf-b2ab-a3396bac2c62
location_href: 00004174-python-matrix-synapse-ldap3/python-matrix-synapse-ldap3-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Allows synapse to use LDAP as a password provider.
  This allows users to log in to synapse with their username and password from an
  LDAP server. There is also ma1sd (https://github.com/ma1uta/ma1sd) (3rd party)
  that offers more fully-featured integration.


pkgId: 341d4cfd08cafe449408ab945955825002ad40584dfc27b350544074cf9e3162
name: python-matrixprofile-debuginfo
arch: aarch64
version: 1.1.10
epoch: 0
release: 1
summary: Debug information for package python-matrixprofile
url: https://github.com/matrix-profile-foundation/matrixprofile
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-b9d24aff-6305-4449-9e0f-9292ab021e4a
rpm_sourcerpm: python-matrixprofile-1.1.10-1.src.rpm
location_href: 00011253-python-matrixprofile/python-matrixprofile-debuginfo-1.1.10-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-matrixprofile.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 0c86a51d97accecc95cb3a71944fe28247b1af09ef1439d3283e74c2133d90a7
name: python-matrixprofile-debugsource
arch: aarch64
version: 1.1.10
epoch: 0
release: 1
summary: Debug sources for package python-matrixprofile
url: https://github.com/matrix-profile-foundation/matrixprofile
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-b9d24aff-6305-4449-9e0f-9292ab021e4a
rpm_sourcerpm: python-matrixprofile-1.1.10-1.src.rpm
location_href: 00011253-python-matrixprofile/python-matrixprofile-debugsource-1.1.10-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-matrixprofile.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 3c6af6fc8c49b693b20e623cf83e4e1599857b2bfcd226ab2ce7d7300bb509e5
name: python-maya
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Datetimes for Humans.
url: https://github.com/kennethreitz/maya
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-685bed0c-06ec-49ae-bf4f-d2dd10a79461
location_href: 00012217-python-maya/python-maya-0.6.1-1.src.rpm
checksum_type: sha256
description:
  Datetimes are very frustrating to work with in Python, especially when dealing
  with different locales on different systems. This library exists to make the
  simple things **much** easier, while admitting that time is an illusion
  (timezones doubly so).
  Datetimes should be interacted with via an API written for humans.
  Maya is mostly built around the headaches and use-cases around parsing datetime data from websites.
  Art by `Sam Flores
  <https://www.instagram.com/samagram12/>`_ (Photo by `Kenneth Reitz
  <https://www.instagram.com/kennethreitz/>`_).
  If you're interested in financially supporting Kenneth Reitz open source, consider `visiting this link <https://cash.me/$KennethReitz>`_. Your support helps tremendously with sustainability of motivation, as Open Source is no longer part of my day job.


pkgId: 329b6a00755a80f8d6a465309ded948366307343737d9edc3c69f784d7714809
name: python-mbed-tools
arch: src
version: 7.59.0
epoch: 0
release: 1
summary: Command line interface for Mbed OS.
url: https://github.com/ARMmbed/mbed-tools
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ac500b7d-3dd1-4c5b-831f-02101bd78866
location_href: 00011191-python-mbed-tools/python-mbed-tools-7.59.0-1.src.rpm
checksum_type: sha256
description:
  ![Package](https://badgen.net/badge/Package/mbed-tools/grey)
  [![Documentation](https://badgen.net/badge/Documentation/GitHub%20Pages/blue?icon=github)](https://armmbed.github.io/mbed-tools/api/)
  [![PyPI](https://badgen.net/pypi/v/mbed-tools)](https://pypi.org/project/mbed-tools/)
  [![PyPI - Status](https://img.shields.io/pypi/status/mbed-tools)](https://pypi.org/project/mbed-tools/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mbed-tools)](https://pypi.org/project/mbed-tools/)

  [![License](https://badgen.net/pypi/license/mbed-tools)](https://github.com/ARMmbed/mbed-tools/blob/master/LICENSE)

  [![Build Status](https://dev.azure.com/mbed-tools/mbed-tools/_apis/build/status/Build%20and%20Release?branchName=master&stageName=CI%20Checkpoint)](https://dev.azure.com/mbed-tools/mbed-tools/_build/latest?definitionId=10&branchName=master)
  [![Test Coverage](https://codecov.io/gh/ARMmbed/mbed-tools/branch/master/graph/badge.svg)](https://codecov.io/gh/ARMmbed/mbed-tools)
  [![Maintainability](https://api.codeclimate.com/v1/badges/b9fca0e16f7a85da7674/maintainability)](https://codeclimate.com/github/ARMmbed/mbed-tools/maintainability)



  This is the **future** command line tool for Mbed OS. It provides the ability to detect Mbed Enabled devices connected
  by USB, checkout Mbed projects and perform builds amongst other operations.

  > :warning: While this package is generally available it is not complete. The available functionality can be viewed with
  > the `--help` option once installed. Please note that the current tools for Mbed OS 5.x and above can be found at
  > https://github.com/ARMmbed/mbed-cli.



  For release notes and a history of changes of all **production** releases, please see the following:

  - [Changelog](https://github.com/ARMmbed/mbed-tools/blob/master/CHANGELOG.md)

  For a the list of all available versions please, please see the:

  - [PyPI Release History](https://pypi.org/project/mbed-tools/#history)



  The version scheme used follows [PEP440](https://www.python.org/dev/peps/pep-0440/) and
  [Semantic Versioning](https://semver.org/). For production quality releases the version will look as follows:

  - `<major>.<minor>.<patch>`

  Pre releases are used to give early access to new functionality, for testing and to get feedback on experimental
  features. As such these releases may not be stable and should not be used for production. Additionally any interfaces
  introduced in a pre release may be removed or changed without notice. For pre releases the version will look as
  follows:

  - `<major>.<minor>.<patch>.dev<pre-release-number>`



  `mbed-tools` relies on the Ninja build system and CMake.
  - CMake. [Install version 3.19.0 or newer for all operating systems](https://cmake.org/install/).
  - Ninja. [Install version 1.0 or newer for all operating systems](https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages).

  We recommend installing `mbed-tools` in a Python virtual environment to avoid dependency conflicts.

  To install the most recent production quality release use:

  ```
  pip install mbed-tools
  ```

  To install a specific release:

  ```
  pip install mbed-tools==<version>
  ```



  Interface definition and usage documentation (for developers of Mbed OS tooling) is available for the most recent
  production release here:

  - [GitHub Pages](https://armmbed.github.io/mbed-tools/api/)



  The follow described the major aspects of the project structure:

  - `azure-pipelines/` - CI configuration files for Azure Pipelines.
  - `src/mbed_tools/` - Python source files.
  - `news/` - Collection of news files for unreleased changes.
  - `tests/` - Unit and integration tests.



  - For interface definition and usage documentation, please see [GitHub Pages](https://armmbed.github.io/mbed-tools/api/).
  - For a list of known issues and possible work arounds, please see [Known Issues](KNOWN_ISSUES.md).
  - To raise a defect or enhancement please use [GitHub Issues](https://github.com/ARMmbed/mbed-tools/issues).
  - To ask a question please use the [Mbed Forum](https://forums.mbed.com/).



  - Mbed OS is an open source project and we are committed to fostering a welcoming community, please see our
    [Code of Conduct](https://github.com/ARMmbed/mbed-tools/blob/master/CODE_OF_CONDUCT.md) for more information.
  - For how to contribute to the project, including how to develop the project,
    please see the [Contributions Guidelines](https://github.com/ARMmbed/mbed-tools/blob/master/CONTRIBUTING.md)


pkgId: ace65f4e7db56658978fe52ed11875bf99db5cae9a5f0910dbc7da6493176436
name: python-mbstrdecoder
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: multi-byte character string decoder
url: https://github.com/thombashi/mbstrdecoder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f0bf54fa-86cc-4e3d-9235-558a9a01d6c4
location_href: 00011089-python-mbstrdecoder/python-mbstrdecoder-1.1.2-1.src.rpm
checksum_type: sha256
description:
  `mbstrdecoder <https://github.com/thombashi/mbstrdecoder>`__ is a Python library for multi-byte character string decoder.


pkgId: 9a90d8d4fa9ad6783bd958f5d2a37ee8363d2b650a0d65aa4ea2f7762d902076
name: python-mccabe
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: McCabe checker, plugin for flake8
url: https://github.com/pycqa/mccabe
rpm_license: Expat license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a7ae708f-d4a4-4c6b-9e43-05a9973c403f
location_href: 00008998-python-mccabe/python-mccabe-0.7.0-1.src.rpm
checksum_type: sha256
description:
  Ned's script to check McCabe complexity.
  This module provides a plugin for ``flake8``, the Python code checker.


pkgId: 2467935c3f6d29b88411705226bf458c5b4658e6ea66dfcacaed191859bd3604
name: python-mdv
arch: src
version: 1.7.4
epoch: 0
release: 1
summary: Terminal Markdown Viewer
url: http://github.com/axiros/terminal_markdown_viewer
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5fcb5d7d-70d6-4b60-9f4c-7a76db30af12
location_href: 00013010-python-mdv/python-mdv-1.7.4-1.src.rpm
checksum_type: sha256
description:
  """
  from setuptools import setup, find_packages
  import mdv
  setup(
      name='mdv',
      version=mdv.__version__,
  ```


pkgId: bd8618d21b77c9941d653441b235e6f842d05a390816d36b6f2dc7555e15b961
name: python-mdx-gh-links
arch: src
version: 0.3
epoch: 0
release: 1
url: https://github.com/Python-Markdown/github-links/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2adb42b4-f63c-4c36-985b-111ca000f78f
location_href: 00004178-python-mdx_gh_links/python-mdx-gh-links-0.3-1.src.rpm
checksum_type: sha256
summary:
  An extension to Python-Markdown which adds support for shorthand links to GitHub users, repositories, issues and commits.


pkgId: d07f589da058f18b3d7644c4b6c36f2afc63ac7e20bf4cca2877129d2a3bb8f7
name: python-mechanize
arch: src
version: 0.4.8
epoch: 0
release: 1
summary: Stateful, programmatic web browsing
url: https://github.com/python-mechanize/mechanize
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-235978ca-856f-4fa8-921a-e409a8b6be6c
location_href: 00004181-python-mechanize/python-mechanize-0.4.8-1.src.rpm
checksum_type: sha256
description:
  Stateful programmatic web browsing in Python
  - The browser class `mechanize.Browser` implements the
    interface of `urllib2.OpenerDirector`, so any URL can
    be opened not just `http`.
  - Easy HTML form filling.
  - Convenient link parsing and following.
  - Browser history (`.back()` and `.reload()` methods).
  - The `Referer` HTTP header is added properly (optional).
  - Automatic observance of `robots.txt <http://www.robotstxt.org/wc/norobots.html>`_.
  - Automatic handling of HTTP-Equiv and Refresh.


pkgId: d434d5243fd042e1717f409de9afb0e78596b433528fbc53cb8422e0e641073c
name: python-meld3
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Unmaintained templating system used by old versions of Supervisor
url: https://github.com/supervisor/meld3
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4a853e50-6a17-4f4f-a78b-5dca043f3bb6
location_href: 00004184-python-meld3/python-meld3-2.0.1-1.src.rpm
checksum_type: sha256
description:
  No further development of the meld3 package is planned.  The meld3 package
  should be considered unmaintained as of April 2020.  Since 2007, meld3
  received only minimal updates to keep compatible with newer Python versions.
  It was only maintained because it was a dependency of the Supervisor package.
  Since Supervisor 4.1.0 (released in October 2019), the meld3 package is
  no longer a dependency of Supervisor.


pkgId: 5ead3f7ae4b9fe7e03a0f1e3c89bbc82b0f25057ae798e34d695212f63c76fa1
name: python-memoization
arch: src
version: 0.4.0
epoch: 0
release: 1
url: https://github.com/lonelyenvoy/python-memoization
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4cb72774-148b-4c06-8525-805c6b94c6d6
location_href: 00010915-python-memoization/python-memoization-0.4.0-1.src.rpm
checksum_type: sha256
summary:
  A powerful caching library for Python, with TTL support and multiple algorithm options. (https://github.com/lonelyenvoy/python-memoization)

description:
  [![Repository][repositorysvg]][repository] [![Build Status][travismaster]][travis] [![Codacy Badge][codacysvg]][codacy]
  [![Coverage Status][coverallssvg]][coveralls] [![Downloads][downloadssvg]][repository]
  <br>
  [![PRs welcome][prsvg]][pr] [![License][licensesvg]][license] [![Supports Python][pythonsvg]][python]


  A powerful caching library for Python, with TTL support and multiple algorithm options.

  If you like this work, please [star](https://github.com/lonelyenvoy/python-memoization) it on GitHub.



  Perhaps you know about [```functools.lru_cache```](https://docs.python.org/3/library/functools.html#functools.lru_cache)
  in Python 3, and you may be wondering why we are reinventing the wheel.

  Well, actually not. This lib is based on ```functools```. Please find below the comparison with ```lru_cache```.

  |Features|```functools.lru_cache```|```memoization```|
  |--------|-------------------|-----------|
  |Configurable max size|✔️|✔️|
  |Thread safety|✔️|✔️|
  |Flexible argument typing (typed & untyped)|✔️|Always typed|
  |Cache statistics|✔️|✔️|
  |LRU (Least Recently Used) as caching algorithm|✔️|✔️|
  |LFU (Least Frequently Used) as caching algorithm|No support|✔️|
  |FIFO (First In First Out) as caching algorithm|No support|✔️|
  |Extensibility for new caching algorithms|No support|✔️|
  |TTL (Time-To-Live) support|No support|✔️|
  |Support for unhashable arguments (dict, list, etc.)|No support|✔️|
  |Custom cache keys|No support|✔️|
  |On-demand partial cache clearing|No support|✔️|
  |Iterating through the cache|No support|✔️|
  |Python version|3.2+|3.4+|

  ```memoization``` solves some drawbacks of ```functools.lru_cache```:

  1. ```lru_cache``` does not support __unhashable types__, which means function arguments cannot contain dict or list.

  ```python
  >>> from functools import lru_cache
  >>> @lru_cache()
  ... def f(x): return x
  ...
  >>> f([1, 2])  # unsupported
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'list'
  ```

  2. ```lru_cache``` is vulnerable to [__hash collision attack__](https://learncryptography.com/hash-functions/hash-collision-attack)
     and can be hacked or compromised. Using this technique, attackers can make your program __unexpectedly slow__ by
     feeding the cached function with certain cleverly designed inputs. However, in ```memoization```, caching is always
     typed, which means ```f(3)``` and ```f(3.0)``` will be treated as different calls and cached separately. Also,
     you can build your own cache key with a unique hashing strategy. These measures __prevents the attack__ from
     happening (or at least makes it a lot harder).

  ```python
  >>> hash((1,))
  3430019387558
  >>> hash(3430019387558.0)  # two different arguments with an identical hash value
  3430019387558
  ```

  3. Unlike `lru_cache`, `memoization` is designed to be highly extensible, which make it easy for developers to add and integrate
  __any caching algorithms__ (beyond FIFO, LRU and LFU) into this library. See [Contributing Guidance](https://github.com/lonelyenvoy/python-memoization/blob/master/CONTRIBUTING.md) for further detail.




  ```bash
  pip install -U memoization
  ```




  ```python
  from memoization import cached

  @cached
  def func(arg):
      ...  # do something slow
  ```

  Simple enough - the results of ```func()``` are cached.
  Repetitive calls to ```func()``` with the same arguments run ```func()``` only once, enhancing performance.

  >:warning:__WARNING:__ for functions with unhashable arguments, the default setting may not enable `memoization` to work properly. See [custom cache keys](https://github.com/lonelyenvoy/python-memoization#custom-cache-keys) section below for details.



  You will learn about the advanced features in the following tutorial, which enable you to customize `memoization` .

  Configurable options include `ttl`, `max_size`, `algorithm`, `thread_safe`, `order_independent` and `custom_key_maker`.



  ```python
  @cached(ttl=5)  # the cache expires after 5 seconds
  def expensive_db_query(user_id):
      ...
  ```

  For impure functions, TTL (in second) will be a solution. This will be useful when the function returns resources that is valid only for a short time, e.g. fetching something from databases.



  ```python
  @cached(max_size=128)  # the cache holds no more than 128 items
  def get_a_very_large_object(filename):
      ...
  ```

  By default, if you don't specify ```max_size```, the cache can hold unlimited number of items.
  When the cache is fully occupied, the former data will be overwritten by a certain algorithm described below.



  ```python
  from memoization import cached, CachingAlgorithmFlag

  @cached(max_size=128, algorithm=CachingAlgorithmFlag.LFU)  # the cache overwrites items using the LFU algorithm
  def func(arg):
      ...
  ```

  Possible values for ```algorithm``` are:

  - `CachingAlgorithmFlag.LRU`: _Least Recently Used_  (default)
  - `CachingAlgorithmFlag.LFU`: _Least Frequently Used_
  - `CachingAlgorithmFlag.FIFO`: _First In First Out_

  This option is valid only when a ```max_size``` is explicitly specified.



  ```python
  @cached(thread_safe=False)
  def func(arg):
      ...
  ```

  ```thread_safe``` is ```True``` by default. Setting it to ```False``` enhances performance.



  By default, the following function calls will be treated differently and cached twice, which means the cache misses at the second call.

  ```python
  func(a=1, b=1)
  func(b=1, a=1)
  ```

  You can avoid this behavior by passing an `order_independent` argument to the decorator, although it will slow down the performance a little bit.

  ```python
  @cached(order_independent=True)
  def func(**kwargs):
      ...
  ```



  Prior to memorize your function inputs and outputs (i.e. putting them into a cache), `memoization` needs to
  build a __cache key__ using the inputs, so that the outputs can be retrieved later.

  > By default, `memoization` tries to combine all your function
  arguments and calculate its hash value using `hash()`. If it turns out that parts of your arguments are
  unhashable, `memoization` will fall back to turning them into a string using `str()`. This behavior relies
  on the assumption that the string exactly represents the internal state of the arguments, which is true for
  built-in types.

  However, this is not true for all objects. __If you pass objects which are
  instances of non-built-in classes, sometimes you will need to override the default key-making procedure__,
  because the `str()` function on these objects may not hold the correct information about their states.

  Here are some suggestions. __Implementations of a valid key maker__:

  - MUST be a function with the same signature as the cached function.
  - MUST produce unique keys, which means two sets of different arguments always map to two different keys.
  - MUST produce hashable keys, and a key is comparable with another key (`memoization` only needs to check for their equality).
  - should compute keys efficiently and produce small objects as keys.

  Example:

  ```python
  def get_employee_id(employee):
      return employee.id  # returns a string or a integer

  @cached(custom_key_maker=get_employee_id)
  def calculate_performance(employee):
      ...
  ```

  Note that writing a robust key maker function can be challenging in some situations. If you find it difficult,
  feel free to ask for help by submitting an [issue](https://github.com/lonelyenvoy/python-memoization/issues).




  ```python
  >>> @cached
  ... def f(x): return x
  ...
  >>> f.cache_info()
  CacheInfo(hits=0, misses=0, current_size=0, max_size=None, algorithm=<CachingAlgorithmFlag.LRU: 2>, ttl=None, thread_safe=True, order_independent=False, use_custom_key=False)
  ```

  With ```cache_info```, you can retrieve the number of ```hits``` and ```misses``` of the cache, and other information indicating the caching status.

  - `hits`: the number of cache hits
  - `misses`: the number of cache misses
  - `current_size`: the number of items that were cached
  - `max_size`: the maximum number of items that can be cached (user-specified)
  - `algorithm`: caching algorithm (user-specified)
  - `ttl`: Time-To-Live value (user-specified)
  - `thread_safe`: whether the cache is thread safe (user-specified)
  - `order_independent`: whether the cache is kwarg-order-independent (user-specified)
  - `use_custom_key`: whether a custom key maker is used



  - Access the original undecorated function `f` by `f.__wrapped__`.
  - Clear the cache by `f.cache_clear()`.
  - Check whether the cache is empty by `f.cache_is_empty()`.
  - Check whether the cache is full by `f.cache_is_full()`.
  - Disable `SyntaxWarning` by `memoization.suppress_warnings()`.



  <details>
  <summary>Details</summary>





  ```
  Return True if the cache contains a cached item with the specified function call arguments

  :param function_arguments:  Can be a list, a tuple or a dict.
                              - Full arguments: use a list to represent both positional arguments and keyword
                                arguments. The list contains two elements, a tuple (positional arguments) and
                                a dict (keyword arguments). For example,
                                  f(1, 2, 3, a=4, b=5, c=6)
                                can be represented by:
                                  [(1, 2, 3), {'a': 4, 'b': 5, 'c': 6}]
                              - Positional arguments only: when the arguments does not include keyword arguments,
                                a tuple can be used to represent positional arguments. For example,
                                  f(1, 2, 3)
                                can be represented by:
                                  (1, 2, 3)
                              - Keyword arguments only: when the arguments does not include positional arguments,
                                a dict can be used to represent keyword arguments. For example,
                                  f(a=4, b=5, c=6)
                                can be represented by:
                                  {'a': 4, 'b': 5, 'c': 6}

  :param alive_only:          Whether to check alive cache item only (default to True).

  :return:                    True if the desired cached item is present, False otherwise.
  ```



  ```
  Return True if the cache contains a cache item with the specified user function return value. O(n) time
  complexity.

  :param return_value:        A return value coming from the user function.

  :param alive_only:          Whether to check alive cache item only (default to True).

  :return:                    True if the desired cached item is present, False otherwise.
  ```





  ```
  Get user function arguments of all alive cache elements

  see also: cache_items()

  Example:
     @cached
     def f(a, b, c, d):
         ...
     f(1, 2, c=3, d=4)
     for argument in f.cache_arguments():
         print(argument)  # ((1, 2), {'c': 3, 'd': 4})

  :return: an iterable which iterates through a list of a tuple containing a tuple (positional arguments) and
          a dict (keyword arguments)
  ```



  ```
  Get user function return values of all alive cache elements

  see also: cache_items()

  Example:
     @cached
     def f(a):
         return a
     f('hello')
     for result in f.cache_results():
         print(result)  # 'hello'

  :return: an iterable which iterates through a list of user function result (of any type)
  ```



  ```
  Get cache items, i.e. entries of all alive cache elements, in the form of (argument, result).

  argument: a tuple containing a tuple (positional arguments) and a dict (keyword arguments).
  result: a user function return value of any type.

  see also: cache_arguments(), cache_results().

  Example:
     @cached
     def f(a, b, c, d):
         return 'the answer is ' + str(a)
     f(1, 2, c=3, d=4)
     for argument, result in f.cache_items():
         print(argument)  # ((1, 2), {'c': 3, 'd': 4})
         print(result)    # 'the answer is 1'

  :return: an iterable which iterates through a list of (argument, result) entries
  ```



  ```
  Perform the given action for each cache element in an order determined by the algorithm until all
  elements have been processed or the action throws an error

  :param consumer:           an action function to process the cache elements. Must have 3 arguments:
                               def consumer(user_function_arguments, user_function_result, is_alive): ...
                             user_function_arguments is a tuple holding arguments in the form of (args, kwargs).
                               args is a tuple holding positional arguments.
                               kwargs is a dict holding keyword arguments.
                               for example, for a function: foo(a, b, c, d), calling it by: foo(1, 2, c=3, d=4)
                               user_function_arguments == ((1, 2), {'c': 3, 'd': 4})
                             user_function_result is a return value coming from the user function.
                             is_alive is a boolean value indicating whether the cache is still alive
                             (if a TTL is given).
  ```





  ```
  Clear the cache and its statistics information
  ```



  ```
  Remove all cache elements that satisfy the given predicate

  :param predicate:           a predicate function to judge whether the cache elements should be removed. Must
                              have 3 arguments, and returns True or False:
                                def consumer(user_function_arguments, user_function_result, is_alive): ...
                              user_function_arguments is a tuple holding arguments in the form of (args, kwargs).
                                args is a tuple holding positional arguments.
                                kwargs is a dict holding keyword arguments.
                                for example, for a function: foo(a, b, c, d), calling it by: foo(1, 2, c=3, d=4)
                                user_function_arguments == ((1, 2), {'c': 3, 'd': 4})
                              user_function_result is a return value coming from the user function.
                              is_alive is a boolean value indicating whether the cache is still alive
                              (if a TTL is given).

  :return:                    True if at least one element is removed, False otherwise.
  ```

  </details>



  1. **Q: There are duplicated code in `memoization` and most of them can be eliminated by using another level of
  abstraction (e.g. classes and multiple inheritance). Why not refactor?**

     A: We would like to keep the code in a proper level of abstraction. However, these abstractions make it run slower.
  As this is a caching library focusing on speed, we have to give up some elegance for better performance. Refactoring
  is our future work.


  2. **Q: I have submitted an issue and not received a reply for a long time. Anyone can help me?**

     A: Sorry! We are not working full-time, but working voluntarily on this project, so you might experience some delay.
  We appreciate your patience.




  This project welcomes contributions from anyone.
  - [Read Contributing Guidance](https://github.com/lonelyenvoy/python-memoization/blob/master/CONTRIBUTING.md) first.
  - [Submit bugs](https://github.com/lonelyenvoy/python-memoization/issues) and help us verify fixes.
  - [Submit pull requests](https://github.com/lonelyenvoy/python-memoization/pulls) for bug fixes and features and discuss existing proposals. Please make sure that your PR passes the tests in ```test.py```.
  - [See contributors](https://github.com/lonelyenvoy/python-memoization/blob/master/CONTRIBUTORS.md) of this project.




  [The MIT License](https://github.com/lonelyenvoy/python-memoization/blob/master/LICENSE)


  [pythonsvg]: https://img.shields.io/pypi/pyversions/memoization.svg
  [python]: https://www.python.org

  [travismaster]: https://travis-ci.com/lonelyenvoy/python-memoization.svg?branch=master
  [travis]: https://travis-ci.com/lonelyenvoy/python-memoization

  [coverallssvg]: https://coveralls.io/repos/github/lonelyenvoy/python-memoization/badge.svg?branch=master
  [coveralls]: https://coveralls.io/github/lonelyenvoy/python-memoization?branch=master

  [repositorysvg]: https://img.shields.io/pypi/v/memoization
  [repository]: https://pypi.org/project/memoization

  [downloadssvg]: https://img.shields.io/pypi/dm/memoization

  [prsvg]: https://img.shields.io/badge/pull_requests-welcome-blue.svg
  [pr]: https://github.com/lonelyenvoy/python-memoization#contributing

  [licensesvg]: https://img.shields.io/badge/license-MIT-blue.svg
  [license]: https://github.com/lonelyenvoy/python-memoization/blob/master/LICENSE

  [codacysvg]: https://api.codacy.com/project/badge/Grade/52c68fb9de6b4b149e77e8e173616db6
  [codacy]: https://www.codacy.com/manual/petrinchor/python-memoization?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=lonelyenvoy/python-memoization&amp;utm_campaign=Badge_Grade


pkgId: 3e7bdc8041f8dff49fab1b3c084d913da74346c4d503343ffaacf1c650fcc52e
name: python-metaextract
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: get metadata for python modules
url: http://github.com/toabctl/metaextract
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-028badb5-a9ad-4f89-928f-95624a08b41a
location_href: 00004187-python-metaextract/python-metaextract-1.0.9-1.src.rpm
checksum_type: sha256
description:
  metaextract is a tool to collect metadata about a python module. For example
  you may have a sdist tarball from the `Python Package Index`_ and you want to
  know it's dependencies. metaextract can collect theses dependencies.
  The tool was first developed in `py2pack`_ but is now it's own module to be
  useful for others, too.


pkgId: 3fc3c0e1c60d5f1545b911353fc0217dbb69809bd3501ef383e9b468d8b736fc
name: python-metaflow
arch: src
version: 2.8.2
epoch: 0
release: 1
summary: Metaflow: More Data Science, Less Engineering
url: https://pypi.org/project/metaflow/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e1e1f2d-7cb6-4085-8014-640b8f5836b5
location_href: 00013501-python-metaflow/python-metaflow-2.8.2-1.src.rpm
checksum_type: sha256
description:
  ![Metaflow_Logo_Horizontal_FullColor_Ribbon_Dark_RGB](https://user-images.githubusercontent.com/763451/89453116-96a57e00-d713-11ea-9fa6-82b29d4d6eff.png)



  Metaflow is a human-friendly Python/R library that helps scientists and engineers build and manage real-life data science projects. Metaflow was originally developed at Netflix to boost productivity of data scientists who work on a wide variety of projects from classical statistics to state-of-the-art deep learning.

  For more information, see [Metaflow's website](https://metaflow.org) and [documentation](https://docs.metaflow.org).



  Getting up and running with Metaflow is easy.


  Install metaflow from [pypi](https://pypi.org/project/metaflow/):

  ```sh
  pip install metaflow
  ```

  and access tutorials by typing:

  ```sh
  metaflow tutorials pull
  ```



  Install Metaflow from [github](https://github.com/Netflix/metaflow/tree/master/R):

  ```R
  devtools::install_github("Netflix/metaflow", subdir="R")
  metaflow::install()
  ```

  and access tutorials by typing:

  ```R
  metaflow::pull_tutorials()
  ```


  There are several ways to get in touch with us:

  * Open an issue at: https://github.com/Netflix/metaflow
  * Email us at: help@metaflow.org
  * Chat with us on: http://chat.metaflow.org



  We welcome contributions to Metaflow. Please see our [contribution guide](https://docs.metaflow.org/introduction/contributing-to-metaflow) for more details.



  We use [black](https://black.readthedocs.io/en/stable/) as a code formatter. The easiest way to ensure your commits are always formatted with the correct version of `black` it is to use [pre-commit](https://pre-commit.com/): install it and then run `pre-commit install` once in your local copy of the repo.


pkgId: a94ea0943bd2d4ca272a22664847a7a444370fb593130c50f55512a057c3b485
name: python-metar
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: Metar - a package to parse METAR-coded weather reports
url: https://github.com/python-metar/python-metar
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c3033dd-64f6-488f-9021-149174dbbae1
location_href: 00004192-python-metar/python-metar-1.9.0-1.src.rpm
checksum_type: sha256
description:
  Metar is a python package for interpreting METAR and SPECI weather reports.

  METAR is an international format for reporting weather observations.
  The standard specification for the METAR and SPECI codes is given
  in the WMO Manual on Codes, vol I.1, Part A (WMO-306 I.i.A).  US
  conventions for METAR/SPECI reports are described in chapter 12 of
  the Federal Meteorological Handbook No.1. (FMC-H1-2017), issued by
  NOAA.  See http://www.ofcm.gov/publications/fmh/FMH1/FMH1.pdf

  This module extracts the data recorded in the main-body groups of
  reports that follow the WMO spec or the US conventions, except for
  the runway state and trend groups, which are parsed but ignored.
  The most useful remark groups defined in the US spec are parsed,
  as well, such as the cumulative precipitation, min/max temperature,
  peak wind and sea-level pressure groups.  No other regional conventions
  are formally supported, but a large number of variant formats found
  in international reports are accepted.


pkgId: 548263e9f9e5c91f721f2e25d8260ea7d27835c1ecb9610bdf0f790f086689f2
name: python-meteomatics
arch: src
version: 2.9.0
epoch: 0
release: 1
summary: Meteomatics API connector
url: https://github.com/meteomatics/python-connector-api
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92f2f573-cb70-4e94-9859-3314ad88fdf4
location_href: 00013006-python-meteomatics/python-meteomatics-2.9.0-1.src.rpm
checksum_type: sha256
description:
  Meteomatics provides a REST-style API to retrieve historic, current, and forecast data globally. This includes model data and observational data in time series and areal formats. Areal formats are also offered through a WMS/WFS-compatible interface. Geographic and time series data can be combined in certain file formats, such as NetCDF.
  Install by typing `pip install meteomatics` in your favourite shell.
  For a start we recommend to run the example script.


pkgId: 59c9edcd22f7b32be5dc3b08fdbb54e874b6dbeebdaa1348b6964f67caffa7f2
name: python-methodtools
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: Expand standard functools to methods
url: https://github.com/youknowone/methodtools
rpm_license: BSD 2-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e82138f7-16e2-4617-a96c-e1e20df8d7ac
location_href: 00012256-python-methodtools/python-methodtools-0.4.7-1.src.rpm
checksum_type: sha256
description:
  Expand functools features to methods, classmethods, staticmethods and even for
  (unofficial) hybrid methods.
  For now, methodtools only provides `methodtools.lru_cache`.
  Use `methodtools` module instead of `functools` module. Than it will work as
  you expected.
      from methodtools import lru_cache
      class A(object):
          
          @lru_cache()
          def cached_method(self, args):
          
          @lru_cache()  # the order is important!
          @classmethod  # always lru_cache on top of classmethod
          def cached_classmethod(self, args):
          
          @lru_cache()  # the order is important!
          @staticmethod  # always lru_cache on top of staticmethod
          def cached_staticmethod(self, args):
      @lru_cache()  # just same as functools.lru_cache
      def cached_function():


pkgId: a96dc7a8b7a44d4cb4050c6c2cbdaaad57ba4ab17ef0bcc01ce6039e295a12bc
name: python-mf2py
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Python Microformats2 parser
url: http://microformats.org/wiki/mf2py
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3aae3657-1c7e-4b72-b0f5-2c5650ffbcbf
location_href: 00013294-python-mf2py/python-mf2py-1.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/microformats/mf2py.svg?branch=master)](https://travis-ci.org/microformats/mf2py)
  [![Can I Use Python 3?](https://caniusepython3.com/project/mf2py.svg)](https://caniusepython3.com/project/mf2py)
  Python parser for [microformats 2](http://microformats.org/wiki/Microformats2).
  Current status: Full-featured and mostly stable. Implements the full
  mf2 spec, including backward compatibility with microformats1.
  Documentation, code tidying and so on is rather lacking.
  License: [MIT](http://opensource.org/licenses/mit-license.php)


pkgId: 492f23538977857a1b19ff9bc67cdd3b2f1290ef47c37e96735009e83115657e
name: python-mglob
arch: src
version: 0.4
epoch: 0
release: 1
summary: Enhanced file name globbing module
url: http://vvtools.googlecode.com/svn/trunk/mglob#egg=mglob-dev
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb3aa8ef-cc97-4bd4-b586-aab05fc72689
location_href: 00004195-python-mglob/python-mglob-0.4-1.src.rpm
checksum_type: sha256
description:
  mglob - enhanced file list expansion utility/module

  Usable as stand-alone utility (for xargs, backticks etc.), or as a globbing library for own python programs. Globbing the sys.argv is something that almost every Windows script has to perform manually, and this module is here to help with that task. Also Unix users will benefit from enhanced features such as recursion, exclusion, and directory omission.


pkgId: 36105539357630a560f948275b810d95239ee77e595b6b558c5b4add9933bb1f
name: python-mgzip
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A multi-threading implementation of Python gzip module
url: https://github.com/vinlyx/mgzip
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c91b1ff8-ef26-4658-b712-003e177d3779
location_href: 00011493-python-mgzip/python-mgzip-0.2.1-1.src.rpm
checksum_type: sha256
description:
  A multi-threading implement of Python gzip module

  Using a block indexed GZIP file format to enable compress and decompress in parallel. This implement use 'FEXTRA' to record the index of compressed member, which is defined in offical GZIP file format specification version 4.3, so it is fully compatible with normal GZIP implement.

  This module is **~25X** faster for compression and **~7X** faster for decompression (limited by IO and Python implementation) with a *24 CPUs* computer.

  ***In theoretical, compression and decompression acceleration should be linear according to the CPU cores. In fact, the performance is limited by IO and program language implementation.***


  Use same method as gzip module
  ```python
  import mgzip

  s = "a big string..."




  with mgzip.open("test.txt.gz", "wt", thread=8, blocksize=2*10**8) as fw:
      fw.write(s)

  with mgzip.open("test.txt.gz", "rt", thread=8) as fr:
      assert fr.read(len(s)) == s
  ```



  ![Compression Performance](https://raw.githubusercontent.com/vinlyx/mgzip/master/CompressionBenchmark.png)


  ![Decompression Performance](https://raw.githubusercontent.com/vinlyx/mgzip/master/DecompressionBenchmark.png)

  *Brenchmarked on a 24 cores, 48 threads server (Xeon(R) CPU E5-2650 v4 @ 2.20GHz) with 8.0GB FASTQ text file.*

  *Using parameters thread=42 and blocksize=200000000*


  **This package only replace the 'GzipFile' class and 'open', 'compress', 'decompress' functions of standard gzip module. It is not well tested for other class and function.**

  **As the first release version, some features are not yet supported, such as seek() and tell(). Any contribution or improvement is appreciated.**


pkgId: 0d91797bc843c47da4f3db214704d4000e3ca2982326fa0787b730a5e57a21cc
name: python-micawber
arch: src
version: 0.5.4
epoch: 0
release: 1
summary: a small library for extracting rich content from urls
url: http://github.com/coleifer/micawber/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aa5d2ead-6650-42f7-bb72-1c85d65a4aea
location_href: 00004196-python-micawber/python-micawber-0.5.4-1.src.rpm
checksum_type: sha256
description:
  micawber supplies a few methods for retrieving rich metadata about a variety of
  links, such as links to youtube videos.  micawber also provides functions for
  parsing blocks of text and html and replacing links to videos with rich embedded
  content.


pkgId: fa33f67057c6426ef3863cb65c48ce8d44ecc7a13b4ac80d102f2c4f34a107b6
name: python-miceforest
arch: src
version: 5.6.3
epoch: 0
release: 1
summary: Missing Value Imputation using LightGBM
url: https://github.com/AnotherSamWilson/miceforest
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f7e5bb35-d52b-4e57-834e-dce876e57763
location_href: 00014322-python-miceforest/python-miceforest-5.6.3-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/289387436.svg)](https://zenodo.org/badge/latestdoi/289387436)
  [![Downloads](https://static.pepy.tech/badge/miceforest)](https://pepy.tech/project/miceforest)
  [![Pypi](https://img.shields.io/pypi/v/miceforest.svg)](https://pypi.python.org/pypi/miceforest)
  [![Conda
  Version](https://img.shields.io/conda/vn/conda-forge/miceforest.svg)](https://anaconda.org/conda-forge/miceforest)
  [![PyVersions](https://img.shields.io/pypi/pyversions/miceforest.svg?logo=python&logoColor=white)](https://pypi.org/project/miceforest/)
  [![tests +
  mypy](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml/badge.svg)](https://github.com/AnotherSamWilson/miceforest/actions/workflows/run_tests.yml)
  [![Documentation
  Status](https://readthedocs.org/projects/miceforest/badge/?version=latest)](https://miceforest.readthedocs.io/en/latest/?badge=latest)
  [![CodeCov](https://codecov.io/gh/AnotherSamWilson/miceforest/branch/master/graphs/badge.svg?branch=master&service=github)](https://codecov.io/gh/AnotherSamWilson/miceforest)
  <!-- [![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT) -->
  <!-- [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)   -->
  <!-- [![DEV_Version_Badge](https://img.shields.io/badge/Dev-5.6.3-blue.svg)](https://pypi.org/project/miceforest/) -->



  <a href='https://github.com/AnotherSamWilson/miceforest'><img src='https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/icon.png' align="right" height="300" /></a>

  Fast, memory efficient Multiple Imputation by Chained Equations (MICE)
  with lightgbm. The R version of this package may be found
  [here](https://github.com/FarrellDay/miceRanger).

  `miceforest` was designed to be:

    - **Fast**
        - Uses lightgbm as a backend
        - Has efficient mean matching solutions.
        - Can utilize GPU training
    - **Flexible**
        - Can impute pandas dataframes and numpy arrays
        - Handles categorical data automatically
        - Fits into a sklearn pipeline
        - User can customize every aspect of the imputation process
    - **Production Ready**
        - Can impute new, unseen datasets quickly
        - Kernels are efficiently compressed during saving and loading
        - Data can be imputed in place to save memory
        - Can build models on non-missing data

  This document contains a thorough walkthrough of the package,
  benchmarks, and an introduction to multiple imputation. More information
  on MICE can be found in Stef van Buuren’s excellent online book, which
  you can find
  [here](https://stefvanbuuren.name/fimd/ch-introduction.html).



    - [Package
      Meta](https://github.com/AnotherSamWilson/miceforest#Package-Meta)
    - [The
      Basics](https://github.com/AnotherSamWilson/miceforest#The-Basics)
        - [Basic
          Examples](https://github.com/AnotherSamWilson/miceforest#Basic-Examples)
        - [Customizing LightGBM
          Parameters](https://github.com/AnotherSamWilson/miceforest#Customizing-LightGBM-Parameters)
        - [Available Mean Match
          Schemes](https://github.com/AnotherSamWilson/miceforest#Controlling-Tree-Growth)
        - [Imputing New Data with Existing
          Models](https://github.com/AnotherSamWilson/miceforest#Imputing-New-Data-with-Existing-Models)
        - [Saving and Loading
          Kernels](https://github.com/AnotherSamWilson/miceforest#Saving-and-Loading-Kernels)
        - [Implementing sklearn
          Pipelines](https://github.com/AnotherSamWilson/miceforest#Implementing-sklearn-Pipelines)
    - [Advanced
      Features](https://github.com/AnotherSamWilson/miceforest#Advanced-Features)
        - [Customizing the Imputation
          Process](https://github.com/AnotherSamWilson/miceforest#Customizing-the-Imputation-Process)
        - [Building Models on Nonmissing
          Data](https://github.com/AnotherSamWilson/miceforest#Building-Models-on-Nonmissing-Data)
        - [Tuning
          Parameters](https://github.com/AnotherSamWilson/miceforest#Tuning-Parameters)
        - [On
          Reproducibility](https://github.com/AnotherSamWilson/miceforest#On-Reproducibility)
        - [How to Make the Process
          Faster](https://github.com/AnotherSamWilson/miceforest#How-to-Make-the-Process-Faster)
        - [Imputing Data In
          Place](https://github.com/AnotherSamWilson/miceforest#Imputing-Data-In-Place)
    - [Diagnostic
      Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting)
        - [Imputed
          Distributions](https://github.com/AnotherSamWilson/miceforest#Distribution-of-Imputed-Values)
        - [Correlation
          Convergence](https://github.com/AnotherSamWilson/miceforest#Convergence-of-Correlation)
        - [Variable
          Importance](https://github.com/AnotherSamWilson/miceforest#Variable-Importance)
        - [Mean
          Convergence](https://github.com/AnotherSamWilson/miceforest#Variable-Importance)
    - [Benchmarks](https://github.com/AnotherSamWilson/miceforest#Benchmarks)
    - [Using the Imputed
      Data](https://github.com/AnotherSamWilson/miceforest#Using-the-Imputed-Data)
    - [The MICE
      Algorithm](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm)
        - [Introduction](https://github.com/AnotherSamWilson/miceforest#The-MICE-Algorithm)
        - [Common Use
          Cases](https://github.com/AnotherSamWilson/miceforest#Common-Use-Cases)
        - [Predictive Mean
          Matching](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching)
        - [Effects of Mean
          Matching](https://github.com/AnotherSamWilson/miceforest#Effects-of-Mean-Matching)





  This package can be installed using either pip or conda, through
  conda-forge:

  ``` bash

  $ pip install miceforest --no-cache-dir


  $ conda install -c conda-forge miceforest
  ```

  You can also download the latest development version from this
  repository. If you want to install from github with conda, you must
  first run `conda install pip git`.

  ``` bash
  $ pip install git+https://github.com/AnotherSamWilson/miceforest.git
  ```



  miceforest has 3 main classes which the user will interact with:

    - [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel)
      - This class contains the raw data off of which the `mice` algorithm
      is performed. During this process, models will be trained, and the
      imputed (predicted) values will be stored. These values can be used
      to fill in the missing values of the raw data. The raw data can be
      copied, or referenced directly. Models can be saved, and used to
      impute new datasets.
    - [`ImputedData`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputedData.html#miceforest.ImputedData)
      - The result of `ImputationKernel.impute_new_data(new_data)`. This
      contains the raw data in `new_data` as well as the imputed values.
    - [`MeanMatchScheme`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.MeanMatchScheme.html#miceforest.MeanMatchScheme)
      - Determines how mean matching should be carried out. There are 3
      built-in mean match schemes available in miceforest, discussed
      below.



  We will be looking at a few simple examples of imputation. We need to
  load the packages, and define the data:

  ``` python
  import miceforest as mf
  from sklearn.datasets import load_iris
  import pandas as pd
  import numpy as np


  iris = pd.concat(load_iris(as_frame=True,return_X_y=True),axis=1)
  iris.rename({"target": "species"}, inplace=True, axis=1)
  iris['species'] = iris['species'].astype('category')
  iris_amp = mf.ampute_data(iris,perc=0.25,random_state=1991)
  ```



  If you only want to create a single imputed dataset, you can use
  [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel)
  with some default settings:

  ``` python

  kds = mf.ImputationKernel(
    iris_amp,
    save_all_iterations=True,
    random_state=1991
  )


  kds.mice(2)


  iris_complete = kds.complete_data()
  ```

  There are also an array of plotting functions available, these are
  discussed below in the section [Diagnostic
  Plotting](https://github.com/AnotherSamWilson/miceforest#Diagnostic-Plotting).

  We usually don’t want to impute just a single dataset. In statistics,
  multiple imputation is a process by which the uncertainty/other effects
  caused by missing values can be examined by creating multiple different
  imputed datasets.
  [`ImputationKernel`](https://miceforest.readthedocs.io/en/latest/ik/miceforest.ImputationKernel.html#miceforest.ImputationKernel)
  can contain an arbitrary number of different datasets, all of which have
  gone through mutually exclusive imputation processes:

  ``` python

  kernel = mf.ImputationKernel(
    iris_amp,
    datasets=4,
    save_all_iterations=True,
    random_state=1
  )


  kernel.mice(2)


  print(kernel)
  ```

      
      
      
      
      
      
      
      

  After we have run mice, we can obtain our completed dataset directly
  from the kernel:

  ``` python
  completed_dataset = kernel.complete_data(dataset=2)
  print(completed_dataset.isnull().sum(0))
  ```

      
      
      
      
      
      



  Parameters can be passed directly to lightgbm in several different ways.
  Parameters you wish to apply globally to every model can simply be
  passed as kwargs to `mice`:

  ``` python

  kernel.mice(iterations=1,n_estimators=50)
  ```

  You can also pass pass variable-specific arguments to
  `variable_parameters` in mice. For instance, let’s say you noticed the
  imputation of the `[species]` column was taking a little longer, because
  it is multiclass. You could decrease the n\_estimators specifically for
  that column with:

  ``` python

  kernel.mice(
    iterations=1,
    variable_parameters={'species': {'n_estimators': 25}},
    n_estimators=50
  )


  species_model = kernel.get_model(dataset=0,variable="species")
  sepalwidth_model = kernel.get_model(dataset=0,variable="sepal width (cm)")

  print(
  f"""Species used {str(species_model.params["num_iterations"])} iterations
  Sepal Width used {str(sepalwidth_model.params["num_iterations"])} iterations
  """
  )
  ```

      
      

  In this scenario, any parameters specified in `variable_parameters`
  takes presidence over the kwargs.

  Since we can pass any parameters we want to LightGBM, we can completely
  customize how our models are built. That includes how the data should be
  modeled. If your data contains count data, or any other data which can
  be parameterized by lightgbm, you can simply specify that variable to be
  modeled with the corresponding objective function.

  For example, let’s pretend `sepal width (cm)` is a count field which can
  be parameterized by a Poisson distribution. Let’s also change our
  boosting method to gradient boosted trees:

  ``` python

  cust_kernel = mf.ImputationKernel(
    iris_amp,
    datasets=1,
    random_state=1
  )

  cust_kernel.mice(
    iterations=1,
    variable_parameters={'sepal width (cm)': {'objective': 'poisson'}},
    boosting = 'gbdt',
    min_sum_hessian_in_leaf=0.01
  )
  ```

  Other nice parameters like `monotone_constraints` can also be passed.
  Setting the parameter `device: 'gpu'` will utilize GPU learning, if
  LightGBM is set up to do this on your machine.



  Note: It is probably a good idea to read [this
  section](https://github.com/AnotherSamWilson/miceforest#Predictive-Mean-Matching)
  first, to get some context on how mean matching works.

  The class `miceforest.MeanMatchScheme` contains information about how
  mean matching should be performed, such as:

  1)  Mean matching functions
  2)  Mean matching candidates
  3)  How to get predictions from a lightgbm model
  4)  The datatypes predictions are stored as

  There are three pre-built mean matching schemes that come with
  `miceforest`:

  ``` python
  from miceforest import (
    mean_match_default,
    mean_match_fast_cat,
    mean_match_shap
  )



  ```

  These schemes mostly differ in their strategy for performing mean
  matching

    - **mean\_match\_default** - medium speed, medium imputation quality
        - Categorical: perform a K Nearest Neighbors search on the
          candidate class probabilities, where K = mmc. Select 1 at
          random, and choose the associated candidate value as the
          imputation value.
        - Numeric: Perform a K Nearest Neighbors search on the candidate
          predictions, where K = mmc. Select 1 at random, and choose the
          associated candidate value as the imputation value.
    - **mean\_match\_fast\_cat** - fastest speed, lowest imputation
      quality
        - Categorical: return class based on random draw weighted by class
          probability for each sample.
        - Numeric: perform a K Nearest Neighbors search on the candidate
          class probabilities, where K = mmc. Select 1 at random, and
          choose the associated candidate value as the imputation value.
    - **mean\_match\_shap** - slowest speed, highest imputation quality
      for large datasets
        - Categorical: perform a K Nearest Neighbors search on the
          candidate prediction shap values, where K = mmc. Select 1 at
          random, and choose the associated candidate value as the
          imputation value.
        - Numeric: perform a K Nearest Neighbors search on the candidate
          prediction shap values, where K = mmc. Select 1 at random, and
          choose the associated candidate value as the imputation value.

  As a special case, if the mean\_match\_candidates is set to 0, the
  following behavior is observed for all schemes:

    - Categorical: the class with the highest probability is chosen.
    - Numeric: the predicted value is used

  These mean matching schemes can be updated and customized, we show an
  example below in the advanced section.



  Multiple Imputation can take a long time. If you wish to impute a
  dataset using the MICE algorithm, but don’t have time to train new
  models, it is possible to impute new datasets using a `ImputationKernel`
  object. The `impute_new_data()` function uses the models collected by
  `ImputationKernel` to perform multiple imputation without updating the
  models at each iteration:

  ``` python

  from datetime import datetime


  new_data = iris_amp.iloc[range(15)]



  kernel.compile_candidate_preds()

  start_t = datetime.now()
  new_data_imputed = kernel.impute_new_data(new_data=new_data)
  print(f"New Data imputed in {(datetime.now() - start_t).total_seconds()} seconds")
  ```

      

  All of the imputation parameters (variable\_schema,
  mean\_match\_candidates, etc) will be carried over from the original
  `ImputationKernel` object. When mean matching, the candidate values are
  pulled from the original kernel dataset. To impute new data, the
  `save_models` parameter in `ImputationKernel` must be \> 0. If
  `save_models == 1`, the model from the latest iteration is saved for
  each variable. If `save_models > 1`, the model from each iteration is
  saved. This allows for new data to be imputed in a more similar fashion
  to the original mice procedure.



  Kernels can be saved using the `.save_kernel()` method, and then loaded
  again using the `utils.load_kernel()` function. Internally, this
  procedure uses `blosc` and `dill` packages to do the following:

  1.  Convert working data to parquet bytes (if it is a pandas dataframe)
  2.  Serialize the kernel
  3.  Compress this serialization
  4.  Save to a file



  kernels can be fit into sklearn pipelines to impute training and scoring
  datasets:

  ``` python
  import numpy as np
  from sklearn.preprocessing import StandardScaler
  from sklearn.datasets import make_classification
  from sklearn.model_selection import train_test_split
  from sklearn.pipeline import Pipeline
  import miceforest as mf


  X, y = make_classification(random_state=0)


  X = mf.utils.ampute_data(X)
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)



  pipe_kernel = mf.ImputationKernel(X_train, datasets=1)


  pipe = Pipeline([
      ('impute', pipe_kernel),
      ('scaler', StandardScaler()),
  ])



  X_train_t = pipe.fit_transform(
      X_train,
      y_train,
      impute__iterations=2
  )


  X_test_t = pipe.transform(X_test)


  assert not np.any(np.isnan(X_train_t))
  assert not np.any(np.isnan(X_test_t))
  ```



  Multiple imputation is a complex process. However, `miceforest` allows
  all of the major components to be switched out and customized by the
  user.



  It is possible to heavily customize our imputation procedure by
  variable. By passing a named list to `variable_schema`, you can specify
  the predictor variables for each imputed variable. You can also specify
  `mean_match_candidates` and `data_subset` by variable by passing a dict
  of valid values, with variable names as keys. You can even replace the
  entire default mean matching function for certain objectives if desired.
  Below is an *extremely* convoluted setup, which you would probably never
  want to use. It simply shows what is possible:

  ``` python

  from miceforest import mean_match_default
  mean_match_custom = mean_match_default.copy()



  def custom_mmf(bachelor_preds):
      np.random.shuffle(bachelor_preds)
      return bachelor_preds




  mean_match_custom.set_mean_match_function(
    {"poisson": custom_mmf}
  )


  mean_match_custom.set_mean_match_candidates(
    {
        'sepal width (cm)': 3,
        'petal width (cm)': 0
    }
  )


  variable_schema = {
      'sepal width (cm)': ['species','petal width (cm)'],
      'petal width (cm)': ['species','sepal length (cm)']
  }


  variable_subset = {
    'sepal width (cm)': 50
  }




  variable_parameters = {
    'petal width (cm)': {"objective": "poisson"}
  }

  cust_kernel = mf.ImputationKernel(
      iris_amp,
      datasets=3,
      mean_match_scheme=mean_match_custom,
      variable_schema=variable_schema,
      data_subset=variable_subset
  )
  cust_kernel.mice(iterations=1, variable_parameters=variable_parameters)
  ```

  The mean matching function can take any number of the following
  arguments. If a function does not take one of these arguments, then the
  process will not prepare that data for mean matching.

  ``` python
  from miceforest.MeanMatchScheme import AVAILABLE_MEAN_MATCH_ARGS
  print("\n".join(AVAILABLE_MEAN_MATCH_ARGS))
  ```

      
      
      
      
      
      
      
      
      



  The MICE process itself is used to impute missing data in a dataset.
  However, sometimes a variable can be fully recognized in the training
  data, but needs to be imputed later on in a different dataset. It is
  possible to train models to impute variables even if they have no
  missing values by setting `train_nonmissing=True`. In this case,
  `variable_schema` is treated as the list of variables to train models
  on. `imputation_order` only affects which variables actually have their
  values imputed, it does not affect which variables have models trained:

  ``` python
  orig_missing_cols = ["sepal length (cm)", "sepal width (cm)"]
  new_missing_cols = ["sepal length (cm)", "sepal width (cm)", "species"]


  iris_amp2 = iris.copy()
  iris_amp2[orig_missing_cols] = mf.ampute_data(
    iris_amp2[orig_missing_cols],
    perc=0.25,
    random_state=1991
  )


  var_sch = new_missing_cols

  cust_kernel = mf.ImputationKernel(
      iris_amp2,
      datasets=1,
      variable_schema=var_sch,
      train_nonmissing=True
  )
  cust_kernel.mice(1)


  iris_amp2_new = iris.iloc[range(10),:].copy()
  iris_amp2_new[new_missing_cols] = mf.ampute_data(
    iris_amp2_new[new_missing_cols],
    perc=0.25,
    random_state=1991
  )


  iris_amp2_new_imp = cust_kernel.impute_new_data(iris_amp2_new)
  iris_amp2_new_imp.complete_data(0).isnull().sum()
  ```

      
      
      
      
      
      

  Here, we knew that the species column in our new data would need to be
  imputed. Therefore, we specified that a model should be built for all 3
  variables in the `variable_schema` (passing a dict of target - feature
  pairs would also have worked).



  `miceforest` allows you to tune the parameters on a kernel dataset.
  These parameters can then be used to build the models in future
  iterations of mice. In its most simple invocation, you can just call the
  function with the desired optimization steps:

  ``` python


  optimal_parameters, losses = kernel.tune_parameters(
    dataset=0,
    optimization_steps=5
  )


  kernel.mice(1, variable_parameters=optimal_parameters)


  print(optimal_parameters)
  ```

      

  This will perform 10 fold cross validation on random samples of
  parameters. By default, all variables models are tuned. If you are
  curious about the default parameter space that is searched within, check
  out the `miceforest.default_lightgbm_parameters` module.

  The parameter tuning is pretty flexible. If you wish to set some model
  parameters static, or to change the bounds that are searched in, you can
  simply pass this information to either the `variable_parameters`
  parameter, `**kwbounds`, or both:

  ``` python

  optimal_parameters, losses = kernel.tune_parameters(
    dataset=0,
    variables = ['sepal width (cm)','species','petal width (cm)'],
    variable_parameters = {
      'sepal width (cm)': {'bagging_fraction': 0.5},
      'species': {'bagging_freq': (5,10)}
    },
    optimization_steps=5,
    extra_trees = [True, False]
  )

  kernel.mice(1, variable_parameters=optimal_parameters)
  ```

  In this example, we did a few things - we specified that only `sepal
  width (cm)`, `species`, and `petal width (cm)` should be tuned. We also
  specified some specific parameters in `variable_parameters.` Notice that
  `bagging_fraction` was passed as a scalar, `0.5`. This means that, for
  the variable `sepal width (cm)`, the parameter `bagging_fraction` will
  be set as that number and not be tuned. We did the opposite for
  `bagging_freq`. We specified bounds that the process should search in.
  We also passed the argument `extra_trees` as a list. Since it was passed
  to \*\*kwbounds, this parameter will apply to all variables that are
  being tuned. Passing values as a list tells the process that it should
  randomly sample values from the list, instead of treating them as set of
  counts to search within.

  The tuning process follows these rules for different parameter values it
  finds:

    - Scalar: That value is used, and not tuned.
    - Tuple: Should be length 2. Treated as the lower and upper bound to
      search in.
    - List: Treated as a distinct list of values to try randomly.



  `miceforest` allows for different “levels” of reproducibility, global
  and record-level.



  Global reproducibility ensures that the same values will be imputed if
  the same code is run multiple times. To ensure global reproducibility,
  all the user needs to do is set a `random_state` when the kernel is
  initialized.



  Sometimes we want to obtain reproducible imputations at the record
  level, without having to pass the same dataset. This is possible by
  passing a list of record-specific seeds to the `random_seed_array`
  parameter. This is useful if imputing new data multiple times, and you
  would like imputations for each row to match each time it is imputed.

  ``` python

  random_seed_array = np.random.randint(9999, size=150)
  iris_imputed = kernel.impute_new_data(
      iris_amp,
      random_state=4,
      random_seed_array=random_seed_array
  )


  new_inds = np.random.choice(150, size=15)
  new_data = iris_amp.loc[new_inds]
  new_seeds = random_seed_array[new_inds]
  new_imputed = kernel.impute_new_data(
      new_data,
      random_state=4,
      random_seed_array=new_seeds
  )



  assert new_imputed.complete_data(0).equals(iris_imputed.complete_data(0).loc[new_inds])
  ```

  Note that record-level reproducibility is only possible in the
  `impute_new_data` function, there are no guarantees of record-level
  reproducibility in imputations between the kernel and new data.



  Multiple Imputation is one of the most robust ways to handle missing
  data - but it can take a long time. There are several strategies you can
  use to decrease the time a process takes to run:

    - Decrease `data_subset`. By default all non-missing datapoints for
      each variable are used to train the model and perform mean matching.
      This can cause the model training nearest-neighbors search to take a
      long time for large data. A subset of these points can be searched
      instead by using `data_subset`.
    - If categorical columns are taking a long time, you can use the
      `mean_match_fast_cat` scheme. You can also set different parameters
      specifically for categorical columns, like smaller
      `bagging_fraction` or `num_iterations`.
    - If you need to impute new data faster, compile the predictions with
      the `compile_candidate_preds` method. This stores the predictions
      for each model, so it does not need to be re-calculated at each
      iteration.
    - Convert your data to a numpy array. Numpy arrays are much faster to
      index. While indexing overhead is avoided as much as possible, there
      is no getting around it. Consider comverting to `float32` datatype
      as well, as it will cause the resulting object to take up much less
      memory.
    - Decrease `mean_match_candidates`. The maximum number of neighbors
      that are considered with the default parameters is 10. However, for
      large datasets, this can still be an expensive operation. Consider
      explicitly setting `mean_match_candidates` lower.
    - Use different lightgbm parameters. lightgbm is usually not the
      problem, however if a certain variable has a large number of
      classes, then the max number of trees actually grown is (\# classes)
      \* (n\_estimators). You can specifically decrease the bagging
      fraction or n\_estimators for large multi-class variables, or grow
      less trees in general.
    - Use a faster mean matching function. The default mean matching
      function uses the scipy.Spatial.KDtree algorithm. There are faster
      alternatives out there, if you think mean matching is the holdup.



  It is possible to run the entire process without copying the dataset. If
  `copy_data=False`, then the data is referenced directly:

  ``` python
  kernel_inplace = mf.ImputationKernel(
    iris_amp,
    datasets=1,
    copy_data=False
  )
  kernel_inplace.mice(2)
  ```

  Note, that this probably won’t (but could) change the original dataset
  in undesirable ways. Throughout the `mice` procedure, imputed values are
  stored directly in the original data. At the end, the missing values are
  put back as `np.NaN`.

  We can also complete our original data in place:

  ``` python
  kernel_inplace.complete_data(dataset=0, inplace=True)
  print(iris_amp.isnull().sum(0))
  ```

      
      
      
      
      
      

  This is useful if the dataset is large, and copies can’t be made in
  memory.



  As of now, miceforest has four diagnostic plots available.



  We probably want to know how the imputed values are distributed. We can
  plot the original distribution beside the imputed distributions in each
  dataset by using the `plot_imputed_distributions` method of an
  `ImputationKernel` object:

  ``` python
  kernel.plot_imputed_distributions(wspace=0.3,hspace=0.3)
  ```

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/distributions.png" width="600px" />

  The red line is the original data, and each black line are the imputed
  values of each dataset.



  We are probably interested in knowing how our values between datasets
  converged over the iterations. The `plot_correlations` method shows you
  a boxplot of the correlations between imputed values in every
  combination of datasets, at each iteration. This allows you to see how
  correlated the imputations are between datasets, as well as the
  convergence over iterations:

  ``` python
  kernel.plot_correlations()
  ```

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/plot_corr.png" width="600px" />



  We also may be interested in which variables were used to impute each
  variable. We can plot this information by using the
  `plot_feature_importance` method.

  ``` python
  kernel.plot_feature_importance(dataset=0, annot=True,cmap="YlGnBu",vmin=0, vmax=1)
  ```

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/var_imp.png" width="600px" />

  The numbers shown are returned from the
  `lightgbm.Booster.feature_importance()` function. Each square represents
  the importance of the column variable in imputing the row variable.



  If our data is not missing completely at random, we may see that it
  takes a few iterations for our models to get the distribution of
  imputations right. We can plot the average value of our imputations to
  see if this is occurring:

  ``` python
  kernel.plot_mean_convergence(wspace=0.3, hspace=0.4)
  ```

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/mean_convergence.png" width="600px" />

  Our data was missing completely at random, so we don’t see any
  convergence occurring here.



  To return the imputed data simply use the `complete_data` method:

  ``` python
  dataset_1 = kernel.complete_data(0)
  ```

  This will return a single specified dataset. Multiple datasets are
  typically created so that some measure of confidence around each
  prediction can be created.

  Since we know what the original data looked like, we can cheat and see
  how well the imputations compare to the original data:

  ``` python
  acclist = []
  for iteration in range(kernel.iteration_count()+1):
      species_na_count = kernel.na_counts[4]
      compdat = kernel.complete_data(dataset=0,iteration=iteration)

      
      acclist.append(
        round(1-sum(compdat['species'] != iris['species'])/species_na_count,2)
      )



  print(acclist)
  ```

      

  In this instance, we went from a low accuracy (what is expected with
  random sampling) to a much higher accuracy.



  Multiple Imputation by Chained Equations ‘fills in’ (imputes) missing
  data in a dataset through an iterative series of predictive models. In
  each iteration, each specified variable in the dataset is imputed using
  the other variables in the dataset. These iterations should be run until
  it appears that convergence has been met.

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/MICEalgorithm.png" style="display: block; margin: auto;" />

  This process is continued until all specified variables have been
  imputed. Additional iterations can be run if it appears that the average
  imputed values have not converged, although no more than 5 iterations
  are usually necessary.





  MICE is particularly useful if missing values are associated with the
  target variable in a way that introduces leakage. For instance, let’s
  say you wanted to model customer retention at the time of sign up. A
  certain variable is collected at sign up or 1 month after sign up. The
  absence of that variable is a data leak, since it tells you that the
  customer did not retain for 1 month.



  Information is often collected at different stages of a ‘funnel’. MICE
  can be used to make educated guesses about the characteristics of
  entities at different points in a funnel.



  MICE can be used to impute missing values, however it is important to
  keep in mind that these imputed values are a prediction. Creating
  multiple datasets with different imputed values allows you to do two
  types of inference:

    - Imputed Value Distribution: A profile can be built for each imputed
      value, allowing you to make statements about the likely distribution
      of that value.
    - Model Prediction Distribution: With multiple datasets, you can build
      multiple models and create a distribution of predictions for each
      sample. Those samples with imputed values which were not able to be
      imputed with much confidence would have a larger variance in their
      predictions.



  `miceforest` can make use of a procedure called predictive mean matching
  (PMM) to select which values are imputed. PMM involves selecting a
  datapoint from the original, nonmissing data (candidates) which has a
  predicted value close to the predicted value of the missing sample
  (bachelors). The closest N (`mean_match_candidates` parameter) values
  are selected, from which a value is chosen at random. This can be
  specified on a column-by-column basis. Going into more detail from our
  example above, we see how this works in practice:

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/PMM.png" style="display: block; margin: auto;" />

  This method is very useful if you have a variable which needs imputing
  which has any of the following characteristics:

    - Multimodal
    - Integer
    - Skewed



  As an example, let’s construct a dataset with some of the above
  characteristics:

  ``` python
  randst = np.random.RandomState(1991)

  nrws = 1000
  uniform_vec = randst.uniform(size=nrws)

  def make_bimodal(mean1,mean2,size):
      bimodal_1 = randst.normal(size=nrws, loc=mean1)
      bimodal_2 = randst.normal(size=nrws, loc=mean2)
      bimdvec = []
      for i in range(size):
          bimdvec.append(randst.choice([bimodal_1[i], bimodal_2[i]]))
      return np.array(bimdvec)


  close_bimodal_vec = make_bimodal(2,-2,nrws)
  far_bimodal_vec = make_bimodal(3,-3,nrws)



  skewed_vec = np.exp(uniform_vec*randst.uniform(size=nrws)*3) + randst.uniform(size=nrws)*3


  integer_vec = np.round(uniform_vec + close_bimodal_vec/3 + randst.uniform(size=nrws)*2)


  dat = pd.DataFrame(
      {
      'uniform_var':uniform_vec,
      'close_bimodal_var':close_bimodal_vec,
      'far_bimodal_var':far_bimodal_vec,
      'skewed_var':skewed_vec,
      'integer_var':integer_vec
      }
  )


  ampdat = mf.ampute_data(dat,perc=0.25,random_state=randst)


  import seaborn as sns
  import matplotlib.pyplot as plt
  g = sns.PairGrid(dat)
  g.map(plt.scatter,s=5)
  ```

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/dataset.png" width="600px" style="display: block; margin: auto;" />
  We can see how our variables are distributed and correlated in the graph
  above. Now let’s run our imputation process twice, once using mean
  matching, and once using the model prediction.

  ``` python
  from miceforest import mean_match_default
  scheme_mmc_0 = mean_match_default.copy()
  scheme_mmc_5 = mean_match_default.copy()

  scheme_mmc_0.set_mean_match_candidates(0)
  scheme_mmc_5.set_mean_match_candidates(5)

  kernelmeanmatch = mf.ImputationKernel(ampdat, mean_match_scheme=scheme_mmc_5, datasets=1)
  kernelmodeloutput = mf.ImputationKernel(ampdat, mean_match_scheme=scheme_mmc_0, datasets=1)

  kernelmeanmatch.mice(2)
  kernelmodeloutput.mice(2)
  ```

  Let’s look at the effect on the different variables.



  ``` python
  kernelmeanmatch.plot_imputed_distributions(wspace=0.2,hspace=0.4)
  ```

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/meanmatcheffects.png" width="600px" style="display: block; margin: auto;" />



  ``` python
  kernelmodeloutput.plot_imputed_distributions(wspace=0.2,hspace=0.4)
  ```

  <img src="https://raw.githubusercontent.com/AnotherSamWilson/miceforest/master/examples/nomeanmatching.png" width="600px" style="display: block; margin: auto;" />

  You can see the effects that mean matching has, depending on the
  distribution of the data. Simply returning the value from the model
  prediction, while it may provide a better ‘fit’, will not provide
  imputations with a similair distribution to the original. This may be
  beneficial, depending on your goal.


pkgId: e622d835c59f6485a2770ace869908e1afaa2c1c6a9a36b96e6eec2c883c99ee
name: python-microfs
arch: src
version: 1.4.5
epoch: 0
release: 1
summary: A module and utility to work with the simple filesystem on the BBC micro:bit
url: https://github.com/ntoll/microfs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e31e4cc1-34c9-47e9-8e47-3fb951c6a975
location_href: 00004197-python-microfs/python-microfs-1.4.5-1.src.rpm
checksum_type: sha256
description:
  A simple command line tool and module for interacting with the limited
  file system provided by MicroPython on the BBC micro:bit.
  Installation
  ++++++++++++
  To install simply type::
      $ pip install microfs
  latest version, use the following command::
      $ pip install --no-cache --upgrade microfs
  Usage
  +++++
  There are two ways to use microfs - as a module in your Python code or as a
  stand-alone command to use from your shell (``ufs``).


pkgId: ffd304675d191e88d2d22815cf4ccf0ffd6d6c209e000cc2c21a862d78d9981f
name: python-mido
arch: src
version: 1.2.10
epoch: 0
release: 1
summary: MIDI Objects for Python
url: https://mido.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-32660791-4e3e-4aa9-95df-d49ee17482b2
location_href: 00004198-python-mido/python-mido-1.2.10-1.src.rpm
checksum_type: sha256
description:
  Mido is a library for working with MIDI messages and ports:
     >>> import mido
     >>> msg = mido.Message('note_on', note=60)
     >>> msg.type
     'note_on'
     >>> msg.note
     60
     >>> msg.bytes()
     [144, 60, 64]
     >>> msg.copy(channel=2)
     Message('note_on', channel=2, note=60, velocity=64, time=0)
     port = mido.open_output('Port Name')
     port.send(msg)
      with mido.open_input() as inport:
          for msg in inport:
              print(msg)
      mid = mido.MidiFile('song.mid')
      for msg in mid.play():
          port.send(msg)
  Full documentation at https://mido.readthedocs.io/


pkgId: df2ad851942f92edf7becf694287f90a8662c294fe6f80a58a2bc665493c929d
name: python-migen
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Python toolbox for building complex digital hardware
url: https://m-labs.hk
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26e1ee92-197c-450a-beec-2bd77a5b1e13
location_href: 00004199-python-migen/python-migen-0.9.2-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/m-labs/migen/raw/master/doc/migen_logo.png" alt="migen logo" width="150"/>



  Despite being faster than schematics entry, hardware design with Verilog and
  VHDL remains tedious and inefficient for several reasons. The event-driven
  model introduces issues and manual coding that are unnecessary for synchronous
  circuits, which represent the lion's share of today's logic designs. Counter-
  intuitive arithmetic rules result in steeper learning curves and provide a
  fertile ground for subtle bugs in designs. Finally, support for procedural
  generation of logic (metaprogramming) through "generate" statements is very
  limited and restricts the ways code can be made generic, reused and organized.

  To address those issues, we have developed the **Migen FHDL** library that
  replaces the event-driven paradigm with the notions of combinatorial and
  synchronous statements, has arithmetic rules that make integers always behave
  like mathematical integers, and most importantly allows the design's logic to
  be constructed by a Python program. This last point enables hardware designers
  to take advantage of the richness of the Python language - object oriented
  programming, function parameters, generators, operator overloading, libraries,
  etc. - to build well organized, reusable and elegant designs.

  Other Migen libraries are built on FHDL and provide various tools such as a
  system-on-chip interconnect infrastructure, a dataflow programming system, a
  more traditional high-level synthesizer that compiles Python routines into
  state machines with datapaths, and a simulator that allows test benches to be
  written in Python.

  See the doc/ folder for more technical information.

  Migen is designed for Python 3.5. Note that Migen is **not** spelled MiGen.



  Code repository:
  https://github.com/m-labs/migen

  System-on-chip design based on Migen:
  https://github.com/m-labs/misoc

  Online documentation:
  https://m-labs.hk/migen/manual/



  ```python
  from migen import *
  from migen.build.platforms import m1
  plat = m1.Platform()
  led = plat.request("user_led")
  m = Module()
  counter = Signal(26)
  m.comb += led.eq(counter[25])
  m.sync += counter.eq(counter + 1)
  plat.build(m)
  ```



  Migen is released under the very permissive two-clause BSD license. Under the
  terms of this license, you are authorized to use Migen for closed-source
  proprietary designs.
  Even though we do not require you to do so, those things are awesome, so please
  do them if possible:
  * tell us that you are using Migen
  * put the Migen logo (doc/migen_logo.svg) on the page of a product using it,
    with a link to http://m-labs.hk
  * cite Migen in publications related to research it has helped
  * send us feedback and suggestions for improvements
  * send us bug reports when something goes wrong
  * send us the modifications and improvements you have done to Migen. The use
     of "git format-patch" is recommended. If your submission is large and
     complex and/or you are not sure how to proceed, feel free to discuss it on
     the mailing list or IRC (#m-labs on Freenode) beforehand.

  See LICENSE file for full copyright and license info. You can contact us on the
  public mailing list devel [AT] lists.m-labs.hk.

    "Electricity! It's like magic!"


pkgId: 3f491bef0f0185c176feb0ac54ebe3a3621fc42364640b5bfa9a99d71dee92b1
name: python-mimerender
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: RESTful HTTP Content Negotiation for Flask, Bottle, web.py and webapp2 (Google App Engine)
url: https://github.com/martinblech/mimerender
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26d1e7fb-527c-4085-a2ae-feea52f4a04f
location_href: 00004201-python-mimerender/python-mimerender-0.6.0-1.src.rpm
checksum_type: sha256
description:
  This module provides a decorator that wraps a HTTP
      request handler to select the correct render function for a given HTTP
      Accept header. It uses mimeparse to parse the accept string and select the
      best available representation. Supports Flask, Bottle, web.py and webapp2
      out of the box, and it's easy to add support for other frameworks.


pkgId: 1cbcfdbb63245034baaf32133e0c0eb99225658757b765e1569bbe7c138f8482
name: python-minimal-snowplow-tracker
arch: src
version: 0.0.2
epoch: 0
release: 1
url: https://www.fishtownanalytics.com
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b8594c86-6290-4e90-9f98-e1b0a10eed35
location_href: 00009648-python-minimal-snowplow-tracker/python-minimal-snowplow-tracker-0.0.2-1.src.rpm
checksum_type: sha256
summary:
  A minimal snowplow event tracker for Python. Add analytics to your Python and Django apps, webapps and games


pkgId: 0e905d0697973ec2b23d87b7bcac360445ad899249acae4a822ce78156b3c0e4
name: python-minio
arch: src
version: 7.1.14
epoch: 0
release: 1
summary: MinIO Python SDK for Amazon S3 Compatible Cloud Storage
url: https://github.com/minio/minio-py
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-68d80bd4-b281-4954-9032-40a9d083db3f
location_href: 00009617-python-minio/python-minio-7.1.14-1.src.rpm
checksum_type: sha256
description:
  MinIO Python SDK is Simple Storage Service (aka S3) client to perform bucket and object operations to any Amazon S3 compatible object storage service.

  For a complete list of APIs and examples, please take a look at the [Python Client API Reference](https://min.io/docs/minio/linux/developers/python/API.html)


  Python 3.7 or higher.



  ```sh
  pip3 install minio
  ```



  ```sh
  git clone https://github.com/minio/minio-py
  cd minio-py
  python setup.py install
  ```


  This example program connects to an S3-compatible object storage server, make a bucket on that server, and upload a file to the bucket.

  You need the following items to connect to an S3-compatible object storage server:

  | Parameters | Description                                                |
  |------------|------------------------------------------------------------|
  | Endpoint   | URL to S3 service.                                         |
  | Access Key | Access key (aka user ID) of an account in the S3 service.  |
  | Secret Key | Secret key (aka password) of an account in the S3 service. |

  This example uses MinIO server playground [https://play.min.io](https://play.min.io). Feel free to use this service for test and development.


  ```py
  from minio import Minio
  from minio.error import S3Error


  def main():
      
      
      client = Minio(
          "play.min.io",
          access_key="Q3AM3UQ867SPQQA43P2F",
          secret_key="zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG",
      )

      
      found = client.bucket_exists("asiatrip")
      if not found:
          client.make_bucket("asiatrip")
      else:
          print("Bucket 'asiatrip' already exists")

      
      
      client.fput_object(
          "asiatrip", "asiaphotos-2015.zip", "/home/user/Photos/asiaphotos.zip",
      )
      print(
          "'/home/user/Photos/asiaphotos.zip' is successfully uploaded as "
          "object 'asiaphotos-2015.zip' to bucket 'asiatrip'."
      )


  if __name__ == "__main__":
      try:
          main()
      except S3Error as exc:
          print("error occurred.", exc)
  ```


  ```sh
  $ python file_uploader.py
  '/home/user/Photos/asiaphotos.zip' is successfully uploaded as object 'asiaphotos-2015.zip' to bucket 'asiatrip'.

  $ mc ls play/asiatrip/
  [2016-06-02 18:10:29 PDT]  82KiB asiaphotos-2015.zip
  ```


  * [Python Client API Reference](https://min.io/docs/minio/linux/developers/python/API.html)
  * [Examples](https://github.com/minio/minio-py/tree/release/examples)


  * [Complete Documentation](https://min.io/docs/minio/kubernetes/upstream/index.html)


  Please refer [Contributors Guide](https://github.com/minio/minio-py/blob/release/CONTRIBUTING.md)

  [![PYPI](https://img.shields.io/pypi/v/minio.svg)](https://pypi.python.org/pypi/minio)


pkgId: 531133e5dd0c7a44c26af602cc77da587b5c67f687784a7548066a92c9bb7008
name: python-mir_eval
arch: src
version: 0.7
epoch: 0
release: 1
summary: Common metrics for common audio/music processing tasks.
url: https://github.com/craffel/mir_eval
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb9fe97f-2528-4989-9b84-af469d7dfff8
location_href: 00011627-python-mir-eval/python-mir_eval-0.7-1.src.rpm
checksum_type: sha256
description:
  Python library for computing common heuristic accuracy scores for various music/audio information retrieval/signal processing tasks.
  Documentation, including installation and usage information: http://craffel.github.io/mir_eval/
  If you're looking for the mir_eval web service, which you can use to run mir_eval without installing anything or writing any code, it can be found here: http://labrosa.ee.columbia.edu/mir_eval/
  Dependencies:
  * `Scipy/Numpy <http://www.scipy.org/>`_
  * future
  * six
  If you use mir_eval in a research project, please cite the following paper:
  Colin Raffel, Brian McFee, Eric J. Humphrey, Justin Salamon, Oriol Nieto, Dawen Liang, and Daniel P. W. Ellis, "`mir_eval: A Transparent Implementation of Common MIR Metrics <http://colinraffel.com/publications/ismir2014mir_eval.pdf>`_", Proceedings of the 15th International Conference on Music Information Retrieval, 2014.


pkgId: da0fab84d01a4497826ab408aa8136e78c3f165b55a76d717a6d48344ab12a1d
name: python-missingpy
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Missing Data Imputation for Python
url: https://github.com/epsilon-machine/missingpy
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-610ef0f1-ea1b-4093-a39b-1c48b3749dbd
location_href: 00010257-python-missingpy/python-missingpy-0.2.0-1.src.rpm
checksum_type: sha256
description:
      missing_values : integer or "NaN", optional (default = "NaN")
          The placeholder for the missing values. All occurrences of
          `missing_values` will be imputed. For missing values encoded as
          ``np.nan``, use the string value "NaN".
      n_neighbors : int, optional (default = 5)
          Number of neighboring samples to use for imputation.
      weights : str or callable, optional (default = "uniform")
          Weight function used in prediction.  Possible values:
          - 'uniform' : uniform weights.  All points in each neighborhood
            are weighted equally.
          - 'distance' : weight points by the inverse of their distance.
            in this case, closer neighbors of a query point will have a
            greater influence than neighbors which are further away.
          - [callable] : a user-defined function which accepts an
            array of distances, and returns an array of the same shape
            containing the weights.
      metric : str or callable, optional (default = "masked_euclidean")
          Distance metric for searching neighbors. Possible values:
          - 'masked_euclidean'
          - [callable] : a user-defined function which conforms to the
          definition of _pairwise_callable(X, Y, metric, **kwds). In other
          words, the function accepts two arrays, X and Y, and a
          ``missing_values`` keyword in **kwds and returns a scalar distance
          value.
      row_max_missing : float, optional (default = 0.5)
          The maximum fraction of columns (i.e. features) that can be missing
          before the sample is excluded from nearest neighbor imputation. It
          means that such rows will not be considered a potential donor in
          ``fit()``, and in ``transform()`` their missing feature values will be
          imputed to be the column mean for the entire dataset.
      col_max_missing : float, optional (default = 0.8)
          The maximum fraction of rows (or samples) that can be missing
          for any feature beyond which an error is raised.
      copy : boolean, optional (default = True)
          If True, a copy of X will be created. If False, imputation will
          be done in-place whenever possible. Note that, if metric is
          "masked_euclidean" and copy=False then missing_values in the
          input matrix X will be overwritten with zeros.


pkgId: d10df826e41ed76100c8863b967cc776a49c80fe760f0cb4e354a08adea975e0
name: python-mitogen
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Library for writing distributed self-replicating programs.
url: https://github.com/mitogen-hq/mitogen/
rpm_license: New BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8584562e-51cb-4209-b2d0-03acf1f4b771
location_href: 00004210-python-mitogen/python-mitogen-0.3.3-1.src.rpm
checksum_type: sha256
description:
  <a href="https://mitogen.networkgenomics.com/">Please see the documentation</a>.

  ![](https://i.imgur.com/eBM6LhJ.gif)

  [![Total alerts](https://img.shields.io/lgtm/alerts/g/mitogen-hq/mitogen.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/mitogen-hq/mitogen/alerts/)

  [![Build Status](https://dev.azure.com/mitogen-hq/mitogen/_apis/build/status/mitogen-hq.mitogen?branchName=master)](https://dev.azure.com/mitogen-hq/mitogen/_build/latest?definitionId=1&branchName=master)


pkgId: 096b942cccab5d81d7ea9eab6915942bd0e248b60ccd910a315e7acea22a20e8
name: python-mixer
arch: src
version: 7.2.2
epoch: 0
release: 1
url: https://github.com/klen/mixer
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1cf137de-7e26-4025-bc73-b619f6735bb9
location_href: 00012399-python-mixer/python-mixer-7.2.2-1.src.rpm
checksum_type: sha256
summary:
  Mixer -- Is a fixtures replacement. Supported Django ORM, SqlAlchemy ORM, Mongoengine ODM and custom python objects.

description:
  - Python 3.7+
  - Django (3.0, 3.1) for Django ORM support;
  - Flask-SQLALchemy for SQLAlchemy ORM support and integration as Flask application;
  - Faker >= 0.7.3
  - Mongoengine for Mongoengine ODM support;
  - SQLAlchemy for SQLAlchemy ORM support;
  - Peewee ORM support;


pkgId: b0603d36a9d731d9a558c382927b1651320a24e63f9cf011ad1799f71066a65b
name: python-mixpanel
arch: src
version: 4.10.0
epoch: 0
release: 1
summary: Official Mixpanel library for Python
url: https://github.com/mixpanel/mixpanel-python
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5df2c15f-e543-486c-a175-fbd6205d8950
location_href: 00010205-python-mixpanel/python-mixpanel-4.10.0-1.src.rpm
checksum_type: sha256
description:
  This is the official Mixpanel Python library. This library allows for
  server-side integration of Mixpanel.
  To import, export, transform, or delete your Mixpanel data, please see our
  `mixpanel-utils package`_.


pkgId: c4021cc994b9c489bd6ae00f4331ceea1cbf7a01b623e3cb4faf1e17007a19dd
name: python-mkdocs-git-revision-date-localized-plugin
arch: src
version: 1.2.0
epoch: 0
release: 1
url: https://github.com/timvink/mkdocs-git-revision-date-localized-plugin
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-675f95ea-f927-4ef3-8a0c-df3484f8db4f
checksum_type: sha256
summary:
  Mkdocs plugin that enables displaying the localized date of the last git modification of a markdown file.

description:
  [![Actions Status](https://github.com/timvink/mkdocs-git-revision-date-localized-plugin/workflows/pytest/badge.svg)](https://github.com/timvink/mkdocs-git-revision-date-localized-plugin/actions)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mkdocs-git-revision-date-localized-plugin)
  ![PyPI](https://img.shields.io/pypi/v/mkdocs-git-revision-date-localized-plugin)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/mkdocs-git-revision-date-localized-plugin)
  ![GitHub contributors](https://img.shields.io/github/contributors/timvink/mkdocs-git-revision-date-localized-plugin)
  ![PyPI - License](https://img.shields.io/pypi/l/mkdocs-git-revision-date-localized-plugin)



  [MkDocs](https://www.mkdocs.org/) plugin that enables displaying the date of the last git modification of a page. The plugin uses [babel](https://github.com/python-babel/babel/tree/master/babel) and [timeago.js](https://github.com/hustcc/timeago.js) to provide different localized date formats. Initial fork from [mkdocs-git-revision-date-plugin](https://github.com/zhaoterryy/mkdocs-git-revision-date-plugin).

  ![demo](https://github.com/timvink/mkdocs-git-revision-date-localized-plugin/raw/master/demo_screencast.gif)

  (*Example when used together with the [mkdocs-material](https://github.com/squidfunk/mkdocs-material) theme*)

  Other MkDocs plugins that use information from git:

  - [mkdocs-git-authors-plugin](https://github.com/timvink/mkdocs-git-authors-plugin) for displaying the authors from git
  - [mkdocs-git-committers-plugin](https://github.com/byrnereese/mkdocs-git-committers-plugin) for displaying authors' github user profiles



  Install the plugin using `pip3` with the following command:

  ```bash
  pip3 install mkdocs-git-revision-date-localized-plugin
  ```

  Next, add the following lines to your `mkdocs.yml`:

  ```yaml
  plugins:
    - search
    - git-revision-date-localized
  ```

  > If you have no `plugins` entry in your config file yet, you'll likely also want to add the `search` plugin. MkDocs enables it by default if there is no `plugins` entry set.

  The [mkdocs-material](https://squidfunk.github.io/mkdocs-material/) theme supports `git-revision-date-localized`. After installing the plugin and updating your `mkdocs.yml` you should see the last revision date on the bottom of your pages. Other mkdocs themes require [additional customization](https://timvink.github.io/mkdocs-git-revision-date-localized-plugin/howto/override-a-theme/).

  See the [documentation](https://timvink.github.io/mkdocs-git-revision-date-localized-plugin/index.html) on how to fine-tune the appearance and the date format.



  This plugin needs access to the last commit that touched a specific file to be able to retrieve the date. By default many build environments only retrieve the last commit, which means you might need to:

  <details>
    <summary>Change your CI settings</summary>
      <ul>
        <li>github actions: set <code>fetch-depth</code> to <code>0</code> (<a href="https://github.com/actions/checkout">docs</a>)</li>
        <li>gitlab runners: set <code>GIT_DEPTH</code> to <code>0</code> (<a href="https://docs.gitlab.com/ee/ci/pipelines/settings.html#limit-the-number-of-changes-fetched-during-clone">docs</a>)</li>
        <li>bitbucket pipelines: set <code>clone: depth: full</code> (<a href="https://support.atlassian.com/bitbucket-cloud/docs/configure-bitbucket-pipelinesyml/">docs</a>)</li>
      </ul>
  </details>




  See [timvink.github.io/mkdocs-git-revision-date-localized-plugin](https://timvink.github.io/mkdocs-git-revision-date-localized-plugin/index.html).



  Contributions are very welcome! Please read [CONTRIBUTING.md](https://github.com/timvink/mkdocs-git-revision-date-localized-plugin/blob/master/CONTRIBUTING.md) before putting in any work.

location_href:
  00012887-python-mkdocs-git-revision-date-localized-plugin/python-mkdocs-git-revision-date-localized-plugin-1.2.0-1.src.rpm


pkgId: 5156c0aa6f92516cdda912d4334c42692d93541a476314159948da7cf9da714f
name: python-mkdocs-git-revision-date-localized-plugin-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for mkdocs-git-revision-date-localized-plugin
url: https://github.com/timvink/mkdocs-git-revision-date-localized-plugin
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-675f95ea-f927-4ef3-8a0c-df3484f8db4f
rpm_sourcerpm: python-mkdocs-git-revision-date-localized-plugin-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/timvink/mkdocs-git-revision-date-localized-plugin/workflows/pytest/badge.svg)](https://github.com/timvink/mkdocs-git-revision-date-localized-plugin/actions)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mkdocs-git-revision-date-localized-plugin)
  ![PyPI](https://img.shields.io/pypi/v/mkdocs-git-revision-date-localized-plugin)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/mkdocs-git-revision-date-localized-plugin)
  ![GitHub contributors](https://img.shields.io/github/contributors/timvink/mkdocs-git-revision-date-localized-plugin)
  ![PyPI - License](https://img.shields.io/pypi/l/mkdocs-git-revision-date-localized-plugin)



  [MkDocs](https://www.mkdocs.org/) plugin that enables displaying the date of the last git modification of a page. The plugin uses [babel](https://github.com/python-babel/babel/tree/master/babel) and [timeago.js](https://github.com/hustcc/timeago.js) to provide different localized date formats. Initial fork from [mkdocs-git-revision-date-plugin](https://github.com/zhaoterryy/mkdocs-git-revision-date-plugin).

  ![demo](https://github.com/timvink/mkdocs-git-revision-date-localized-plugin/raw/master/demo_screencast.gif)

  (*Example when used together with the [mkdocs-material](https://github.com/squidfunk/mkdocs-material) theme*)

  Other MkDocs plugins that use information from git:

  - [mkdocs-git-authors-plugin](https://github.com/timvink/mkdocs-git-authors-plugin) for displaying the authors from git
  - [mkdocs-git-committers-plugin](https://github.com/byrnereese/mkdocs-git-committers-plugin) for displaying authors' github user profiles



  Install the plugin using `pip3` with the following command:

  ```bash
  pip3 install mkdocs-git-revision-date-localized-plugin
  ```

  Next, add the following lines to your `mkdocs.yml`:

  ```yaml
  plugins:
    - search
    - git-revision-date-localized
  ```

  > If you have no `plugins` entry in your config file yet, you'll likely also want to add the `search` plugin. MkDocs enables it by default if there is no `plugins` entry set.

  The [mkdocs-material](https://squidfunk.github.io/mkdocs-material/) theme supports `git-revision-date-localized`. After installing the plugin and updating your `mkdocs.yml` you should see the last revision date on the bottom of your pages. Other mkdocs themes require [additional customization](https://timvink.github.io/mkdocs-git-revision-date-localized-plugin/howto/override-a-theme/).

  See the [documentation](https://timvink.github.io/mkdocs-git-revision-date-localized-plugin/index.html) on how to fine-tune the appearance and the date format.



  This plugin needs access to the last commit that touched a specific file to be able to retrieve the date. By default many build environments only retrieve the last commit, which means you might need to:

  <details>
    <summary>Change your CI settings</summary>
      <ul>
        <li>github actions: set <code>fetch-depth</code> to <code>0</code> (<a href="https://github.com/actions/checkout">docs</a>)</li>
        <li>gitlab runners: set <code>GIT_DEPTH</code> to <code>0</code> (<a href="https://docs.gitlab.com/ee/ci/pipelines/settings.html#limit-the-number-of-changes-fetched-during-clone">docs</a>)</li>
        <li>bitbucket pipelines: set <code>clone: depth: full</code> (<a href="https://support.atlassian.com/bitbucket-cloud/docs/configure-bitbucket-pipelinesyml/">docs</a>)</li>
      </ul>
  </details>




  See [timvink.github.io/mkdocs-git-revision-date-localized-plugin](https://timvink.github.io/mkdocs-git-revision-date-localized-plugin/index.html).



  Contributions are very welcome! Please read [CONTRIBUTING.md](https://github.com/timvink/mkdocs-git-revision-date-localized-plugin/blob/master/CONTRIBUTING.md) before putting in any work.

location_href:
  00012887-python-mkdocs-git-revision-date-localized-plugin/python-mkdocs-git-revision-date-localized-plugin-help-1.2.0-1.noarch.rpm


pkgId: 54e29725b9ebf08a66fdec3a1e2b36590c44eee2c0e9ac9088f19d6aecc3f967
name: python-mkdocs-macros-plugin
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Unleash the power of MkDocs with macros and variables
url: https://github.com/fralau/mkdocs_macros_plugin
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f383a04-3e56-4819-af69-214f42ea3bb2
location_href: 00013674-python-mkdocs-macros-plugin/python-mkdocs-macros-plugin-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  ![Language](https://img.shields.io/github/languages/top/fralau/mkdocs_macros_plugin)
  ![PyPI](https://img.shields.io/pypi/v/mkdocs-macros-plugin)
  ![Github](https://img.shields.io/github/v/tag/fralau/mkdocs_macros_plugin?label=github%20tag)
  ![macros](https://img.shields.io/pypi/dm/mkdocs-macros-plugin)

  * **View the [mkdocs-macro documentation](https://mkdocs-macros-plugin.readthedocs.io/) on Read the Docs**
  * View the [general Mkdocs documentation](https://www.mkdocs.org/)

  <!-- To update, run the following command:
  markdown-toc -i README.md
  -->

  <!-- toc -->

  - [mkdocs-macros-plugin: Unleash the power of MkDocs with variables and macros](#mkdocs-macros-plugin-unleash-the-power-of-mkdocs-with-variables-and-macros)
    - [Overview](#Overview)
      - [Using variables](#Using-variables)
      - [Defining variables](#Defining-variables)
      - [Macros and filters](#Macros-and-filters)
    - [Installation](#Installation)
      - [Prerequisites](#Prerequisites)
      - [Standard installation](#Standard-installation)
      - ["Manual installation"](#"Manual-installation")
      - [Development/test installation](#Development/test-installation)
      - [Declaration of plugin](#Declaration-of-plugin)
      - [Check that it works](#Check-that-it-works)
    - [Using pluglets](#Using-pluglets)
      - [What are pluglets?](#What-are-pluglets?)
      - [How to add a pluglet to an mkdocs project?](#How-to-add-a-pluglet-to-an-mkdocs-project?)
      - [How to write a pluglet?](#How-to-write-a-pluglet?)

  <!-- tocstop -->


  **mkdocs-macros-plugin** is a plugin that makes it easier for contributors
  of an [MkDocs](https://www.mkdocs.org/) website to produce richer and more beautiful pages. It transforms the markdown pages
  into [jinja2](https://jinja.palletsprojects.com/en/2.10.x/) templates
  that use **variables**, calls to **macros** and custom **filters**.

  > **You can also partially replace MkDocs plugins with mkdocs-macros modules,
  > and [pluglets](https://mkdocs-macros-plugin.readthedocs.io/en/latest/pluglets/)
  > (pre-installed modules).**



  You can leverage the power of Python in markdown thanks to jinja2
  by writing this :

  ```markdown
  The unit price of product A is {{ unit_price }} EUR.
  Taking the standard discount into account,
  the sale price of 50 units is {{ price(unit_price, 50) }} EUR.
  ```

  If you defined a `price()` function, this could translate into:

  ```
  The unit price of product A is 10.00 EUR.
  Taking the standard discount into account,
  the sale price of 50 units is 450.00 EUR.
  ```

  > The result of a macro can be **HTML code**:
  this makes macros especially useful
  to make custom extensions to the syntax of markdown, such as buttons,
  calls to email, embedding YouTube videos, etc.

  It is possible to use the wide range of facilities provided by
  [Jinja2 templates](http://jinja.pocoo.org/docs/2.10/templates/) such
  as conditions (`{% if ... %}`) and loops (`{% for ... %}`).



  Regular **variables** can be defined in five ways:

  | No | Validity | For whom | Description |
  | --- | --- | --- | ---- |
  | 1. | global | designer of the website | in the `mkdocs.yml` file, under the `extra` heading |
  | 2. | global | contributor | in external yaml definition files |
  | 3. | global | programmer | in a `main.py` file (Python), by adding them to a dictionary |
  | 4. | local (page) | writer | in the YAML header of each Markdown page |
  | 5. | local (page) | writer | with a `{%set variable = value %}`  statement |

  In addition, predefined objects are provided (local and global), typically
  for the environment, project, page, git information, etc.



  Similarly programmers can define their own **macros** and **filters**,
  as Python functions in the `main.py` file,
  which the users will then be able to
  use without much difficulty, as jinja2 directives in the markdown page.







    - Python version > 3.5
    - MkDocs version >= 1.0 (it should work > 0.17
      (it should be compatible with post 1.0 versions)


  ```
  pip install mkdocs-macros-plugin
  ```


  To install the package, download it and run:

  ```
  pip install .

  python setup.py install
  ```


  To install the extra dependencies required for testing the package, run:

  ```
  pip install "mkdocs-macros-plugin[test]"
  ```


  Declare the plugin in the the file `mkdocs.yml`:

  ```yaml
  plugins:
      - search
      - macros
  ```

  > **Note:** If you have no `plugins` entry in your config file yet,
  you should also add the `search` plugin.
  If no `plugins` entry is set, MkDocs enables `search` by default; but
  if you use it, then you have to declare it explicitly.


  The recommended way to check that the plugin works properly is to add the
  following command in one of the pages of your site (let's say `info.md`):

  ```
  {{ macros_info() }}
  ```

  In the terminal, restart the environment:

  ```
  > mkdocs serve
  ````
  You will notice that additional information now appears in the terminal:

  ```
  INFO    -  Building documentation...
  [macros] Macros arguments: {'module_name': 'main', 'include_yaml': [], 'j2_block_start_string': '', 'j2_block_end_string': '', 'j2_variable_start_string': '', 'j2_variable_end_string': ''}
  ```

  Within the browser (e.g. http://127.0.0.1:8000/info), you should
  see a description of the plugins environment:

  ![macros_info()](macros_info.png)

  If you see it that information, you should be all set.

  Give a good look at the General List, since it gives you an overview
  of what you can do out of the box with the macros plugin.

  The other parts give you more detailed information.






  **Pluglets** are small, easy-to-write programs
  that use mkdocs-macro's foundation
  to offer services to mkdocs projects, which would normally
  be offered by plugins.

  Pluglets are Python packages, which can be hosted on github, and
  distributed through [PyPI](https://pypi.org/).




  Install it:

  ```python
  pip install <pluglet_name>
  ```

  Declare it in the project's config (`mkdocs.yml`) file:

  ```yaml
  plugins:
    - search
    - macros:
        modules:
          - <pluglet_name>
  ```



  [See instructions in the documentation](https://mkdocs-macros-plugin.readthedocs.io/en/latest/pluglets/).

  A sample pluglet can be found in [mkdocs-test (github)](https://github.com/fralau/mkdocs-macros-test).


pkgId: 289d21fd969dbe465c892231f27b456a0ea6c8ffde58a5b383a139df3cdf9a9b
name: python-mkdocs-monorepo-plugin
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Plugin for adding monorepository support in Mkdocs.
url: https://github.com/backstage/mkdocs-monorepo-plugin
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b709bc5a-5f88-4645-8846-87251be7215b
location_href: 00014225-python-mkdocs-monorepo-plugin/python-mkdocs-monorepo-plugin-1.0.4-1.src.rpm
checksum_type: sha256
description:
  This introduces support for the !include syntax in mkdocs.yml, allowing you to import additional Mkdocs navigation.
  It enables large or complex repositories to have their own sets of docs/ folders, whilst generating only a single Mkdocs site.
  This is built and maintained by the engineering community at Spotify.


pkgId: fdf0a2fa89e7bf7a1f228184d6a7eb15cb8bbe3c640a24693d67bfa55c0c3afd
name: python-mkdocs-redirects
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A MkDocs plugin for dynamic page redirects to prevent broken links.
url: https://github.com/datarobot/mkdocs-redirects
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6e9610f0-db3f-456e-8416-437572767049
location_href: 00014095-python-mkdocs-redirects/python-mkdocs-redirects-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Plugin for [`mkdocs`](https://www.mkdocs.org/) to create page redirects (e.g. for moved/renamed pages).

  Initially developed by [DataRobot](https://www.datarobot.com/).



  > **Note:** This package requires MkDocs version 1.0.4 or higher.

  Install with pip:

  ```bash
  pip install mkdocs-redirects
  ```



  To use this plugin, specify your desired redirects in the plugin's `redirect_maps` setting in your `mkdocs.yml`:

  ```yaml
  plugins:
      - redirects:
          redirect_maps:
              'old.md': 'new.md'
              'old/file.md': 'new/file.md'
              'some_file.md': 'http://external.url.com/foobar'
  ```

  _Note: don't forget that specifying the `plugins` setting will override the defaults if you didn't already have it set! See [this page](https://www.mkdocs.org/user-guide/configuration/#plugins) for more information._

  The redirects map should take the form of a key/value pair:

  - The key of each redirect is the original _markdown doc_ (relative to the `docs_dir` path).
    - This plugin will handle the filename resolution during the `mkdocs build` process.
      This should be set to what the original markdown doc's filename was (or what it _would be_ if it existed), not the final HTML file rendered by MkDocs
  - The value is the _redirect target_. This can take the following forms:
    - Path of the _markdown doc_ you wish to be redirected to (relative to `docs_dir`)
      - This plugin will handle the filename resolution during the `mkdocs build` process.
        This should be set to what the markdown doc's filename is, not the final HTML file rendered by MkDocs
    - External URL (e.g. `http://example.com`)

  During the `mkdocs build` process, this plugin will create `.html` files in `site_dir` for each of the "old" file that redirects to the "new" path.
  It will produce a warning if any problems are encountered or of the redirect target doesn't actually exist (useful if you have `strict: true` set).



  If you have `use_directory_urls: true` set (which is the default), this plugin will modify the redirect targets to the _directory_ URL, not the _actual_ `index.html` filename.
  However, it will create the `index.html` file for each target in the correct place so URL resolution works.

  For example, a redirect map of `'old/dir/README.md': 'new/dir/README.md'` will result in an HTML file created at `$site_dir/old/dir/index.html` which redirects to `../../new/dir/`.

  Additionally, a redirect map of `'old/dir/doc_name.md': 'new/dir/doc_name.md'` will result in `$site_dir/old/dir/doc_name/index.html` redirecting to `../../new/dir/doc_name/`.

  This mimics the behavior of how MkDocs builds the site dir without this plugin.





  Create a virtualenv using a method of your choice.

  ```bash
  brew install pyenv pyenv-virtualenv
  pyenv install 2.7.18
  pyenv virtualenv 2.7.18 mkdocs-redirects
  pyenv activate mkdocs-redirects
  ```



  ```bash
  make build
  ```



  ```bash
  make test
  ```



  ```bash
  make release
  ```

  It will prompt you for your PyPI user and password.

  See:

  - <https://packaging.python.org/tutorials/packaging-projects/>
  - <https://packaging.python.org/guides/migrating-to-pypi-org/>


pkgId: 0a3f926f84b2a99e773daafc16b42a1cf8518b106ada0e20d3b15fd37aa7a4a4
name: python-mlagents
arch: src
version: 0.30.0
epoch: 0
release: 1
summary: Unity Machine Learning Agents
url: https://github.com/Unity-Technologies/ml-agents
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-474b5945-781e-4ddc-9742-bb30cbee1572
location_href: 00012514-python-mlagents/python-mlagents-0.30.0-1.src.rpm
checksum_type: sha256
description:
  The `mlagents` Python package is part of the
  [ML-Agents Toolkit](https://github.com/Unity-Technologies/ml-agents). `mlagents`
  provides a set of reinforcement and imitation learning algorithms designed to be
  used with Unity environments. The algorithms interface with the Python API
  provided by the `mlagents_envs` package. See [here](../docs/Python-LLAPI.md) for
  more information on `mlagents_envs`.

  The algorithms can be accessed using the: `mlagents-learn` access point. See
  [here](../docs/Training-ML-Agents.md) for more information on using this
  package.



  Install the `mlagents` package with:

  ```sh
  python -m pip install mlagents==0.30.0
  ```



  For more information on the ML-Agents Toolkit and how to instrument a Unity
  scene with the ML-Agents SDK, check out the main
  [ML-Agents Toolkit documentation](../docs/Readme.md).



  - Resuming self-play from a checkpoint resets the reported ELO to the default
    value.


pkgId: 490edc3b2ff3ad05104c8862bdbb81f86b175fdc32921ed372ff74e77f428383
name: python-mlxtend
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: Machine Learning Library Extensions
url: https://github.com/rasbt/mlxtend
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-609dd186-b909-404e-8337-9954371a446e
location_href: 00009528-python-mlxtend/python-mlxtend-0.22.0-1.src.rpm
checksum_type: sha256
description:
  If you have any questions or comments about mlxtend,
  please feel free to contact me via
  eMail: mail@sebastianraschka.com
  or Twitter: https://twitter.com/rasbt
  This project is hosted at https://github.com/rasbt/mlxtend
  The documentation can be found at https://rasbt.github.io/mlxtend/


pkgId: e4387a815bd6c3fcde1b276fed94d2988dae25c6627e1e071a08a1ba819d043c
name: python-mmh3
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Python wrapper for MurmurHash (MurmurHash3), a set of fast and robust hash functions.
url: https://github.com/hajimes/mmh3
rpm_license: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ca4c66e-68e5-4479-ac35-ce8459cc533f
location_href: 00009505-python-mmh3/python-mmh3-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Super-Linter](https://github.com/hajimes/mmh3/workflows/Super-Linter/badge.svg?branch=master)](https://github.com/hajimes/mmh3/actions?query=workflow%3ASuper-Linter+branch%3Amaster)
  [![Build](https://github.com/hajimes/mmh3/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/hajimes/mmh3/actions/workflows/build.yml?branch=master)
  [![PyPi Version](https://img.shields.io/pypi/v/mmh3.svg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.org/project/mmh3/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/mmh3.svg)](https://pypi.org/project/mmh3/)
  [![License: CC0-1.0](https://img.shields.io/badge/License-CC0%201.0-lightgrey.svg)](http://creativecommons.org/publicdomain/zero/1.0/)
  [![Total Downloads](https://pepy.tech/badge/mmh3)](https://pepy.tech/project/mmh3)
  [![Recent Downloads](https://pepy.tech/badge/mmh3/month)](https://pepy.tech/project/mmh3)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/mmh3.svg?style=flat-square&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/mmh3)

  mmh3 is a Python wrapper for [MurmurHash (MurmurHash3)](https://en.wikipedia.org/wiki/MurmurHash), a set of fast and robust non-cryptographic hash functions invented by Austin Appleby.

  Combined with probabilistic techniques like a [Bloom filter](https://en.wikipedia.org/wiki/Bloom_filter), [MinHash](https://en.wikipedia.org/wiki/MinHash), and [feature hashing](https://en.wikipedia.org/wiki/Feature_hashing), mmh3 allows you to develop high-performance systems in fields such as data mining, machine learning, and natural language processing.

  Another common use of mmh3 is to [calculate favicon hashes](https://gist.github.com/yehgdotnet/b9dfc618108d2f05845c4d8e28c5fc6a) used by [Shodan](https://www.shodan.io), the world's first IoT search engine.


  Install:
  ```shell
  pip install mmh3 # for macOS, use "pip3 install mmh3" and python3
  ```

  Quickstart:
  ```shell
  >>> import mmh3
  >>> mmh3.hash("foo") # returns a 32-bit signed int
  -156908512
  >>> mmh3.hash("foo", 42) # uses 42 as a seed
  -1322301282
  >>> mmh3.hash("foo", signed=False) # returns a 32-bit unsigned int
  4138058784
  ```

  Other functions:
  ```shell
  >>> mmh3.hash64("foo") # two 64 bit signed ints (by using the 128-bit algorithm as its backend)
  (-2129773440516405919, 9128664383759220103)
  >>> mmh3.hash64("foo", signed=False) #  two 64 bit unsigned ints
  (16316970633193145697, 9128664383759220103)
  >>> mmh3.hash128("foo", 42) # 128 bit unsigned int
  215966891540331383248189432718888555506
  >>> mmh3.hash128("foo", 42, signed=True) # 128 bit signed int
  -124315475380607080215185174712879655950
  >>> mmh3.hash_bytes("foo") # 128 bit value as bytes
  'aE\xf5\x01W\x86q\xe2\x87}\xba+\xe4\x87\xaf~'
  >>> import numpy as np
  >>> a = np.zeros(2 ** 32, dtype=np.int8)
  >>> mmh3.hash_bytes(a)
  b'V\x8f}\xad\x8eNM\xa84\x07FU\x9c\xc4\xcc\x8e'
  ```

  Beware that `hash64` returns **two** values, because it uses the 128-bit version of MurmurHash3 as its backend.

  `hash_from_buffer` hashes byte-likes without memory copying. The method is suitable when you hash a large memory-view such as `numpy.ndarray`.

  ```shell
  >>> mmh3.hash_from_buffer(numpy.random.rand(100))
  -2137204694
  >>> mmh3.hash_from_buffer(numpy.random.rand(100), signed=False)
  3812874078
  ```

  `hash64`, `hash128`, and `hash_bytes` have the third argument for architecture optimization. Use True for x64 and False for x86 (default: True):

  ```shell
  >>> mmh3.hash64("foo", 42, True)
  (-840311307571801102, -6739155424061121879)
  ```



  * Add support for Python 3.10 and 3.11. Thanks [wouter bolsterlee](https://github.com/wbolster) and [Dušan Nikolić](https://github.com/n-dusan)!
  * Drop support for Python 3.6; remove legacy code for Python 2.x at the source code level.
  * Add support for 32-bit architectures such as `i686` and `armv7l`. From now on, `hash` and `hash_from_buffer` on these architectures will generate the same hash values as those on other environments. Thanks [Danil Shein](https://github.com/dshein-alt)!
  * In relation to the above, `manylinux2014_i686` wheels are now available.
  * Support for hashing huge data (>16GB). Thanks [arieleizenberg](https://github.com/arieleizenberg)!


  * Python wheels are now available, thanks to the power of [cibuildwheel](https://github.com/joerick/cibuildwheel).
    * Supported platforms are `manylinux1_x86_64`, `manylinux2010_x86_64`, `manylinux2014_aarch64`, `win32`, `win_amd64`, `macosx_10_9_x86_64`, and `macosx_11_0_arm64` (Apple Silicon).
  * Add support for newer macOS environments. Thanks [Matthew Honnibal](https://github.com/honnibal)!
  * Drop support for Python 2.7, 3.3, 3.4, and 3.5.
  * Add support for Python 3.7, 3.8, and 3.9.
  * Migrate Travis CI and AppVeyor to GitHub Actions.


  * Bugfix for `hash_bytes`. Thanks [doozr](https://github.com/doozr)!

  See [CHANGELOG.md](./CHANGELOG.md) for the complete changelog.


  [CC0-1.0](./LICENSE).



  By default, mmh3 returns **signed** values for 32-bit and 64-bit versions and **unsigned** values for `hash128`, due to historical reasons. Please use the keyword argument `signed` to obtain a desired result.

  For compatibility with Google Guava (Java), see <https://stackoverflow.com/questions/29932956/murmur3-hash-different-result-between-python-and-java-implementation>


  Version 2.4 changed the type of seeds from signed 32-bit int to unsigned 32-bit int. The resulting values with signed seeds still remain the same as before, as long as they are 32-bit.

  ```shell
  >>> mmh3.hash("aaaa", -1756908916) # signed representation for 0x9747b28c
  1519878282
  >>> mmh3.hash("aaaa", 2538058380) # unsigned representation for 0x9747b28c
  1519878282
  ```

  Be careful so that these seeds do not exceed 32-bit. Unexpected results may happen with invalid values.

  ```shell
  >>> mmh3.hash("foo", 2 ** 33)
  -156908512
  >>> mmh3.hash("foo", 2 ** 34)
  -156908512
  ```


  MurmurHash3 was originally developed by Austin Appleby and distributed under public domain.

  * <https://github.com/aappleby/smhasher>

  Ported and modified for Python by Hajime Senuma.

  * <http://pypi.python.org/pypi/mmh3>
  * <http://github.com/hajimes/mmh3>



  The following textbooks and tutorials are great sources to learn how to use mmh3 (and other hash algorithms in general) for high-performance computing.

  * Chapter 11: *Using Less Ram* in Micha Gorelick and Ian Ozsvald. 2014. *High Performance Python: Practical Performant Programming for Humans*. O'Reilly Media. [ISBN: 978-1-4493-6159-4](https://www.amazon.com/dp/1449361595).
    * 2nd edition of the above (2020). [ISBN: 978-1492055020](https://www.amazon.com/dp/1492055026).
  * Max Burstein. February 2, 2013. *[Creating a Simple Bloom Filter](http://www.maxburstein.com/blog/creating-a-simple-bloom-filter/)*.
  * Duke University. April 14, 2016. *[Efficient storage of data in memory](http://people.duke.edu/~ccc14/sta-663-2016/20B_Big_Data_Structures.html)*.
  * Bugra Akyildiz. August 24, 2016. *[A Gentle Introduction to Bloom Filter](https://www.kdnuggets.com/2016/08/gentle-introduction-bloom-filter.html)*. KDnuggets.


  [Shodan](https://www.shodan.io), the world's first [IoT](https://en.wikipedia.org/wiki/Internet_of_things) search engine, uses MurmurHash3 hash values for [favicons](https://en.wikipedia.org/wiki/Favicon) (icons associated with web pages). [ZoomEye](https://www.zoomeye.org) follows Shodan's convention.
  [Calculating these values with mmh3](https://gist.github.com/yehgdotnet/b9dfc618108d2f05845c4d8e28c5fc6a) is useful for OSINT and cybersecurity activities.

  * Jan Kopriva. April 19, 2021. *[Hunting phishing websites with favicon hashes](https://isc.sans.edu/diary/Hunting+phishing+websites+with+favicon+hashes/27326)*. SANS Internet Storm Center.
  * Nikhil Panwar. May 2, 2022. *[Using Favicons to Discover Phishing & Brand Impersonation Websites](https://bolster.ai/blog/how-to-use-favicons-to-find-phishing-websites)*. Bolster.
  * Faradaysec. July 25, 2022. *[Understanding Spring4Shell: How used is it?](https://faradaysec.com/understanding-spring4shell/)*. Faraday Security.
  * Debjeet. August 2, 2022. *[How To Find Assets Using Favicon Hashes](https://payatu.com/blog/favicon-hash/)*. Payatu.


  * <https://github.com/wc-duck/pymmh3>: mmh3 in pure python (Fredrik Kihlander and Swapnil Gusani)
  * <https://github.com/escherba/python-cityhash>: Python bindings for CityHash (Eugene Scherba)
  * <https://github.com/veelion/python-farmhash>: Python bindigs for FarmHash (Veelion Chong)
  * <https://github.com/escherba/python-metrohash>: Python bindings for MetroHash (Eugene Scherba)
  * <https://github.com/ifduyue/python-xxhash>: Python bindings for xxHash (Yue Du)


pkgId: b59830443defa4e8187731adc93ec111eb71f6da0db492a4f070e86e1ae22d2a
name: python-mmh3-debuginfo
arch: aarch64
version: 3.1.0
epoch: 0
release: 1
summary: Debug information for package python-mmh3
url: https://github.com/hajimes/mmh3
rpm_license: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-8ca4c66e-68e5-4479-ac35-ce8459cc533f
rpm_sourcerpm: python-mmh3-3.1.0-1.src.rpm
location_href: 00009505-python-mmh3/python-mmh3-debuginfo-3.1.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-mmh3.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 92b8783e1798bd95e832b80542450169a3f9750d39422be5ce45db5c2ddabf87
name: python-mmh3-debugsource
arch: aarch64
version: 3.1.0
epoch: 0
release: 1
summary: Debug sources for package python-mmh3
url: https://github.com/hajimes/mmh3
rpm_license: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-8ca4c66e-68e5-4479-ac35-ce8459cc533f
rpm_sourcerpm: python-mmh3-3.1.0-1.src.rpm
location_href: 00009505-python-mmh3/python-mmh3-debugsource-3.1.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-mmh3.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 957ba9b0809e5029ce7254e9ccbeb9ebbdbb025f848628abee439d990a868810
name: python-mne
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: MNE-Python project for MEG and EEG data analysis.
url: https://mne.tools/dev/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-839cf6b3-f454-4426-8201-a550c18bd9ce
location_href: 00004213-python-mne/python-mne-1.3.1-1.src.rpm
checksum_type: sha256
description:
  `MNE-Python software`_ is an open-source Python package for exploring,
  visualizing, and analyzing human neurophysiological data such as MEG, EEG, sEEG,
  ECoG, and more. It includes modules for data input/output, preprocessing,
  visualization, source estimation, time-frequency analysis, connectivity analysis,
  machine learning, and statistics.
  Documentation
  ^^^^^^^^^^^^^
  `MNE documentation`_ for MNE-Python is available online.
  Installing MNE-Python
  ^^^^^^^^^^^^^^^^^^^^^
  To install the latest stable version of MNE-Python, you can use pip_ in a terminal:
      $ pip install -U mne
  - MNE-Python 0.17 was the last release to support Python 2.7
  - MNE-Python 0.18 requires Python 3.5 or higher
  - MNE-Python 0.21 requires Python 3.6 or higher
  - MNE-Python 0.24 requires Python 3.7 or higher
  For more complete instructions and more advanced installation methods (e.g. for
  the latest development version), see the `installation guide`_.
  Get the latest code
  ^^^^^^^^^^^^^^^^^^^
  To install the latest version of the code using pip_ open a terminal and type:
      $ pip install -U https://github.com/mne-tools/mne-python/archive/main.zip
  To get the latest code using `git <https://git-scm.com/>`__, open a terminal and type:
      $ git clone https://github.com/mne-tools/mne-python.git
  Alternatively, you can also download a
  `zip file of the latest development version <https://github.com/mne-tools/mne-python/archive/main.zip>`__.
  Dependencies
  ^^^^^^^^^^^^
  The minimum required dependencies to run MNE-Python are:
  - Python >= 3.7
  - NumPy >= 1.18.1
  - SciPy >= 1.4.1
  - Matplotlib >= 3.1.0
  - pooch >= 1.5
  - tqdm
  - Jinja2
  - decorator
  For full functionality, some functions require:
  - Scikit-learn >= 0.22.0
  - joblib >= 0.15 (for parallelization control)
  - Numba >= 0.48.0
  - NiBabel >= 2.5.0
  - OpenMEEG >= 2.5.5
  - Pandas >= 1.0.0
  - Picard >= 0.3
  - CuPy >= 7.1.1 (for NVIDIA CUDA acceleration)
  - DIPY >= 1.1.0
  - Imageio >= 2.6.1
  - PyVista >= 0.32
  - pyvistaqt >= 0.4
  - mffpy >= 0.5.7
  - h5py
  - h5io
  - pymatreader
  Contributing to MNE-Python
  ^^^^^^^^^^^^^^^^^^^^^^^^^^
  Please see the documentation on the MNE-Python homepage:
  https://mne.tools/dev/install/contributing.html
  Forum
  ^^^^^^
  https://mne.discourse.group
  Licensing
  ^^^^^^^^^
  MNE-Python is **BSD-licenced** (BSD-3-Clause):
      This software is OSI Certified Open Source Software.
      OSI Certified is a certification mark of the Open Source Initiative.
      Copyright (c) 2011-2022, authors of MNE-Python.
      All rights reserved.
      Redistribution and use in source and binary forms, with or without
      modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright notice,
        this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright notice,
        this list of conditions and the following disclaimer in the documentation
        and/or other materials provided with the distribution.
      * Neither the names of MNE-Python authors nor the names of any
        contributors may be used to endorse or promote products derived from
        this software without specific prior written permission.
      **This software is provided by the copyright holders and contributors
      "as is" and any express or implied warranties, including, but not
      limited to, the implied warranties of merchantability and fitness for
      a particular purpose are disclaimed. In no event shall the copyright
      owner or contributors be liable for any direct, indirect, incidental,
      special, exemplary, or consequential damages (including, but not
      limited to, procurement of substitute goods or services; loss of use,
      data, or profits; or business interruption) however caused and on any
      theory of liability, whether in contract, strict liability, or tort
      (including negligence or otherwise) arising in any way out of the use
      of this software, even if advised of the possibility of such
      damage.**


pkgId: fd16cd7c9e546410e33819da98990aa06d691317b59d87432066df3d742f85fb
name: python-mne-bids
arch: src
version: 0.12
epoch: 0
release: 1
url: https://github.com/mne-tools/mne-bids
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-56c2d326-69d0-42ea-a99f-5311a9a3b44f
location_href: 00004214-python-mne-bids/python-mne-bids-0.12-1.src.rpm
checksum_type: sha256
summary:
  MNE-BIDS: Organizing MEG, EEG, and iEEG data according to the BIDS specification and facilitating their analysis with MNE-Python

description:
  MNE-BIDS is a Python package that allows you to read and write
  [BIDS](https://bids.neuroimaging.io/)-compatible datasets with the help of
  [MNE-Python](https://mne.tools/stable/index.html).
  ![Schematic: From raw data to BIDS using MNE-BIDS](https://mne.tools/mne-bids/assets/MNE-BIDS.png)


pkgId: 08457bf95080cd891e96488828acdefec335fd016428a0cbb578647fe43a9e0d
name: python-mock
arch: src
version: 5.0.1
epoch: 0
release: 1
summary: Rolling backport of unittest.mock for all Pythons
url: http://mock.readthedocs.org/en/latest/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-829b4134-9ea3-40e4-9899-fa22d302b849
location_href: 00009061-python-mock/python-mock-5.0.1-1.src.rpm
checksum_type: sha256
description:
  mock is a library for testing in Python. It allows you to replace parts of
  your system under test with mock objects and make assertions about how they
  have been used.

  mock is now part of the Python standard library, available as `unittest.mock
  <https://docs.python.org/dev/library/unittest.mock.html>`_ in Python 3.3
  onwards.

  This package contains a rolling backport of the standard library mock code
  compatible with Python 3.6 and up.

  Please see the standard library documentation for more details.

  :Homepage: `Mock Homepage`_
  :Download: `Mock on PyPI`_
  :Documentation: `Python Docs`_
  :License: `BSD License`_
  :Support: `Mailing list (testing-in-python@lists.idyll.org)
   <http://lists.idyll.org/listinfo/testing-in-python>`_
  :Code: `GitHub
   <https://github.com/testing-cabal/mock>`_
  :Issue tracker: `GitHub Issues
   <https://github.com/testing-cabal/mock/issues>`_
  :Build status:
      |CircleCI|_ |Docs|_

      .. |CircleCI| image:: https://circleci.com/gh/testing-cabal/mock/tree/master.svg?style=shield
      .. _CircleCI: https://circleci.com/gh/testing-cabal/mock/tree/master

      .. |Docs| image:: https://readthedocs.org/projects/mock/badge/?version=latest
      .. _Docs: http://mock.readthedocs.org/en/latest/

  .. _Mock Homepage: http://mock.readthedocs.org/en/latest/
  .. _BSD License: https://github.com/testing-cabal/mock/blob/master/LICENSE.txt
  .. _Python Docs: https://docs.python.org/dev/library/unittest.mock.html
  .. _mock on PyPI: https://pypi.org/project/mock/


pkgId: 721e85d0f53bf14bde42d1b1c619b1ee9afce59d68ebcbf3af646934144e26c2
name: python-mod-wsgi
arch: src
version: 4.9.4
epoch: 0
release: 1
summary: Installer for Apache/mod_wsgi.
url: https://www.modwsgi.org/
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90231f83-e2f2-4511-956a-babd800884a8
location_href: 00004216-python-mod_wsgi/python-mod-wsgi-4.9.4-1.src.rpm
checksum_type: sha256
description:
  The mod_wsgi package provides an Apache module that implements a WSGI
  compliant interface for hosting Python based web applications on top of the
  Apache web server.
  Installation of mod_wsgi from source code can be performed in one of two
  ways.
  The first way of installing mod_wsgi is the traditional way that has been
  used by many software packages. This is where it is installed as a module
  directly into your Apache installation using the commands ``configure``,
  ``make`` and ``make install``, a method sometimes referred to by the
  acronym CMMI. This method works with most UNIX type systems. It cannot
  be used on Windows.
  The second way of installing mod_wsgi is to install it as a Python package
  into your Python installation using the Python ``pip install`` command.
  This can be used on all platforms, including Windows.
  This second way of installing mod_wsgi will compile not only the Apache
  module for mod_wsgi, but will also install a Python module and admin
  script, which on UNIX type systems can be used to start up a standalone
  instance of Apache directly from the command line with an auto generated
  configuration.
  This later mechanism for installing mod_wsgi using Python ``pip`` is a much
  simpler way of getting starting with hosting your Python web application.
  In particular, this installation method makes it very easy to use
  Apache/mod_wsgi in a development environment without the need to perform
  any Apache configuration yourself.
  The Apache module for mod_wsgi created when using the ``pip install``
  method can still be used with the main Apache installation, via manual
  configuration if necessary. As detailed later in these instructions, the
  admin script installed when you use ``pip install`` can be used to generate
  the configuration to manually add to the Apache configuration to load
  mod_wsgi.
  Note that although MacOS X is a UNIX type system, the ``pip install``
  method is the only supported way for installing mod_wsgi.
  Since MacOS X Sierra, Apple has completely broken the ability to install
  third party Apache modules using the ``apxs`` tool normally used for this
  task. History suggests that Apple will never fix the problem as they have
  broken things in the past in other ways and workarounds were required as
  they never fixed those problems either. This time there is no easy
  workaround as they no longer supply certain tools which are required to
  perform the installation.
  The ``pip install`` method along with the manual configuration of Apache
  is also the method you need to use on Windows.


pkgId: d4d4f82a33135194140b9f1b65e18f3f4a9c2689210eba662a740ed02b468121
name: python-moderngl
arch: src
version: 5.8.2
epoch: 0
release: 1
summary: ModernGL: High performance rendering for Python 3
url: https://github.com/moderngl/moderngl
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ce48b504-71b3-4d65-b613-4e0e021f0063
location_href: 00013712-python-moderngl/python-moderngl-5.8.2-1.src.rpm
checksum_type: sha256
description:
  [![preview](https://github.com/moderngl/moderngl/raw/master/.github/preview.png)](#readme)





  [![pypi](https://badge.fury.io/py/moderngl.svg)](https://pypi.python.org/pypi/moderngl) [![anaconda](https://anaconda.org/conda-forge/moderngl/badges/version.svg)](https://anaconda.org/conda-forge/moderngl/) <img src="https://raw.githubusercontent.com/moderngl/moderngl/master/.github/python-versions.svg?sanitize=true"> [![rtd](https://readthedocs.org/projects/moderngl/badge/?version=latest)](https://moderngl.readthedocs.io)

  ModernGL is a python wrapper over OpenGL 3.3+ core that simplifies the creation of simple graphics applications like scientific simulations, games or user interfaces. Usually, acquiring in-depth knowledge of OpenGL requires a steep learning curve. In contrast, ModernGL is easy to learn and use, moreover it is capable of rendering with high performance and quality, with less code written. The majority of the moderngl
  code base is also written in C++ for high performance.

  ```sh
  pip install moderngl
  ```

  - [Documentation](https://moderngl.readthedocs.io/)
  - [Examples](https://github.com/moderngl/moderngl/tree/master/examples/#readme)
  - [ModernGL on Github](https://github.com/moderngl/moderngl/)
  - [ModernGL on PyPI](https://pypi.org/project/ModernGL/)
  - [ModernGL Discord Server](https://discord.gg/UEMtW8D)
  - [glcontext]
  - [moderngl-window] (Window creation, resource loading, ..)

  > **NOTE: From moderngl 5.6 context creation is delegated to the [glcontext] package.
    This makes us able to expand and improve context creation without releasing new
    versions of moderngl. It also makes it possible for users to customize their own
    context creation and the bar for contributing should be lower. New backends
    can be created using ctypes or C++.**



  - GPU accelerated high quality graphics
  - Rendering modern OpenGL scenes with less headache
  - Simpler and faster than PyOpenGL
  - Can render without a window
  - 100% Pythonic



  ```py
  >>> import moderngl
  >>> ctx = moderngl.create_standalone_context()
  >>> buf = ctx.buffer(b'Hello World!')  # allocated on the GPU
  >>> buf.read()
  b'Hello World!'
  ```

  For complete examples please visit the [Examples](https://github.com/moderngl/moderngl/tree/master/examples/#readme).



  ```py
  >>> img = Image.open('texture.jpg')
  >>> ctx.texture(img.size, 3, img.tobytes())
  <Texture: 1>
  ```

  ```py
  >>> ctx.buffer(np.array([0.0, 0.0, 1.0, 1.0], dtype='f4'))
  <Buffer: 1>
  ```



  With PyOpenGL, using the original OpenGL API, you have to write three lines to
  achieve a simple task like binding a VBO:

  ```py
  vbo1 = glGenBuffers(1)
  GL.glBindBuffer(GL_ARRAY_BUFFER, vbo1)
  GL.glBufferData(GL_ARRAY_BUFFER, b'Hello World!', GL_STATIC_DRAW)

  vbo2 = glGenBuffers(1)
  GL.glBindBuffer(GL_ARRAY_BUFFER, vbo2)
  GL.glBufferData(GL_ARRAY_BUFFER, b'\x00' * 1024, GL_DYNAMIC_DRAW)
  ```

  With ModernGL you need just one simple line per VBO to achieve the same
  results:

  ```py
  vbo1 = ctx.buffer(b'Hello World!')
  vbo2 = ctx.buffer(reserve=1024, dynamic=True)
  ```



  [![build](https://github.com/moderngl/moderngl/actions/workflows/build.yml/badge.svg)](https://github.com/moderngl/moderngl/actions/workflows/build.yml) [![test](https://github.com/moderngl/moderngl/actions/workflows/test.yml/badge.svg)](https://github.com/moderngl/moderngl/actions/workflows/test.yml)

  ```sh
  python setup.py build_ext --inplace
  ```





  In many cases **yes**, the core functions of ModernGL are written in C++,
  OpenGL functions are called in quick succession so these calls together
  count as a single python function call.



  Most of the calls only require **OpenGL 3.3** but Subroutines and Compute
  Shaders require **OpenGL 4.0** and **OpenGL 4.3**



  OpenGL 3.3 came out in February 2010. With **up to date drivers** you will
  be able to use the most of the ModernGL functions, even on integrated
  graphics cards. _(Compute Shaders will likely not work
  depending on how old your PC is.)_

  You can still try [using Mesa](https://moderngl.readthedocs.io/en/latest/installation.html#using-with-mesa-3d-on-windows)
  but performance would be limited.



  **Anywhere where OpenGL is supported.** ModernGL is capable of rendering
  using a [standalone_context] as well. Rendering to a window only requires
  a valid OpenGL context.

  [standalone_context]: https://github.com/moderngl/moderngl/tree/master/examples/old-examples/standalone



  **NO**, but we provide a utility library [moderngl-window] making window
  creation and resource loading very simple.



  All the necessary calls are (or can be) implemented in ModernGL. However
  you can interact with the ModernGL objects from PyOpenGL. If something is
  missing write an [issue](https://github.com/moderngl/moderngl/issues)
  or raise a [PR](https://github.com/moderngl/moderngl/pulls).



  - [x] Windows
  - [x] Linux
  - [x] Mac





  ```sh
  apt-get install python3-dev libgl1-mesa-dev libx11-dev
  python3 setup.py install
  ```



  ```sh
  pip install -r docs/requirements.txt
  python setup.py build_sphinx
  ```



  ```sh
  pip install -r tests/requirements.txt
  pytest tests
  ```

  > Some of the tests may be skipped when the supported OpenGL version is below the requirements of the given test.



  ```sh
  apt-get install xvfb
  alias xpy='xvfb-run -s "-screen 0 1x1x24" python3'
  xpy -m moderngl
  ```



  Code is tested with [pep8], [flake8], [prospector] and [pylint]

  [pep8]: https://www.python.org/dev/peps/pep-0008/
  [flake8]: http://flake8.pycqa.org/en/latest/
  [prospector]: https://prospector.readthedocs.io/en/master/
  [pylint]: https://www.pylint.org/
  [moderngl-window]: https://github.com/moderngl/moderngl-window
  [glcontext]: https://github.com/moderngl/glcontext



  - [Code of conduct](https://github.com/moderngl/moderngl/blob/master/.github/CODE_OF_CONDUCT.md)



  If you need to cite this repository in academic research:
  ```txt
  @Online{Dombi2020,
    author = {Szabolcs Dombi},
    title = {ModernGL, high performance python bindings for OpenGL 3.3+},
    date = {2020-05-01},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/moderngl/moderngl}},
    commit = {<insert hash if needed>}
  }
  ```

  If commit hash is required this can be found per release here:
  https://github.com/moderngl/moderngl/releases




  - [Szabolcs Dombi](https://github.com/cprogrammer1994)
  - [SimLeek](https://github.com/SimLeek)
  - [Aljenci](https://github.com/Aljenci)
  - [MinchinWeb](https://github.com/MinchinWeb)
  - [Silexstudio](https://github.com/Silexstudio)
  - [stuaxo](https://github.com/stuaxo)
  - [Tomi Aarnio](https://github.com/toaarnio)
  - [Joshua Reibert](https://github.com/joshua-r)
  - [Einar Forselv](https://github.com/einarf)
  - [Jonathan Hartley](https://github.com/tartley)
  - [yoyonel](https://github.com/yoyonel)
  - [Naveen M K](https://github.com/naveen521kk)

  and [many others](https://github.com/moderngl/moderngl/graphs/contributors)

  Thank You!

  Contributions are welcome. _(Please add yourself to the list)_


pkgId: 1826efea8fb082afc3aa5614e0f8ceaf396afc1a466ba27992143cf934cabcf7
name: python-moderngl-debuginfo
arch: aarch64
version: 5.8.2
epoch: 0
release: 1
summary: Debug information for package python-moderngl
url: https://github.com/moderngl/moderngl
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-ce48b504-71b3-4d65-b613-4e0e021f0063
rpm_sourcerpm: python-moderngl-5.8.2-1.src.rpm
location_href: 00013712-python-moderngl/python-moderngl-debuginfo-5.8.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-moderngl.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 96f45c521d77be28bac2a7ae39a1348058ab1961a4368ea2a891e716c43ead1d
name: python-moderngl-debugsource
arch: aarch64
version: 5.8.2
epoch: 0
release: 1
summary: Debug sources for package python-moderngl
url: https://github.com/moderngl/moderngl
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-ce48b504-71b3-4d65-b613-4e0e021f0063
rpm_sourcerpm: python-moderngl-5.8.2-1.src.rpm
location_href: 00013712-python-moderngl/python-moderngl-debugsource-5.8.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-moderngl.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 9e585153644641c162414f2a455969fee3a0333133a71163d89ae24bf0621c8c
name: python-modernize
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: A hack on top of fissix (lib2to3 fork) for modernizing code for hybrid codebases.
url: https://github.com/PyCQA/modernize
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e183722c-3c3b-4d0c-b04b-7792fc6612df
location_href: 00004217-python-modernize/python-modernize-0.8.0-1.src.rpm
checksum_type: sha256
description:
  ::

      Python           _              _
         _ __  ___  __| |___ _ _ _ _ (_)______
        | '  \/ _ \/ _` / -_) '_| ' \| |_ / -_)
        |_|_|_\___/\__,_\___|_| |_||_|_/__\___|

  This library is a very thin wrapper around `fissix
  <https://github.com/jreese/fissix>`_, a fork of lib2to3, to utilize it
  to make Python 2 code more modern with the intention of eventually
  porting it over to Python 3.

  The ``python -m modernize`` command works like
  ``python -m fissix``, see `fissix <https://github.com/jreese/fissix>`_.
  Here's how you'd rewrite a
  single file::

      python -m modernize -w example.py

  It does not guarantee, but it attempts to spit out a codebase compatible
  with Python 2.6+ or Python 3. The code that it generates has a runtime
  dependency on `six <https://pypi.python.org/pypi/six>`_, unless the
  ``--no-six`` option is used. Version 1.9.0 or later of ``six`` is
  recommended. Some of the fixers output code that is not compatible with
  Python 2.5 or lower.

  **Documentation:** `modernize.readthedocs.io
  <https://modernize.readthedocs.io/>`_.

  See the ``LICENSE`` file for the license of ``modernize``.
  Using this tool does not affect licensing of the modernized code.

  .. image:: https://readthedocs.org/projects/modernize/badge/
      :target: https://readthedocs.org/projects/modernize/?badge=latest
      :alt: Documentation Status

  .. image:: https://api.travis-ci.org/pycqa/modernize.svg?branch=master
      :target: https://travis-ci.org/pycqa/modernize

  .. image:: https://coveralls.io/repos/pycqa/modernize/badge.png?branch=master
      :target: https://coveralls.io/r/pycqa/modernize?branch=master


pkgId: 7d0c2364af09008a308aead0f9bfb44748c98b6c9dbed1abdd44e79f29f15942
name: python-mohawk
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Library for Hawk HTTP authorization
url: https://github.com/kumar303/mohawk
rpm_license: MPL 2.0 (Mozilla Public License)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-38b9d710-8d4a-44df-8dd4-217f5f6e91d0
location_href: 00013655-python-mohawk/python-mohawk-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Hawk lets two parties securely communicate with each other using
  messages signed by a shared key.
  It is based on HTTP MAC access authentication (which
  was based on parts of OAuth 1.0).

  The Mohawk API is a little different from that of the Node library
  (i.e. https://github.com/hueniverse/hawk).
  It was redesigned to be more intuitive to developers, less prone to security problems, and more Pythonic.

  Read more: https://github.com/kumar303/mohawk/


pkgId: 8eaaafb8f92ffa5cdea9139ec9486f6df32f9d3f291277149da7be3534e3920e
name: python-molecule
arch: src
version: 4.0.4
epoch: 0
release: 1
summary: Molecule aids in the development and testing of Ansible roles
url: https://github.com/ansible-community/molecule
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7835fe3f-e8a6-47e6-a475-b3baea50dfbb
location_href: 00004221-python-molecule/python-molecule-4.0.4-1.src.rpm
checksum_type: sha256
description:
  Molecule project is designed to aid in the development and testing of
  `Ansible`_ roles.
  Molecule provides support for testing with multiple instances, operating
  systems and distributions, virtualization providers, test frameworks and
  testing scenarios.
  Molecule encourages an approach that results in consistently developed roles
  that are well-written, easily understood and maintained.
  Molecule supports only the latest two major versions of Ansible (N/N-1),
  meaning that if the latest version is 2.9.x, we will also test our code with
  2.8.x.
  Once installed, the command line can be called using any of the methods below:
      molecule ...
      python3 -m molecule ...  # python module calling method


pkgId: 0c8de440f341f521d4a6a1e7972ad945f533fe5c9497cb168e0cf87eb03ef906
name: python-molecule-docker
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Molecule aids in the development and testing of Ansible roles
url: https://github.com/ansible-community/molecule-docker
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bf36745f-410c-44f4-8cbc-54f873220730
location_href: 00004222-python-molecule-docker/python-molecule-docker-2.1.0-1.src.rpm
checksum_type: sha256
description:
  * Join us in the ``#ansible-devtools`` channel on `Libera`_.
  * Join the discussion in `molecule-users Forum`_.
  * Join the community working group by checking the `wiki`_.
  * Want to know about releases, subscribe to `ansible-announce list`_.
  * For the full list of Ansible email Lists, IRC channels see the
    `communication page`_.


pkgId: a921c432d28364dfddc33e8459dba70e30f617ce9c3a56cc6765352c7f9b76cb
name: python-molecule-podman
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Molecule aids in the development and testing of Ansible roles
url: https://github.com/ansible-community/molecule-podman
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ca4dd1a1-5750-4bea-976f-54959d1e1285
location_href: 00004223-python-molecule-podman/python-molecule-podman-2.0.3-1.src.rpm
checksum_type: sha256
description:
  To change the podman executable from the standard podman, export environment
  variable ``MOLECULE_PODMAN_EXECUTABLE``. For instance, if you wish to run
  molecule with ``podman-remote`` instead of ordinary ``podman``, the variable
  can be exported as:
     $ export MOLECULE_PODMAN_EXECUTABLE=podman-remote


pkgId: 2c42f269981c15a989856ae73621b377a269bcc39abd4392616f4e8ac0755a36
name: python-molten
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A minimal, extensible, fast and productive API framework.
url: https://pypi.org/project/molten/
rpm_license: GNU Lesser General Public License v3 or later (LGPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d227087-c86e-4e2d-87af-b6ed51566535
location_href: 00004224-python-molten/python-molten-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/Bogdanp/molten/workflows/CI/badge.svg)](https://github.com/Bogdanp/molten/actions?query=workflow%3ACI)
  [![PyPI version](https://badge.fury.io/py/molten.svg)](https://badge.fury.io/py/molten)
  [![Documentation](https://img.shields.io/badge/doc-latest-brightgreen.svg)](https://moltenframework.com)
  [![Reddit](https://img.shields.io/badge/discuss-online-orange.svg)](https://www.reddit.com/r/moltenframework/)

  *A minimal, extensible, fast and productive API framework for Python 3.*

  <hr/>

  **Changelog**: https://moltenframework.com/changelog.html <br/>
  **Community**: https://www.reddit.com/r/moltenframework/ <br/>
  **Documentation**: https://moltenframework.com

  <hr/>




      pip install molten




  Check out the [examples] folder to get a taste of the framework or
  read the [user guide]!




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

  [COPYING.LESSER]: https://github.com/Bogdanp/molten/blob/master/COPYING.LESSER
  [COPYING]: https://github.com/Bogdanp/molten/blob/master/COPYING
  [examples]: https://github.com/Bogdanp/molten/blob/master/examples
  [user guide]: https://moltenframework.com/guide.html


pkgId: 9766ad44f69207aec0948739cda2d025c61351df2ba0158f5b28cda62940a7f0
name: python-monotonic
arch: src
version: 1.6
epoch: 0
release: 1
summary: An implementation of time.monotonic() for Python 2 & < 3.3
url: https://github.com/atdt/monotonic
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4dbf7c70-d65a-46b0-8c19-398a35c6d1e7
location_href: 00004227-python-monotonic/python-monotonic-1.6-1.src.rpm
checksum_type: sha256
description:
  monotonic
  ~~~~~~~~~

  This module provides a ``monotonic()`` function which returns the
  value (in fractional seconds) of a clock which never goes backwards.

  On Python 3.3 or newer, ``monotonic`` will be an alias of
  ``time.monotonic`` from the standard library. On older versions,
  it will fall back to an equivalent implementation:

  +------------------+----------------------------------------+
  | Linux, BSD, AIX  | ``clock_gettime(3)``                   |
  +------------------+----------------------------------------+
  | Windows          | ``GetTickCount`` or ``GetTickCount64`` |
  +------------------+----------------------------------------+
  | OS X             | ``mach_absolute_time``                 |
  +------------------+----------------------------------------+

  If no suitable implementation exists for the current platform,
  attempting to import this module (or to import from it) will
  cause a ``RuntimeError`` exception to be raised.


pkgId: edd8d10789f16c28b3df23f99596908bc3fef78295bf4a2ea4e33d6ce1c904d3
name: python-more-executors
arch: src
version: 2.11.4
epoch: 0
release: 1
summary: A library of composable Python executors and futures
url: https://github.com/rohanpm/more-executors
rpm_license: GNU General Public License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-24440e3c-f3a3-44cd-adf6-a62eab818c0e
location_href: 00004229-python-more-executors/python-more-executors-2.11.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://circleci.com/gh/rohanpm/more-executors/tree/master.svg?style=svg)](https://circleci.com/gh/rohanpm/more-executors/tree/master)
  [![Maintainability](https://api.codeclimate.com/v1/badges/ce1b17e4d606337aa8e0/maintainability)](https://codeclimate.com/github/rohanpm/more-executors/maintainability)
  [![Test Coverage](https://api.codeclimate.com/v1/badges/ce1b17e4d606337aa8e0/test_coverage)](https://codeclimate.com/github/rohanpm/more-executors/test_coverage)

  - [API documentation](https://rohanpm.github.io/more-executors/)
  - [Source](https://github.com/rohanpm/more-executors)
  - [PyPI](https://pypi.python.org/pypi/more-executors)

  This library is intended for use with the
  [`concurrent.futures`](https://docs.python.org/3/library/concurrent.futures.html)
  module.  It includes a collection of `Executor` implementations in order to
  extend the behavior of `Future` objects.



  - Futures with implicit retry
  - Futures with implicit cancel on executor shutdown
  - Futures with implicit cancel after timeout
  - Futures with transformed output values (sync & async)
  - Futures resolved by a caller-provided polling function
  - Throttle the number of futures running at once
  - Synchronous executor
  - Bridge `concurrent.futures` with `asyncio`
  - Convenience API for creating executors
  - Instrumented with [Prometheus](https://prometheus.io/)

  See the [API documentation](https://rohanpm.github.io/more-executors/) for detailed information on usage.



  This example combines the map and retry executors to create futures for
  HTTP requests running concurrently, decoding JSON responses within the
  future and retrying on error.

  ```python
  import requests
  from concurrent.futures import as_completed
  from more_executors import Executors


  def get_json(response):
      response.raise_for_status()
      return (response.url, response.json())


  def fetch_urls(urls):
      
      
      
      
      executor = Executors.\
          thread_pool(max_workers=4).\
          with_map(get_json).\
          with_retry()

      
      futures = [executor.submit(requests.get, url)
                 for url in urls]

      
      
      for future in as_completed(futures):
          (url, data) = future.result()
          do_something(url, data)
  ```



  `virtualenv` and `pip` may be used to locally install this project from
  source:

  ```
  virtualenv ~/dev/python
  . ~/dev/python/bin/activate

  git clone https://github.com/rohanpm/more-executors
  cd more-executors

  pip install --editable .
  ```

  Autotests may be run with pytest:

  ```
  pip install -r test-requirements.txt
  py.test
  ```

  Submit pull requests against https://github.com/rohanpm/more-executors.



  This program 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: 7552e75cde96665befa9bb1d1723460d95c695c7516c4e993d63a0a46cf7d38a
name: python-moreorless
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Python diff wrapper
url: https://github.com/thatch/moreorless/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f0575d73-07a9-4e01-98fc-84e26ecdc1fa
location_href: 00004230-python-moreorless/python-moreorless-0.4.0-1.src.rpm
checksum_type: sha256
description:
  This is a thin wrapper around `difflib.unified_diff` that Does The Right Thing
  for "No newline at eof".  The args are also simplified compared to `difflib`:

  ```py
  moreorless.unified_diff(
      astr: str,
      bstr: str,
      filename: str,
      n: int = 3,
  ) -> str:
      ...


  moreorless.patch.apply_single_file(
      contents: str,
      patch: str,
      allow_offsets: bool = True,
  ) -> str:
      ...


  moreorless.click.echo_color_unified_diff(
      astr: str,
      bstr: str,
      filename: str,
      n: int = 3
  ) -> None:
      ...


  moreorless.click.echo_color_precomputed_diff(
      diff: str,
  ) -> None:
      ...
  ```



  morelorless is copyright [Tim Hatch](http://timhatch.com/), and licensed under
  the MIT license.  I am providing code in this repository to you under an open
  source license.  This is my personal repository; the license you receive to
  my code is from me and not from my employer. See the `LICENSE` file for details.


pkgId: 7e11b605f7142b2bd5f6435b78eacd334308abd94aa8fbe0e4e4cab7459437ff
name: python-moviepy
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Video editing with Python
url: https://zulko.github.io/moviepy/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-57026e77-fb93-4b4a-857c-0a240b2d548b
location_href: 00009499-python-moviepy/python-moviepy-1.0.3-1.src.rpm
checksum_type: sha256
description:
  MoviePy (full documentation_) is a Python library for video editing: cutting, concatenations, title insertions, video compositing (a.k.a. non-linear editing), video processing, and creation of custom effects. See the gallery_ for some examples of use.
  MoviePy can read and write all the most common audio and video formats, including GIF, and runs on Windows/Mac/Linux, with Python 2.7+ and 3 (or only Python 3.4+ from v.1.0). Here it is in action in an IPython notebook:


pkgId: f46e689173ed1a90d4314ee28bb537d035ccdf84271b8262d35334839ee2c3f5
name: python-mozilla-django-oidc
arch: src
version: 3.0.0
epoch: 0
release: 1
url: https://github.com/mozilla/mozilla-django-oidc
rpm_license: MPL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ab46c4a9-7bd9-4017-8f30-6636d0d84e14
location_href: 00004233-python-mozilla-django-oidc/python-mozilla-django-oidc-3.0.0-1.src.rpm
checksum_type: sha256
summary:
  A lightweight authentication and access management library for integration with OpenID Connect enabled authentication services.


pkgId: 44351ed505eb86c5d456f318c0d6b66d27ae895c81106b352b6a0a2e07d2825f
name: python-mplcursors
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Interactive data selection cursors for Matplotlib.
url: https://github.com/anntzer/mplcursors
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c4068bc3-489d-4b38-9cbd-087d7cd4f9ba
location_href: 00004240-python-mplcursors/python-mplcursors-0.5.2-1.src.rpm
checksum_type: sha256
description:
  | |GitHub| |PyPI| |conda-forge| |Debian| |Fedora| |openSUSE|
  | |Read the Docs| |Build|
     image:: https://img.shields.io/badge/github-anntzer%2Fmplcursors-brightgreen
     image:: https://img.shields.io/pypi/v/mplcursors.svg?color=brightgreen
     image:: https://img.shields.io/conda/v/conda-forge/mplcursors.svg?label=conda-forge&color=brightgreen
     image:: https://repology.org/badge/version-for-repo/debian_unstable/mplcursors.svg?header=Debian
     image:: https://repology.org/badge/version-for-repo/fedora_rawhide/python:mplcursors.svg?header=Fedora
     image:: https://repology.org/badge/version-for-repo/opensuse_tumbleweed/python:mplcursors.svg?header=openSUSE
     image:: https://img.shields.io/readthedocs/mplcursors
     image:: https://img.shields.io/github/workflow/status/anntzer/mplcursors/build
  mplcursors provides interactive data selection cursors for Matplotlib_.  It is
  inspired from mpldatacursor_, with a much simplified API.
  mplcursors requires Matplotlib_\≥3.1.
  Read the documentation on `readthedocs.org`_.
  As usual, install using pip:
     $ pip install mplcursors  # from PyPI
     $ pip install git+https://github.com/anntzer/mplcursors  # from Github
  or your favorite package manager.
  Run tests with pytest_\≥3.7.1.


pkgId: 79fddf86a3657ecf71689ae31db3947c10502460bdb28d1ed0386903bf26709f
name: python-mpld3
arch: src
version: 0.5.9
epoch: 0
release: 1
summary: D3 Viewer for Matplotlib
url: http://mpld3.github.com
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5019f6de-6997-4613-a1a1-d73b071e119e
location_href: 00010744-python-mpld3/python-mpld3-0.5.9-1.src.rpm
checksum_type: sha256
description:
  - Maintainers: [@vladh](https://github.com/vladh), [@cliffckerr](https://github.com/cliffckerr)
  - Status: I ([@vladh](https://github.com/vladh)) am not currently able to dedicate much time to resolving mpld3 issues.
    However, I _will_ gladly look at your pull request and review it. Please try your hand at fixing any issues you
    may have and sending a PR rather than just filing an issue — most problems don't take as long as you might expect to
    figure out!
  - Original author: Jake Vanderplas <jakevdp@cs.washington.edu>
  - License: BSD 3-clause
  This is an interactive D3js-based viewer which brings matplotlib graphics to the browser.
  Please visit [http://mpld3.github.io](http://mpld3.github.io) for documentation and examples.
  You may also see the [blog post](http://jakevdp.github.io/blog/2013/12/19/a-d3-viewer-for-matplotlib/), or the
  [IPython notebook examples](http://nbviewer.ipython.org/github/jakevdp/mpld3/tree/master/notebooks/)
  available in the ``notebooks`` directory of this repository.
  [![version status](https://img.shields.io/pypi/v/mpld3.svg)](https://pypi.python.org/pypi/mpld3)
  [![downloads](https://img.shields.io/pypi/dm/mpld3.svg)](https://pypi.python.org/pypi/mpld3)
  [![build status](https://travis-ci.org/jakevdp/mpld3.svg?branch=master)](https://travis-ci.org/jakevdp/mpld3)


pkgId: e49a8e2b0c50d8f34c099f9557fa116f5c96036eb8acb5289171cbfcf5ecd827
name: python-mpmath
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Python library for arbitrary-precision floating-point arithmetic
url: http://mpmath.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-58b7d697-06b4-4919-bf1a-30efc2722009
location_href: 00004241-python-mpmath/python-mpmath-1.3.0-1.src.rpm
checksum_type: sha256
description:
  |pypi version| |Build status| |Code coverage status| |Zenodo Badge|
  A Python library for arbitrary-precision floating-point arithmetic.
  Website: http://mpmath.org/
  Main author: Fredrik Johansson <fredrik.johansson@gmail.com>
  Mpmath is free software released under the New BSD License (see the
  LICENSE file for details)


pkgId: 4db64fdb811cee4b53000b1cf50f708d856c35e655cecc3f4fd9951eafbc3a7e
name: python-mpu
arch: src
version: 0.23.1
epoch: 0
release: 1
summary: Martins Python Utilities
url: https://github.com/MartinThoma/mpu
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c91ee19-a1e6-4690-80bd-926adc70629d
location_href: 00014226-python-mpu/python-mpu-0.23.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/mpu.svg)](https://badge.fury.io/py/mpu)
  [![Python Support](https://img.shields.io/pypi/pyversions/mpu.svg)](https://pypi.org/project/mpu/)
  [![Documentation Status](https://readthedocs.org/projects/mpu/badge/?version=latest)](http://mpu.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://travis-ci.org/MartinThoma/mpu.svg?branch=master)](https://travis-ci.org/MartinThoma/mpu)
  [![Coverage Status](https://coveralls.io/repos/github/MartinThoma/mpu/badge.svg?branch=master)](https://coveralls.io/github/MartinThoma/mpu?branch=master)


  Martins Python Utilities (mpu) is a collection of utility functions and classes
  with no other dependencies.

  The total size of the package will never be bigger than 10 MB and currently it
  is 15.7 kB in zipped form. This makes it a candidate to include into AWS Lambda
  projects.




  ```bash
  $ pip install git+https://github.com/MartinThoma/mpu.git
  ```

  It can, of course, also be installed via PyPI.






  ```python-repl
  >>> from mpu.datastructures import EList

  >>> l = EList([2, 1, 0])
  >>> l[2]
  0

  >>> l[[2, 0]]
  [0, 2]

  >>> l[l]
  [0, 1, 2]
  ```



  To enhance your terminals output, you might want to do something like:

  ```python
  from mpu.shell import Codes

  print("{c.GREEN}{c.UNDERLINED}Works{c.RESET_ALL}".format(c=Codes))
  ```




  Creating small example datastructures is a task I encounter once in a while
  for StackExchange answers.

  ```python
  from mpu.pd import example_df

  df = example_df()
  print(df)
  ```

  gives

  ```
       country   population population_time    EUR
  0    Germany   82521653.0      2016-12-01   True
  1     France   66991000.0      2017-01-01   True
  2  Indonesia  255461700.0      2017-01-01  False
  3    Ireland    4761865.0             NaT   True
  4      Spain   46549045.0      2017-06-01   True
  5    Vatican          NaN             NaT   True
  ```




  ```python
  import mpu
  from fractions import Fraction

  gross_income = mpu.units.Money("2345.10", "EUR")
  net_income = gross_income * Fraction("0.80")
  apartment = mpu.units.Money("501.23", "EUR")
  savings = net_income - apartment
  print(savings)
  ```

  prints `1375.31 Euro`




  * Download files with `mpu.io.download(source, sink)`
  * Read CSV, JSON and pickle with `mpu.io.read(filepath)`
  * Write CSV, JSON and pickle with `mpu.io.write(filepath, data)`


pkgId: f2b1fbe3ae5bc794639c59a2a611feb0098d9bceeeaa89b416e54ba81521b238
name: python-msal
arch: src
version: 1.21.0
epoch: 0
release: 1
url: https://github.com/AzureAD/microsoft-authentication-library-for-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ca98cdc-a70e-4cf9-9eab-ec2b2a263bc7
location_href: 00004245-python-msal/python-msal-1.21.0-1.src.rpm
checksum_type: sha256
summary:
  The Microsoft Authentication Library (MSAL) for Python library enables your app to access the Microsoft Cloud by supporting authentication of users with Microsoft Azure Active Directory accounts (AAD) and Microsoft Accounts (MSA) using industry standard OAuth2 and OpenID Connect.

description:
  | `dev` branch | Reference Docs | # of Downloads per different platforms | # of Downloads per recent MSAL versions |
  |---------------|---------------|----------------------------------------|-----------------------------------------|
   [![Build status](https://github.com/AzureAD/microsoft-authentication-library-for-python/actions/workflows/python-package.yml/badge.svg?branch=dev)](https://github.com/AzureAD/microsoft-authentication-library-for-python/actions) | [![Documentation Status](https://readthedocs.org/projects/msal-python/badge/?version=latest)](https://msal-python.readthedocs.io/en/latest/?badge=latest) | [![Downloads](https://pepy.tech/badge/msal)](https://pypistats.org/packages/msal) | [![Download monthly](https://pepy.tech/badge/msal/month)](https://pepy.tech/project/msal)

  The Microsoft Authentication Library for Python enables applications to integrate with the [Microsoft identity platform](https://aka.ms/aaddevv2). It allows you to sign in users or apps with Microsoft identities ([Azure AD](https://azure.microsoft.com/services/active-directory/), [Microsoft Accounts](https://account.microsoft.com) and [Azure AD B2C](https://azure.microsoft.com/services/active-directory-b2c/) accounts) and obtain tokens to call Microsoft APIs such as [Microsoft Graph](https://graph.microsoft.io/) or your own APIs registered with the Microsoft identity platform. It is built using industry standard OAuth2 and OpenID Connect protocols

  Not sure whether this is the SDK you are looking for your app? There are other Microsoft Identity SDKs
  [here](https://github.com/AzureAD/microsoft-authentication-library-for-python/wiki/Microsoft-Authentication-Client-Libraries).

  Quick links:

  | [Getting Started](https://docs.microsoft.com/azure/active-directory/develop/quickstart-v2-python-webapp) | [Docs](https://github.com/AzureAD/microsoft-authentication-library-for-python/wiki) | [Samples](https://aka.ms/aaddevsamplesv2) | [Support](README.md#community-help-and-support) | [Feedback](https://forms.office.com/r/TMjZkDbzjY) |
  | --- | --- | --- | --- | --- |



  Click on the following thumbnail to visit a large map with clickable links to proper samples.

  [![Map effect won't work inside github's markdown file, so we have to use a thumbnail here to lure audience to a real static website](https://raw.githubusercontent.com/AzureAD/microsoft-authentication-library-for-python/dev/docs/thumbnail.png)](https://msal-python.readthedocs.io/en/latest/)



  You can find MSAL Python on [Pypi](https://pypi.org/project/msal/).
  1. If you haven't already, [install and/or upgrade the pip](https://pip.pypa.io/en/stable/installing/)
     of your Python environment to a recent version. We tested with pip 18.1.
  2. As usual, just run `pip install msal`.



  This library follows [Semantic Versioning](http://semver.org/).

  You can find the changes for each version under
  [Releases](https://github.com/AzureAD/microsoft-authentication-library-for-python/releases).



  Before using MSAL Python (or any MSAL SDKs, for that matter), you will have to
  [register your application with the Microsoft identity platform](https://docs.microsoft.com/azure/active-directory/develop/quickstart-v2-register-an-app).

  Acquiring tokens with MSAL Python follows this 3-step pattern.
  (Note: That is the high level conceptual pattern.
  There will be some variations for different flows. They are demonstrated in
  [runnable samples hosted right in this repo](https://github.com/AzureAD/microsoft-authentication-library-for-python/tree/dev/sample).
  )


  1. MSAL proposes a clean separation between
     [public client applications, and confidential client applications](https://tools.ietf.org/html/rfc6749#section-2.1).
     So you will first create either a `PublicClientApplication` or a `ConfidentialClientApplication` instance,
     and ideally reuse it during the lifecycle of your app. The following example shows a `PublicClientApplication`:

     ```python
     from msal import PublicClientApplication
     app = PublicClientApplication(
         "your_client_id",
         authority="https://login.microsoftonline.com/Enter_the_Tenant_Name_Here")
     ```

     Later, each time you would want an access token, you start by:
     ```python
     result = None  # It is just an initial value. Please follow instructions below.
     ```

  2. The API model in MSAL provides you explicit control on how to utilize token cache.
     This cache part is technically optional, but we highly recommend you to harness the power of MSAL cache.
     It will automatically handle the token refresh for you.

     ```python
     
     
     accounts = app.get_accounts()
     if accounts:
         
         print("Pick the account you want to use to proceed:")
         for a in accounts:
             print(a["username"])
         
         chosen = accounts[0]
         
         result = app.acquire_token_silent(["your_scope"], account=chosen)
     ```

  3. Either there is no suitable token in the cache, or you chose to skip the previous step,
     now it is time to actually send a request to AAD to obtain a token.
     There are different methods based on your client type and scenario. Here we demonstrate a placeholder flow.

     ```python
     if not result:
         
         result = app.acquire_token_by_one_of_the_actual_method(..., scopes=["User.Read"])
     if "access_token" in result:
         print(result["access_token"])  # Yay!
     else:
         print(result.get("error"))
         print(result.get("error_description"))
         print(result.get("correlation_id"))  # You may need this when reporting a bug
     ```

  Refer the [Wiki](https://github.com/AzureAD/microsoft-authentication-library-for-python/wiki) pages for more details on the MSAL Python functionality and usage.



  If your application is using ADAL Python, we recommend you to update to use MSAL Python. No new feature work will be done in ADAL Python.

  See the [ADAL to MSAL migration](https://github.com/AzureAD/microsoft-authentication-library-for-python/wiki/Migrate-to-MSAL-Python) guide.



  You can follow the latest updates and plans for MSAL Python in the [Roadmap](https://github.com/AzureAD/microsoft-authentication-library-for-python/wiki/Roadmap) published on our Wiki.



  MSAL Python supports multiple [application types and authentication scenarios](https://docs.microsoft.com/azure/active-directory/develop/authentication-flows-app-scenarios).
  The generic documents on
  [Auth Scenarios](https://docs.microsoft.com/azure/active-directory/develop/authentication-scenarios)
  and
  [Auth protocols](https://docs.microsoft.com/azure/active-directory/develop/active-directory-v2-protocols)
  are recommended reading.

  We provide a [full suite of sample applications](https://aka.ms/aaddevsamplesv2) and [documentation](https://aka.ms/aaddevv2) to help you get started with learning the Microsoft identity platform.



  We leverage Stack Overflow to work with the community on supporting Azure Active Directory and its SDKs, including this one!
  We highly recommend you ask your questions on Stack Overflow (we're all on there!)
  Also browser existing issues to see if someone has had your question before.

  We recommend you use the "msal" tag so we can see it!
  Here is the latest Q&A on Stack Overflow for MSAL:
  [http://stackoverflow.com/questions/tagged/msal](http://stackoverflow.com/questions/tagged/msal)


  We'd like your thoughts on this library. Please complete [this short survey.](https://forms.office.com/r/TMjZkDbzjY)



  If you find a security issue with our libraries or services please report it to [secure@microsoft.com](mailto:secure@microsoft.com) with as much detail as possible. Your submission may be eligible for a bounty through the [Microsoft Bounty](http://aka.ms/bugbounty) program. Please do not post security issues to GitHub Issues or any other public site. We will contact you shortly upon receiving the information. We encourage you to get notifications of when security incidents occur by visiting [this page](https://technet.microsoft.com/security/dd252948) and subscribing to Security Advisory Alerts.



  All code is licensed under the MIT license and we triage actively on GitHub. We enthusiastically welcome contributions and feedback. Please read the [contributing guide](./contributing.md) before starting.



  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.


pkgId: ba1a46080943274eb172debc66f8fcd8b84ea63fe351525e52d66ea71f47135e
name: python-msal-extensions
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://pypi.org/project/msal-extensions/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-33067a09-2d1b-4dca-a851-c1c8d4d10498
location_href: 00004246-python-msal-extensions/python-msal-extensions-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Microsoft Authentication Library extensions (MSAL EX) provides a persistence API that can save your data on disk, encrypted on Windows, macOS and Linux. Concurrent data access will be coordinated by a file lock mechanism.

description:
  The Microsoft Authentication Extensions for Python offers secure mechanisms for client applications to perform cross-platform token cache serialization and persistence. It gives additional support to the [Microsoft Authentication Library for Python (MSAL)](https://github.com/AzureAD/microsoft-authentication-library-for-python).

  MSAL Python supports an in-memory cache by default and provides the [SerializableTokenCache](https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache) to perform cache serialization. You can read more about this in the MSAL Python [documentation](https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-python-token-cache-serialization). Developers are required to implement their own cache persistance across multiple platforms and Microsoft Authentication Extensions makes this simpler.

  The supported platforms are Windows, Mac and Linux.
  - Windows - [DPAPI](https://docs.microsoft.com/en-us/dotnet/standard/security/how-to-use-data-protection) is used for encryption.
  - MAC - The MAC KeyChain is used.
  - Linux - [LibSecret](https://wiki.gnome.org/Projects/Libsecret) is used for encryption.

  > Note: It is recommended to use this library for cache persistance support for Public client applications such as Desktop apps only. In web applications, this may lead to scale and performance issues. Web applications are recommended to persist the cache in session. Take a look at this [webapp sample](https://github.com/Azure-Samples/ms-identity-python-webapp).



  You can find Microsoft Authentication Extensions for Python on [Pypi](https://pypi.org/project/msal-extensions/).
  1. If you haven't already, [install and/or upgrade the pip](https://pip.pypa.io/en/stable/installing/)
     of your Python environment to a recent version. We tested with pip 18.1.
  2. Run `pip install msal-extensions`.



  This library follows [Semantic Versioning](http://semver.org/).

  You can find the changes for each version under
  [Releases](https://github.com/AzureAD/microsoft-authentication-extensions-for-python/releases).





  The Microsoft Authentication Extensions library provides the `PersistedTokenCache` which accepts a platform-dependent persistence instance. This token cache can then be used to instantiate the `PublicClientApplication` in MSAL Python.

  The token cache includes a file lock, and auto-reload behavior under the hood.



  Here is an example of this pattern for multiple platforms (taken from the complete [sample here](https://github.com/AzureAD/microsoft-authentication-extensions-for-python/blob/dev/sample/token_cache_sample.py)):

  ```python
  def build_persistence(location, fallback_to_plaintext=False):
      """Build a suitable persistence instance based your current OS"""
      try:
          return build_encrypted_persistence(location)
      except:
          if not fallback_to_plaintext:
              raise
          logging.warning("Encryption unavailable. Opting in to plain text.")
          return FilePersistence(location)

  persistence = build_persistence("token_cache.bin")
  print("Type of persistence: {}".format(persistence.__class__.__name__))
  print("Is this persistence encrypted?", persistence.is_encrypted)

  cache = PersistedTokenCache(persistence)
  ```
  Now you can use it in an MSAL application like this:
  ```python
  app = msal.PublicClientApplication("my_client_id", token_cache=cache)
  ```



  Here is an example of this pattern for multiple platforms (taken from the complete [sample here](https://github.com/AzureAD/microsoft-authentication-extensions-for-python/blob/dev/sample/persistence_sample.py)):

  ```python
  def build_persistence(location, fallback_to_plaintext=False):
      """Build a suitable persistence instance based your current OS"""
      try:
          return build_encrypted_persistence(location)
      except:  # pylint: disable=bare-except
          if not fallback_to_plaintext:
              raise
          logging.warning("Encryption unavailable. Opting in to plain text.")
          return FilePersistence(location)

  persistence = build_persistence("storage.bin", fallback_to_plaintext=False)
  print("Type of persistence: {}".format(persistence.__class__.__name__))
  print("Is this persistence encrypted?", persistence.is_encrypted)

  data = {  # It can be anything, here we demonstrate an arbitrary json object
      "foo": "hello world",
      "bar": "",
      "service_principle_1": "blah blah...",
      }

  persistence.save(json.dumps(data))
  assert json.loads(persistence.load()) == data
  ```




  We leverage Stack Overflow to work with the community on supporting Azure Active Directory and its SDKs, including this one!
  We highly recommend you ask your questions on Stack Overflow (we're all on there!).
  Also browse existing issues to see if someone has had your question before.

  We recommend you use the "msal" tag so we can see it!
  Here is the latest Q&A on Stack Overflow for MSAL:
  [http://stackoverflow.com/questions/tagged/msal](http://stackoverflow.com/questions/tagged/msal)




  All code is licensed under the MIT license and we triage actively on GitHub.

  This project welcomes contributions and suggestions.  Most contributions require you to agree to a
  Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
  the rights to use your contribution. For details, visit https://cla.microsoft.com.

  When you submit a pull request, a CLA-bot will automatically determine whether you need to provide
  a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions
  provided by the bot. You will only need to do this once across all repos using our CLA.




  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.


pkgId: 7e1d5da3609a6eb3bfa98cc0197e2de1b6c67ee36e92fd33867b91bd1866cf22
name: python-msedge-selenium-tools
arch: src
version: 3.141.4
epoch: 0
release: 1
url: https://github.com/microsoft/edge-selenium-tools
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c141fb2c-ab38-4fb8-b9ab-e5edeec9b2c6
location_href: 00012230-python-msedge-selenium-tools/python-msedge-selenium-tools-3.141.4-1.src.rpm
checksum_type: sha256
summary:
  An updated EdgeDriver implementation for Selenium 3 with newly-added support for Microsoft Edge (Chromium).

description:
  <a name="deprecation"></a>
  :warning: **This project is no longer maintained. Please uninstall Selenium Tools for Microsoft Edge and upgrade to [Selenium 4](https://www.selenium.dev/) which has built-in support for Microsoft Edge (Chromium). For help upgrading your Selenium 3 browser tests to Selenium 4, see Selenium's guide [here](https://www.selenium.dev/documentation/webdriver/getting_started/upgrade_to_selenium_4/).** :warning:

  This repository will remain available as an example, and for users that have not yet had a chance to upgrade. However, there will be no further activity on issues or pull requests. The [@EdgeDevTools](https://twitter.com/EdgeDevTools) team will continue to work with the Selenium project to contribute future Microsoft Edge Driver features and bug fixes directly to Selenium 4.

  * * *

  [![Build Status](https://dev.azure.com/ms/edge-selenium-tools/_apis/build/status/microsoft.edge-selenium-tools?branchName=master)](https://dev.azure.com/ms/edge-selenium-tools/_build/latest?definitionId=345&branchName=master)

  Selenium Tools for Microsoft Edge extends [Selenium 3](https://github.com/SeleniumHQ/selenium/releases/tag/selenium-3.141.59) with a unified driver to help you write automated tests for both the Microsoft Edge (EdgeHTML) and new Microsoft Edge (Chromium) browsers.

  The libraries included in this project are fully compatible with Selenium's built-in Edge libraries, and run Microsoft Edge (EdgeHTML) by default so you can use our project as a seamless drop-in replacement. In addition to being compatible with your existing Selenium tests, Selenium Tools for Microsoft Edge gives you the ability to drive the new Microsoft Edge (Chromium) browser and unlock all of the latest functionality!

  The classes in this package are based on the existing ``Edge`` and ``Chrome`` driver classes included in the [Selenium](https://github.com/SeleniumHQ/selenium) project.



  Selenium Tools for Microsoft Edge was created as a compatiblity solution for developers who have existing Selenium 3 browser tests and want to add coverage for the latest Microsoft Edge (Chromium) browser. The [Microsoft Edge Developer Tools Team](https://twitter.com/EdgeDevTools) recommends using Selenium 4 instead because Selenium 4 has built-in support for Microsoft Edge (Chromium). If you are able to upgrade your existing tests, or write new tests using Selenium 4, then there is no need to use this package as Selenium should already have everything you need built in!

  See Selenium's upgrade [guide](https://www.selenium.dev/documentation/webdriver/getting_started/upgrade_to_selenium_4/) for help with upgrading from Selenium 3 to Selenium 4. If you are unable to upgrade due to a compatibility issues, please consider opening an issue in the official Selenium GitHub repo [here](https://github.com/SeleniumHQ/selenium/issues). If you have determined that you cannot upgrade from Selenium 3 at this time, and would still like to add test coverage for Microsoft Edge (Chromium) to your project, see the steps in the section below.





  You will need the correct [WebDriver executable][webdriver-download] for the version of Microsoft Edge you want to drive. The executables are not included with this package. WebDriver executables for all supported versions of Microsoft Edge are available for download [here][webdriver-download]. For more information, and instructions on downloading the correct driver for your browser, see the [Microsoft Edge WebDriver documentation][webdriver-chromium-docs].



  Selenium Tools for Microsoft Edge depends on the official Selenium 3 package to run. You will need to ensure that both Selenium 3 and the Tools and included in your project.

  Use pip to install the [msedge-selenium-tools](https://pypi.org/project/msedge-selenium-tools/) and [selenium](https://pypi.org/project/selenium/3.141.0/) packages:

  ```
  pip install msedge-selenium-tools selenium==3.141
  ```



  See the [Microsoft Edge WebDriver documentation][webdriver-chromium-docs] for lots more information on using Microsoft Edge (Chromium) with WebDriver.

  ```python
  from msedge.selenium_tools import Edge, EdgeOptions


  driver = Edge()


  options = EdgeOptions()
  options.use_chromium = True
  driver = Edge(options = options)
  ```



  We are glad you are interested in automating the latest Microsoft Edge browser and improving the automation experience for the rest of the community!

  Before you begin, please read & follow our [Contributor's Guide](CONTRIBUTING.md). Consider also contributing your feature or bug fix directly to [Selenium](https://github.com/SeleniumHQ/selenium) so that it will be included in future Selenium releases.



  This project has adopted the [Microsoft Open Source Code of Conduct][conduct-code].
  For more information see the [Code of Conduct FAQ][conduct-FAQ] or contact [opencode@microsoft.com][conduct-email] with any additional questions or comments.

  [webdriver-download]: https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/
  [webdriver-chromium-docs]: https://docs.microsoft.com/en-us/microsoft-edge/webdriver-chromium
  [conduct-code]: https://opensource.microsoft.com/codeofconduct/
  [conduct-FAQ]: https://opensource.microsoft.com/codeofconduct/faq/
  [conduct-email]: mailto:opencode@microsoft.com


pkgId: d7a949dadb7e93e61a7096dec8eb1c40e22a0c035d8407d2dfbda4a196a61f96
name: python-msgpack-numpy
arch: src
version: 0.4.8
epoch: 0
release: 1
summary: Numpy data serialization using msgpack
url: https://github.com/lebedov/msgpack-numpy
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03dccff3-07df-4364-bcd1-f52bb9adca1b
location_href: 00010433-python-msgpack-numpy/python-msgpack-numpy-0.4.8-1.src.rpm
checksum_type: sha256
description:
  This package provides encoding and decoding routines that enable the
  serialization and deserialization of numerical and array data types provided by
  [numpy](http://www.numpy.org/) using the highly efficient
  [msgpack](http://msgpack.org/) format. Serialization of Python's
  native complex data types is also supported.
  [![Latest Version](https://img.shields.io/pypi/v/msgpack-numpy.svg)](https://pypi.python.org/pypi/msgpack-numpy)
  [![Build Status](https://travis-ci.org/lebedov/msgpack-numpy.svg?branch=master)](https://travis-ci.org/lebedov/msgpack-numpy)


pkgId: c4b2e9efa806b6c2d99747a92fd6ff044189dc26f58d5d0033bef6ea13e93c96
name: python-mss
arch: src
version: 8.0.2
epoch: 0
release: 1
summary: An ultra fast cross-platform multiple screenshots module in pure python using ctypes.
url: https://github.com/BoboTiG/python-mss
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03320110-f914-453c-af6a-cc0985f447cb
location_href: 00010651-python-mss/python-mss-8.0.2-1.src.rpm
checksum_type: sha256
description:
      from mss import mss
      
      with mss() as sct:
          sct.shot()
  An ultra fast cross-platform multiple screenshots module in pure python using ctypes.
  - **Python 3.8+** and PEP8 compliant, no dependency, thread-safe;
  - very basic, it will grab one screen shot by monitor or a screen shot of all monitors and save it to a PNG file;
  - but you can use PIL and benefit from all its formats (or add yours directly);
  - integrate well with Numpy and OpenCV;
  - it could be easily embedded into games and other software which require fast and platform optimized methods to grab screen shots (like AI, Computer Vision);
  - get the `source code on GitHub <https://github.com/BoboTiG/python-mss>`_;
  - learn with a `bunch of examples <https://python-mss.readthedocs.io/examples.html>`_;
  - you can `report a bug <https://github.com/BoboTiG/python-mss/issues>`_;
  - need some help? Use the tag *python-mss* on `StackOverflow <https://stackoverflow.com/questions/tagged/python-mss>`_;
  - and there is a `complete, and beautiful, documentation <https://python-mss.readthedocs.io>`_ :)
  - **MSS** stands for Multiple Screen Shots;


pkgId: 66db812b6abd83702420df713404bc3ce107bf582d5491e8995b56c0ccdb6fc2
name: python-mtg
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Console-based access to the Gatherer Magic Card Database.
url: https://github.com/chigby/mtg
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3fde3dc-0666-4e9b-9b56-8dbb16dd43c3
location_href: 00004252-python-mtg/python-mtg-1.6.1-1.src.rpm
checksum_type: sha256
description:
  Search for Magic cards from the command line.  Limit your results by
  card name, color, type, rules text, converted mana cost, power,
  toughness, or expansion set.  Rulings and flavor text also available.
  Clean interface and output.


pkgId: 903cf4d19a32c67672647ec0341b03bb6b2feaf9a0a29d57f8da22aa6eaeee43
name: python-mtscomp
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Lossless compression for electrophysiology time-series
url: https://github.com/int-brain-lab/mtscomp
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1d35629-1f0a-4401-af5f-5f46c47bc2c8
location_href: 00012600-python-mtscomp/python-mtscomp-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/int-brain-lab/mtscomp.svg?branch=master)](https://travis-ci.org/int-brain-lab/mtscomp)
  [![Coverage Status](https://codecov.io/gh/int-brain-lab/mtscomp/branch/master/graph/badge.svg)](https://codecov.io/gh/int-brain-lab/mtscomp)

  This library implements a simple lossless compression scheme adapted to time-dependent high-frequency, high-dimensional signals. It is being developed within the [International Brain Laboratory](https://www.internationalbrainlab.com/) with the aim of being the compression library used for all large-scale electrophysiological recordings based on Neuropixels. The signals are typically recorded at 30 kHz and 10 bit depth, and contain several hundreds of channels.




  The requested features for the compression scheme were as follows:

  * Lossless compression only (one should retrieve byte-to-byte exact decompressed data).
  * Written in pure Python (no C extensions) with minimal dependencies so as to simplify distribution.
  * Scalable to large sample rates, large number of channels, long recording time.
  * Faster than real time (i.e. it should take less time to compress than to record).
  * Multithreaded so as to leverage multiple CPU cores.
  * On-the-fly decompression and random read accesses.
  * As simple as possible.

  The compression scheme is the following:

  * The data is split into chunks along the time axis.
  * The time differences are computed for all channels.
  * These time differences are compressed with zlib.
  * The compressed chunks (and initial values of each chunk) are appended in a binary file.
  * Metadata about the compression, including the chunk offsets within the compressed binary file, are saved in a secondary JSON file.

  Saving the offsets allows for on-the-fly decompression and random data access: one simply has to determine which chunks should be loaded, and load them directly from the compressed binary file. The compressed chunks are decompressed with zlib, and the original data is recovered with a cumulative sum (the inverse of the time difference operation).

  With large-scale neurophysiological recordings, we achieved a compression ratio of 3x.

  As a consistency check, the compressed file is by default automatically and transparently decompressed and compared to the original file on a byte-per-byte basis.




  * Python 3.7+
  * NumPy
  * tqdm [for the progress bar]

  For development only:

  * flake8
  * pytest
  * pytest-cov
  * coverage




  ```
  pip install mtscomp
  ```




  Example:

  ```bash


  mtscomp data.bin -n 385 -s 30000 -d int16 [--set-default]

  mtsdecomp data.cbin -o data.decomp.bin
  ```

  Usage:

  ```
  usage: mtscomp [-h] [-d DTYPE] [-s SAMPLE_RATE] [-n N_CHANNELS] [-p CPUS]
                 [-c CHUNK] [-nc] [-v] [--set-default]
                 path [out] [outmeta]

  Compress a raw binary file.

  positional arguments:
    path                  input path of a raw binary file
    out                   output path of the compressed binary file (.cbin)
    outmeta               output path of the compression metadata JSON file
                          (.ch)

  optional arguments:
    -h, --help            show this help message and exit
    -d DTYPE, --dtype DTYPE
                          data type
    -s SAMPLE_RATE, --sample-rate SAMPLE_RATE
                          sample rate
    -n N_CHANNELS, --n-channels N_CHANNELS
                          number of channels
    -p CPUS, --cpus CPUS  number of CPUs to use
    -c CHUNK, --chunk CHUNK
                          chunk duration
    -nc, --no-check       no check
    -v, --debug           verbose
    --set-default         set the specified parameters as the default



  usage: mtsdecomp [-h] [-o [OUT]] [--overwrite] [-nc] [-v] cdata [cmeta]

  Decompress a raw binary file.

  positional arguments:
    cdata                 path to the input compressed binary file (.cbin)
    cmeta                 path to the input compression metadata JSON file (.ch)

  optional arguments:
    -h, --help            show this help message and exit
    -o [OUT], --out [OUT]
                          path to the output decompressed file (.bin)
    --overwrite, -f       overwrite existing output
    -nc, --no-check       no check
    -v, --debug           verbose
  ```




  Example:

  ```python
  import numpy as np
  from mtscomp.mtscomp import compress, decompress


  compress('data.bin', 'data.cbin', 'data.ch', sample_rate=20000., n_channels=256, dtype=np.int16)

  arr = decompress('data.cbin', 'data.ch')
  X = arr[start:end, :]  # decompress the data on the fly directly from the file on disk
  arr.close()  # Close the file when done
  ```




  Example:

  ```python
  import numpy as np
  from mtscomp import Writer, Reader


  w = Writer(chunk_duration=1.)

  w.open('data.bin', sample_rate=20000., n_channels=256, dtype=np.int16)

  w.write('data.cbin', 'data.ch')
  w.close()


  r = Reader()

  r.open('data.cbin', 'data.ch')



  array = r[:]

  r.tofile('data_dec.bin')
  r.close()
  ```




  * **Multithreading**: since Python's zlib releases the GIL, the library uses multiple threads when compressing a file. The chunks are grouped in batches containing as many chunks as threads. After each batch, the chunks are written in the binary file in the right order (since the threads of the batch have no reason to finish in order).




  Performance on an Neuropixels dataset (30 kHz, 385 channels) and Intel 10-core i9-9820X CPU @ 3.3GHz:

  * Compression ratio: -63% (compressed files are nearly 3x smaller)
  * Compression time (20 threads): 88 MB/s, **4x faster than real time**
  * Decompression time (single-threaded at the moment): 22 MB/s, **3x faster than real time**


pkgId: 204a48fb046a834b12be1bdbb3f2e67b5ad7fdbba8e91b8dfffb57974125e818
name: python-mulpyplexer
arch: src
version: 0.09
epoch: 0
release: 1
summary: A module that multiplexes interactions with lists of python objects.
url: https://pypi.org/project/mulpyplexer/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bc204b9f-8c6e-4d00-a70d-287ddc735b6d
location_href: 00004253-python-mulpyplexer/python-mulpyplexer-0.09-1.src.rpm
checksum_type: sha256
description:
  Mulpyplexer is a piece of code that can multiplex interactions with lists of python objects.
  It's easier to show you:

      import mulpyplexer

      class A:
          def __init__(self, i):
              self.i = i

          def add(self, j):
              return A(self.i + (j.i if isinstance(j, A) else j))

          def sub(self, j):
              return A(self.i - (j.i if isinstance(j, A) else j))

          def __repr__(self):
              return "<A %d>" % self.i

          def str(self):
              return str(self.i)

          def __eq__(self, o):
              return self.i == o.i

      one = mulpyplexer.MP([ A(10), A(20), A(30) ])

      two = one.add(5)
      assert two.mp_items == [ A(15), A(25), A(35) ]

      three = two.sub(10)
      assert three.mp_items == [ A(5), A(15), A(25) ]

      four = three.add(one)
      assert four.mp_items == [ A(15), A(35), A(55) ]

      five = four.str()
      assert five.mp_items == [ "15", "35", "55" ]

      six = four.i
      assert six.mp_items == [ 15, 35, 55 ]


pkgId: e9ad0b0ca2d5f68903123f83953029638d90610c59c533e8e32be26306b12108
name: python-multi_key_dict
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Multi key dictionary implementation
url: https://github.com/formiaczek/multi_key_dict
rpm_license: License :: OSI Approved :: MIT License (http://opensource.org/licenses/MIT)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8468f302-aa66-4943-ad0e-6914d5a88f29
location_href: 00004254-python-multi_key_dict/python-multi_key_dict-2.0.3-1.src.rpm
checksum_type: sha256
description:
  Implementation of a multi-key dictionary, i.e.:
  (key1[,key2, ..]) => value
  This dictionary has a similar interface to the standard dictionary => but is extended to support multiple keys referring to the same element.
  If element is created using multiple keys, e.g.:
      from multi_key_dict import multi_key_dict
      k = multi_key_dict()
      k[1000, 'kilo', 'k'] = 'kilo (x1000)'
      print k[1000] # will print 'kilo (x1000)'
      print k['k'] # will also print 'kilo (x1000)'
      
      
      
      k['kilo'] = 'kilo'
      print k[1000] # will now print 'kilo' as value was updated
  These elements can be accessed using either of those keys (e.g for read/update/deletion).
  Multi-key dict provides also extended interface for iterating over items and keys (e.g. by the key type), which might be useful when creating, e.g. dictionaries with index-name key pair allowing to iterate over items using either: names or indexes.
  It can be useful for many many other similar use-cases, and there is no limit to the number of keys used to map to the value.
  There are few other useful methods, e.g. to iterate over dictionary (by/using) selected key type, finding other keys mapping to the same value etc. Refer to example/test code to see it in action.


pkgId: 8b0ddfbca20331fccc7a8b7e7ae47967e4695091a1f4bf52b78a863b5ba6a079
name: python-multidict-debuginfo
arch: aarch64
version: 6.0.4
epoch: 0
release: 1
summary: Debug information for package python-multidict
url: https://github.com/aio-libs/multidict
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e62aa15c-4cbb-4844-a69b-3cb7950c1252
rpm_sourcerpm: python-multidict-6.0.4-1.src.rpm
location_href: 00008917-python-multidict/python-multidict-debuginfo-6.0.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-multidict.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: d9ec750bab1fa62370ed05dd6403357849d5204d79d24d50d28e4d8588fa462f
name: python-multidict-debugsource
arch: aarch64
version: 6.0.4
epoch: 0
release: 1
summary: Debug sources for package python-multidict
url: https://github.com/aio-libs/multidict
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e62aa15c-4cbb-4844-a69b-3cb7950c1252
rpm_sourcerpm: python-multidict-6.0.4-1.src.rpm
location_href: 00008917-python-multidict/python-multidict-debugsource-6.0.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-multidict.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e0f9e36f3c081d5483182805a065466a8e831e7813a01be0154105adaa222f78
name: python-multipart
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Parser for multipart/form-data.
url: http://github.com/defnull/multipart
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b7b131bc-8504-435e-86fb-e73c496f3927
location_href: 00004256-python-multipart/python-multipart-0.2.4-1.src.rpm
checksum_type: sha256
description:
  This module provides a parser for the multipart/form-data format. It can read
  from a file, a socket or a WSGI environment. The parser can be used to replace
  cgi.FieldStorage to work around its limitations.


pkgId: c418fac533d4bb7b81e0d2be4961e39919b15fb55dae5137915a8cd89d7d2f03
name: python-multitasking
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: Non-blocking Python methods using decorators
url: https://github.com/ranaroussi/multitasking
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9dfa8bf3-8fdd-484d-ba96-d26fe89abb00
location_href: 00010413-python-multitasking/python-multitasking-0.0.11-1.src.rpm
checksum_type: sha256
description:
  \
  **MultiTasking** is a tiny Python library lets you convert your Python methods into asynchronous,
  non-blocking methods simply by using a decorator.


pkgId: 0cf6aaaf55f276928b878b463b90925147aa0b3280e026299a9cde3ff5269369
name: python-munch
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: A dot-accessible dictionary (a la JavaScript objects)
url: https://github.com/Infinidat/munch
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e5626a3-42bd-494f-b6cb-045b8fc123e2
location_href: 00009315-python-munch/python-munch-2.5.0-1.src.rpm
checksum_type: sha256
description:
  munch is a fork of David Schoonover's **Bunch** package, providing similar functionality. 99% of the work was done by him, and the fork was made mainly for lack of responsiveness for fixes and maintenance on the original code.
  Munch is a dictionary that supports attribute-style access, a la JavaScript:
  ```python
  >>> b = Munch()
  >>> b.hello = 'world'
  >>> b.hello
  'world'
  >>> b['hello'] += "!"
  >>> b.hello
  'world!'
  >>> b.foo = Munch(lol=True)
  >>> b.foo.lol
  True
  >>> b.foo is b['foo']
  True
  ```


pkgId: e896b1ff7974b415fdaffe6b68ab143da73516a12ebb173456a47d0bf7941f2e
name: python-munkres
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: Munkres (Hungarian) algorithm for the Assignment Problem
url: https://software.clapper.org/munkres/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a89be689-0835-4fcf-a80a-4ccb8a925790
location_href: 00004257-python-munkres/python-munkres-1.1.4-1.src.rpm
checksum_type: sha256
description:
  The Munkres module provides an implementation of the Munkres algorithm
  (also called the Hungarian algorithm or the Kuhn-Munkres algorithm),
  useful for solving the Assignment Problem.
  For complete usage documentation, see: https://software.clapper.org/munkres/


pkgId: 089696b053aa7971b395f3f24103e04ac4437bf7832cffe4b9442301f2e1cae8
name: python-musicbrainzngs
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Python bindings for the MusicBrainz NGS and the Cover Art Archive webservices
url: https://python-musicbrainzngs.readthedocs.io/
rpm_license: BSD 2-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2821a659-9dac-484f-8f1f-7be9bde9a870
location_href: 00004260-python-musicbrainzngs/python-musicbrainzngs-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Musicbrainz NGS bindings


  This library implements webservice bindings for the Musicbrainz NGS site, also known as /ws/2
  and the `Cover Art Archive <https://coverartarchive.org/>`_.

  For more information on the musicbrainz webservice see `<http://wiki.musicbrainz.org/XML_Web_Service>`_.

  Usage
  *****

  .. code:: python

      
      import musicbrainzngs

      
      musicbrainzngs.auth("user", "password")

      
      
      
      musicbrainzngs.set_useragent("Example music app", "0.1", "http://example.com/music")

      
      musicbrainzngs.set_hostname("beta.musicbrainz.org")

  See the ``query.py`` file for more examples.

  More documentation is available at
  `Read the Docs <https://python-musicbrainzngs.readthedocs.org>`_.

  Contribute
  **********

  If you want to contribute to this repository, please read `the
  contribution guidelines
  <https://github.com/alastair/python-musicbrainzngs/blob/master/CONTRIBUTING.md>`_ first.


  Authors
  *******

  These bindings were written by `Alastair Porter <http://github.com/alastair>`_.
  Contributions have been made by:

  * `Adrian Sampson <https://github.com/sampsyo>`_
  * `Corey Farwell <https://github.com/frewsxcv>`_
  * `Galen Hazelwood <https://github.com/galenhz>`_
  * `Greg Ward <https://github.com/gward>`_
  * `Ian McEwen <https://github.com/ianmcorvidae>`_
  * `Jérémie Detrey <https://github.com/jdetrey>`_
  * `Johannes Dewender <https://github.com/JonnyJD>`_
  * `Michael Marineau <https://github.com/marineam>`_
  * `Patrick Speiser <https://github.com/doskir>`_
  * `Pavan Chander <https://github.com/navap>`_
  * `Paul Bailey <https://github.com/paulbailey>`_
  * `Rui Gonçalves <https://github.com/ruippeixotog>`_
  * `Ryan Helinski <https://github.com/rlhelinski>`_
  * `Sam Doshi <https://github.com/samdoshi>`_
  * `Shadab Zafar <https://github.com/dufferzafar>`_
  * `Simon Chopin <https://github.com/laarmen>`_
  * `Thomas Vander Stichele <https://github.com/thomasvs>`_
  * `Wieland Hoffmann <https://github.com/mineo>`_

  License
  *******

  This library is released under the simplified BSD license except for the file
  ``musicbrainzngs/compat.py`` which is licensed under the ISC license.
  See COPYING for details.


pkgId: 411a5599ee53a7bc1b6e5e3219050cc91d04756dbdb74d963b80a1d3fa6a1f7d
name: python-mutagen
arch: src
version: 1.46.0
epoch: 0
release: 1
summary: read and write audio tags for many formats
url: https://github.com/quodlibet/mutagen
rpm_license: GPL-2.0-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fcaa8f98-baaa-4fdf-b15c-c0d5980d6762
location_href: 00004261-python-mutagen/python-mutagen-1.46.0-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://raw.githubusercontent.com/quodlibet/mutagen/master/docs/images/logo.svg
     :align: center
     :width: 400px

  |

  Mutagen is a Python module to handle audio metadata. It supports ASF, FLAC,
  MP4, Monkey's Audio, MP3, Musepack, Ogg Opus, Ogg FLAC, Ogg Speex, Ogg Theora,
  Ogg Vorbis, True Audio, WavPack, OptimFROG, and AIFF audio files. All
  versions of ID3v2 are supported, and all standard ID3v2.4 frames are parsed.
  It can read Xing headers to accurately calculate the bitrate and length of
  MP3s. ID3 and APEv2 tags can be edited regardless of audio format. It can also
  manipulate Ogg streams on an individual packet/page level.

  Mutagen works with Python 3.7+ (CPython and PyPy) on Linux, Windows and macOS,
  and has no dependencies outside the Python standard library. Mutagen is licensed
  under `the GPL version 2 or
  later <https://spdx.org/licenses/GPL-2.0-or-later.html>`__.

  For more information visit https://mutagen.readthedocs.org

  .. image:: https://codecov.io/gh/quodlibet/mutagen/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/quodlibet/mutagen


pkgId: d0c4fa5e1b8466f3e8263c3dcb8f7464ac588ecc62b6e04e35c8a2cbc6cbdeb4
name: python-mwclient
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: MediaWiki API client
url: https://github.com/btongminh/mwclient
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d51a39ad-3e2b-4d71-90f0-e1d32cccf01f
location_href: 00004263-python-mwclient/python-mwclient-0.10.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
      <img alt="mwclient logo" src="docs/source/logo.png"/>
      <h1>mwclient</h1>
  </div>

  [![Build status][build-status-img]](https://travis-ci.org/mwclient/mwclient)
  [![Test coverage][test-coverage-img]](https://coveralls.io/r/mwclient/mwclient)
  [![Latest version][latest-version-img]](https://pypi.python.org/pypi/mwclient)
  [![MIT license][mit-license-img]](http://opensource.org/licenses/MIT)
  [![Documentation status][documentation-status-img]](http://mwclient.readthedocs.io/en/latest/)
  [![Issue statistics][issue-statistics-img]](http://isitmaintained.com/project/tldr-pages/tldr)
  [![Gitter chat][gitter-chat-img]](https://gitter.im/mwclient/mwclient)


  [build-status-img]: https://img.shields.io/travis/mwclient/mwclient.svg
  [test-coverage-img]: https://img.shields.io/coveralls/mwclient/mwclient.svg
  [latest-version-img]: https://img.shields.io/pypi/v/mwclient.svg
  [mit-license-img]: https://img.shields.io/github/license/mwclient/mwclient.svg
  [documentation-status-img]: https://readthedocs.org/projects/mwclient/badge/
  [issue-statistics-img]: http://isitmaintained.com/badge/resolution/tldr-pages/tldr.svg
  [gitter-chat-img]: https://img.shields.io/gitter/room/mwclient/mwclient.svg

  mwclient is a lightweight Python client library to the
  [MediaWiki API](https://mediawiki.org/wiki/API)
  which provides access to most API functionality.
  It works with Python 2.7 as well as 3.5 and above,
  and supports MediaWiki 1.16 and above.
  For functions not available in the current MediaWiki,
  a `MediaWikiVersionError` is raised.

  The current stable
  [version 0.10.1](https://github.com/mwclient/mwclient/archive/v0.10.1.zip)
  is [available through PyPI](https://pypi.python.org/pypi/mwclient):

  ```
  $ pip install mwclient
  ```

  The current [development version](https://github.com/mwclient/mwclient)
  can be installed from GitHub:

  ```
  $ pip install git+git://github.com/mwclient/mwclient.git
  ```

  Please see the [changelog
  document](https://github.com/mwclient/mwclient/blob/master/CHANGELOG.md)
  for a list of changes.



  Up-to-date documentation is hosted [at Read the Docs](http://mwclient.readthedocs.io/en/latest/).
  It includes a user guide to get started using mwclient, a reference guide,
  implementation and development notes.

  There is also some documentation on the [GitHub wiki](https://github.com/mwclient/mwclient/wiki)
  that hasn't been ported yet.
  If you want to help, you're welcome!



  Patches are welcome! See [this page](https://mwclient.readthedocs.io/en/latest/development/)
  for information on how to get started with mwclient development.


pkgId: 21138a82e68e287ba937ca4eddacf8e8f6316b9f42ffe288750837ba56335e3d
name: python-mypy
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Optional static typing for Python
url: http://www.mypy-lang.org/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc9d4f53-7fd6-4973-8eeb-b8fe37127b28
location_href: 00004266-python-mypy/python-mypy-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Add type annotations to your Python programs, and use mypy to type
  check them.  Mypy is essentially a Python linter on steroids, and it
  can catch many programming errors by analyzing your program, without
  actually having to run it.  Mypy has a powerful type system with
  features such as type inference, gradual typing, generics and union
  types.


pkgId: 6a7670f3a45e4b28bd25519d93f2a6a2090891ff15ba1605f75e4e752cfe118a
name: python-mypy-boto3
arch: src
version: 1.26.109
epoch: 0
release: 1
summary: Type annotations for boto3 1.26.109 master module generated with mypy-boto3-builder 7.14.5
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-650a95ff-f39c-4c45-9048-0cb9473a5b52
location_href: 00011543-python-mypy-boto3/python-mypy-boto3-1.26.109-1.src.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3"></a>



  [![PyPI - mypy-boto3](https://img.shields.io/pypi/v/mypy-boto3.svg?color=blue)](https://pypi.org/project/mypy-boto3)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3.svg?color=blue)](https://pypi.org/project/mypy-boto3)
  [![Docs](https://img.shields.io/readthedocs/boto3-stubs.svg?color=blue)](https://youtype.github.io/boto3_stubs_docs/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/mypy-boto3?color=blue)](https://pypistats.org/packages/mypy-boto3)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Dynamic
  [boto3 1.26.109](https://boto3.amazonaws.com/v1/documentation/api/1.26.109/index.html)
  type annotations builder for
  [boto3-stubs](https://pypi.org/project/boto3-stubs/).

  Generated by
  [mypy-boto3-builder 7.14.5](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page.

  See how it helps to find and fix potential bugs:

  ![boto3-stubs demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3](#mypy-boto3)
    - [How to install](#how-to-install)
    - [Usage](#usage)

  <a id="how-to-install"></a>



  ```bash

  python -m pip install 'boto3-stubs[s3,ec2]'



  python -m pip install 'boto3-stubs-lite[s3,ec2]'
  ```

  <a id="usage"></a>



  This tool is not longer required for annotations to work. Do not use it,
  install [boto3-stubs](https://pypi.org/project/boto3-stubs/) instead.


pkgId: 3fe0c209ab7e0242ad8d322cb23cbeb73b74b87090e5629070c13b8f4308edeb
name: python-mypy-boto3-accessanalyzer
arch: src
version: 1.26.61
epoch: 0
release: 1
summary: Type annotations for boto3.AccessAnalyzer 1.26.61 service generated with mypy-boto3-builder 7.12.3
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a0b42db4-1d7c-4271-869b-14d6c5703957
location_href: 00014230-python-mypy-boto3-accessanalyzer/python-mypy-boto3-accessanalyzer-1.26.61-1.src.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-accessanalyzer"></a>



  [![PyPI - mypy-boto3-accessanalyzer](https://img.shields.io/pypi/v/mypy-boto3-accessanalyzer.svg?color=blue)](https://pypi.org/project/mypy-boto3-accessanalyzer)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-accessanalyzer.svg?color=blue)](https://pypi.org/project/mypy-boto3-accessanalyzer)
  [![Docs](https://img.shields.io/readthedocs/mypy-boto3-builder.svg?color=blue)](https://mypy-boto3-builder.readthedocs.io/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/mypy-boto3-accessanalyzer?color=blue)](https://pypistats.org/packages/mypy-boto3-accessanalyzer)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3.AccessAnalyzer 1.26.61](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/accessanalyzer.html#AccessAnalyzer)
  service compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated by
  [mypy-boto3-builder 7.12.3](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-accessanalyzer docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_accessanalyzer/).

  See how it helps to find and fix potential bugs:

  ![boto3-stubs demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-accessanalyzer](#mypy-boto3-accessanalyzer)
    - [How to install](#how-to-install)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Typed dictionaries](#typed-dictionaries)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `AccessAnalyzer`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `AccessAnalyzer` service.

  ```bash

  python -m pip install 'boto3-stubs[accessanalyzer]'




  python -m pip install 'boto3-stubs-lite[accessanalyzer]'



  python -m pip install mypy-boto3-accessanalyzer
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-accessanalyzer
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs[accessanalyzer]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  Install `boto3-stubs-lite[accessanalyzer]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[accessanalyzer]'`
  ```

  Both type checking and code completion should now work. Explicit type
  annotations **are required**.

  Use `boto3-stubs` package instead for implicit type discovery.

  <a id="emacs"></a>



  - Install `boto3-stubs` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `boto3-stubs`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs[accessanalyzer]` with services you use in your
    environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs[accessanalyzer]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'`
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs[accessanalyzer]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'
  ```

  Optionally, you can install `boto3-stubs` to `typings` folder.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `AccessAnalyzerClient` provides annotations for
  `boto3.client("accessanalyzer")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_accessanalyzer import AccessAnalyzerClient

  client: AccessAnalyzerClient = Session().client("accessanalyzer")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_accessanalyzer.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_accessanalyzer import AccessAnalyzerClient
  from mypy_boto3_accessanalyzer.paginator import (
      ListAccessPreviewFindingsPaginator,
      ListAccessPreviewsPaginator,
      ListAnalyzedResourcesPaginator,
      ListAnalyzersPaginator,
      ListArchiveRulesPaginator,
      ListFindingsPaginator,
      ListPolicyGenerationsPaginator,
      ValidatePolicyPaginator,
  )

  client: AccessAnalyzerClient = Session().client("accessanalyzer")



  list_access_preview_findings_paginator: ListAccessPreviewFindingsPaginator = client.get_paginator(
      "list_access_preview_findings"
  )
  list_access_previews_paginator: ListAccessPreviewsPaginator = client.get_paginator(
      "list_access_previews"
  )
  list_analyzed_resources_paginator: ListAnalyzedResourcesPaginator = client.get_paginator(
      "list_analyzed_resources"
  )
  list_analyzers_paginator: ListAnalyzersPaginator = client.get_paginator("list_analyzers")
  list_archive_rules_paginator: ListArchiveRulesPaginator = client.get_paginator("list_archive_rules")
  list_findings_paginator: ListFindingsPaginator = client.get_paginator("list_findings")
  list_policy_generations_paginator: ListPolicyGenerationsPaginator = client.get_paginator(
      "list_policy_generations"
  )
  validate_policy_paginator: ValidatePolicyPaginator = client.get_paginator("validate_policy")
  ```

  <a id="literals"></a>



  `mypy_boto3_accessanalyzer.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  ```python
  from mypy_boto3_accessanalyzer.literals import (
      AccessPreviewStatusReasonCodeType,
      AccessPreviewStatusType,
      AclPermissionType,
      AnalyzerStatusType,
      FindingChangeTypeType,
      FindingSourceTypeType,
      FindingStatusType,
      FindingStatusUpdateType,
      JobErrorCodeType,
      JobStatusType,
      KmsGrantOperationType,
      ListAccessPreviewFindingsPaginatorName,
      ListAccessPreviewsPaginatorName,
      ListAnalyzedResourcesPaginatorName,
      ListAnalyzersPaginatorName,
      ListArchiveRulesPaginatorName,
      ListFindingsPaginatorName,
      ListPolicyGenerationsPaginatorName,
      LocaleType,
      OrderByType,
      PolicyTypeType,
      ReasonCodeType,
      ResourceTypeType,
      TypeType,
      ValidatePolicyFindingTypeType,
      ValidatePolicyPaginatorName,
      ValidatePolicyResourceTypeType,
      AccessAnalyzerServiceName,
      ServiceName,
      ResourceServiceName,
      PaginatorName,
      RegionName,
  )


  def check_value(value: AccessPreviewStatusReasonCodeType) -> bool:
      ...
  ```

  <a id="typed-dictionaries"></a>



  `mypy_boto3_accessanalyzer.type_defs` module contains structures and shapes
  assembled to typed dictionaries for additional type checking.

  ```python
  from mypy_boto3_accessanalyzer.type_defs import (
      AccessPreviewStatusReasonTypeDef,
      AclGranteeTypeDef,
      AnalyzedResourceSummaryTypeDef,
      AnalyzedResourceTypeDef,
      StatusReasonTypeDef,
      ApplyArchiveRuleRequestRequestTypeDef,
      CriterionTypeDef,
      CancelPolicyGenerationRequestRequestTypeDef,
      TrailTypeDef,
      TrailPropertiesTypeDef,
      EbsSnapshotConfigurationTypeDef,
      EcrRepositoryConfigurationTypeDef,
      EfsFileSystemConfigurationTypeDef,
      IamRoleConfigurationTypeDef,
      SecretsManagerSecretConfigurationTypeDef,
      SnsTopicConfigurationTypeDef,
      SqsQueueConfigurationTypeDef,
      ResponseMetadataTypeDef,
      DeleteAnalyzerRequestRequestTypeDef,
      DeleteArchiveRuleRequestRequestTypeDef,
      FindingSourceDetailTypeDef,
      GeneratedPolicyTypeDef,
      GetAccessPreviewRequestRequestTypeDef,
      GetAnalyzedResourceRequestRequestTypeDef,
      GetAnalyzerRequestRequestTypeDef,
      GetArchiveRuleRequestRequestTypeDef,
      GetFindingRequestRequestTypeDef,
      GetGeneratedPolicyRequestRequestTypeDef,
      JobErrorTypeDef,
      KmsGrantConstraintsTypeDef,
      PaginatorConfigTypeDef,
      ListAccessPreviewsRequestRequestTypeDef,
      ListAnalyzedResourcesRequestRequestTypeDef,
      ListAnalyzersRequestRequestTypeDef,
      ListArchiveRulesRequestRequestTypeDef,
      SortCriteriaTypeDef,
      ListPolicyGenerationsRequestRequestTypeDef,
      PolicyGenerationTypeDef,
      ListTagsForResourceRequestRequestTypeDef,
      VpcConfigurationTypeDef,
      SubstringTypeDef,
      PolicyGenerationDetailsTypeDef,
      PositionTypeDef,
      RdsDbClusterSnapshotAttributeValueTypeDef,
      RdsDbSnapshotAttributeValueTypeDef,
      S3PublicAccessBlockConfigurationTypeDef,
      StartResourceScanRequestRequestTypeDef,
      TagResourceRequestRequestTypeDef,
      UntagResourceRequestRequestTypeDef,
      UpdateFindingsRequestRequestTypeDef,
      ValidatePolicyRequestRequestTypeDef,
      AccessPreviewSummaryTypeDef,
      S3BucketAclGrantConfigurationTypeDef,
      AnalyzerSummaryTypeDef,
      ArchiveRuleSummaryTypeDef,
      CreateArchiveRuleRequestRequestTypeDef,
      InlineArchiveRuleTypeDef,
      ListAccessPreviewFindingsRequestRequestTypeDef,
      UpdateArchiveRuleRequestRequestTypeDef,
      CloudTrailDetailsTypeDef,
      CloudTrailPropertiesTypeDef,
      CreateAccessPreviewResponseTypeDef,
      CreateAnalyzerResponseTypeDef,
      EmptyResponseMetadataTypeDef,
      GetAnalyzedResourceResponseTypeDef,
      ListAnalyzedResourcesResponseTypeDef,
      ListTagsForResourceResponseTypeDef,
      StartPolicyGenerationResponseTypeDef,
      FindingSourceTypeDef,
      JobDetailsTypeDef,
      KmsGrantConfigurationTypeDef,
      ListAccessPreviewFindingsRequestListAccessPreviewFindingsPaginateTypeDef,
      ListAccessPreviewsRequestListAccessPreviewsPaginateTypeDef,
      ListAnalyzedResourcesRequestListAnalyzedResourcesPaginateTypeDef,
      ListAnalyzersRequestListAnalyzersPaginateTypeDef,
      ListArchiveRulesRequestListArchiveRulesPaginateTypeDef,
      ListPolicyGenerationsRequestListPolicyGenerationsPaginateTypeDef,
      ValidatePolicyRequestValidatePolicyPaginateTypeDef,
      ListFindingsRequestListFindingsPaginateTypeDef,
      ListFindingsRequestRequestTypeDef,
      ListPolicyGenerationsResponseTypeDef,
      NetworkOriginConfigurationTypeDef,
      PathElementTypeDef,
      SpanTypeDef,
      RdsDbClusterSnapshotConfigurationTypeDef,
      RdsDbSnapshotConfigurationTypeDef,
      ListAccessPreviewsResponseTypeDef,
      GetAnalyzerResponseTypeDef,
      ListAnalyzersResponseTypeDef,
      GetArchiveRuleResponseTypeDef,
      ListArchiveRulesResponseTypeDef,
      CreateAnalyzerRequestRequestTypeDef,
      StartPolicyGenerationRequestRequestTypeDef,
      GeneratedPolicyPropertiesTypeDef,
      AccessPreviewFindingTypeDef,
      FindingSummaryTypeDef,
      FindingTypeDef,
      KmsKeyConfigurationTypeDef,
      S3AccessPointConfigurationTypeDef,
      LocationTypeDef,
      GeneratedPolicyResultTypeDef,
      ListAccessPreviewFindingsResponseTypeDef,
      ListFindingsResponseTypeDef,
      GetFindingResponseTypeDef,
      S3BucketConfigurationTypeDef,
      ValidatePolicyFindingTypeDef,
      GetGeneratedPolicyResponseTypeDef,
      ConfigurationTypeDef,
      ValidatePolicyResponseTypeDef,
      AccessPreviewTypeDef,
      CreateAccessPreviewRequestRequestTypeDef,
      GetAccessPreviewResponseTypeDef,
  )


  def get_structure() -> AccessPreviewStatusReasonTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers a drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from the documentation (blame `botocore` docs if types
    are incorrect).
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [black](https://github.com/psf/black) and
    [isort](https://github.com/PyCQA/isort) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore` and `aiobotocore` libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.session` calls
  - Auto discovery of types for `session.client` and `session.session` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `mypy-boto3-accessanalyzer` version is the same as related `boto3` version and
  follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_accessanalyzer/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: 0fede21eb5f3571898e433236d66d147779eba05054b0bd71ea04cdb676db507
name: python-mypy-boto3-accessanalyzer-help
arch: noarch
version: 1.26.61
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-accessanalyzer
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a0b42db4-1d7c-4271-869b-14d6c5703957
rpm_sourcerpm: python-mypy-boto3-accessanalyzer-1.26.61-1.src.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-accessanalyzer"></a>



  [![PyPI - mypy-boto3-accessanalyzer](https://img.shields.io/pypi/v/mypy-boto3-accessanalyzer.svg?color=blue)](https://pypi.org/project/mypy-boto3-accessanalyzer)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-accessanalyzer.svg?color=blue)](https://pypi.org/project/mypy-boto3-accessanalyzer)
  [![Docs](https://img.shields.io/readthedocs/mypy-boto3-builder.svg?color=blue)](https://mypy-boto3-builder.readthedocs.io/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/mypy-boto3-accessanalyzer?color=blue)](https://pypistats.org/packages/mypy-boto3-accessanalyzer)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3.AccessAnalyzer 1.26.61](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/accessanalyzer.html#AccessAnalyzer)
  service compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated by
  [mypy-boto3-builder 7.12.3](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-accessanalyzer docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_accessanalyzer/).

  See how it helps to find and fix potential bugs:

  ![boto3-stubs demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-accessanalyzer](#mypy-boto3-accessanalyzer)
    - [How to install](#how-to-install)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Typed dictionaries](#typed-dictionaries)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `AccessAnalyzer`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `AccessAnalyzer` service.

  ```bash

  python -m pip install 'boto3-stubs[accessanalyzer]'




  python -m pip install 'boto3-stubs-lite[accessanalyzer]'



  python -m pip install mypy-boto3-accessanalyzer
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-accessanalyzer
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs[accessanalyzer]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  Install `boto3-stubs-lite[accessanalyzer]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[accessanalyzer]'`
  ```

  Both type checking and code completion should now work. Explicit type
  annotations **are required**.

  Use `boto3-stubs` package instead for implicit type discovery.

  <a id="emacs"></a>



  - Install `boto3-stubs` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `boto3-stubs`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs[accessanalyzer]` with services you use in your
    environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs[accessanalyzer]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'`
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs[accessanalyzer]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[accessanalyzer]'
  ```

  Optionally, you can install `boto3-stubs` to `typings` folder.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `AccessAnalyzerClient` provides annotations for
  `boto3.client("accessanalyzer")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_accessanalyzer import AccessAnalyzerClient

  client: AccessAnalyzerClient = Session().client("accessanalyzer")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_accessanalyzer.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_accessanalyzer import AccessAnalyzerClient
  from mypy_boto3_accessanalyzer.paginator import (
      ListAccessPreviewFindingsPaginator,
      ListAccessPreviewsPaginator,
      ListAnalyzedResourcesPaginator,
      ListAnalyzersPaginator,
      ListArchiveRulesPaginator,
      ListFindingsPaginator,
      ListPolicyGenerationsPaginator,
      ValidatePolicyPaginator,
  )

  client: AccessAnalyzerClient = Session().client("accessanalyzer")



  list_access_preview_findings_paginator: ListAccessPreviewFindingsPaginator = client.get_paginator(
      "list_access_preview_findings"
  )
  list_access_previews_paginator: ListAccessPreviewsPaginator = client.get_paginator(
      "list_access_previews"
  )
  list_analyzed_resources_paginator: ListAnalyzedResourcesPaginator = client.get_paginator(
      "list_analyzed_resources"
  )
  list_analyzers_paginator: ListAnalyzersPaginator = client.get_paginator("list_analyzers")
  list_archive_rules_paginator: ListArchiveRulesPaginator = client.get_paginator("list_archive_rules")
  list_findings_paginator: ListFindingsPaginator = client.get_paginator("list_findings")
  list_policy_generations_paginator: ListPolicyGenerationsPaginator = client.get_paginator(
      "list_policy_generations"
  )
  validate_policy_paginator: ValidatePolicyPaginator = client.get_paginator("validate_policy")
  ```

  <a id="literals"></a>



  `mypy_boto3_accessanalyzer.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  ```python
  from mypy_boto3_accessanalyzer.literals import (
      AccessPreviewStatusReasonCodeType,
      AccessPreviewStatusType,
      AclPermissionType,
      AnalyzerStatusType,
      FindingChangeTypeType,
      FindingSourceTypeType,
      FindingStatusType,
      FindingStatusUpdateType,
      JobErrorCodeType,
      JobStatusType,
      KmsGrantOperationType,
      ListAccessPreviewFindingsPaginatorName,
      ListAccessPreviewsPaginatorName,
      ListAnalyzedResourcesPaginatorName,
      ListAnalyzersPaginatorName,
      ListArchiveRulesPaginatorName,
      ListFindingsPaginatorName,
      ListPolicyGenerationsPaginatorName,
      LocaleType,
      OrderByType,
      PolicyTypeType,
      ReasonCodeType,
      ResourceTypeType,
      TypeType,
      ValidatePolicyFindingTypeType,
      ValidatePolicyPaginatorName,
      ValidatePolicyResourceTypeType,
      AccessAnalyzerServiceName,
      ServiceName,
      ResourceServiceName,
      PaginatorName,
      RegionName,
  )


  def check_value(value: AccessPreviewStatusReasonCodeType) -> bool:
      ...
  ```

  <a id="typed-dictionaries"></a>



  `mypy_boto3_accessanalyzer.type_defs` module contains structures and shapes
  assembled to typed dictionaries for additional type checking.

  ```python
  from mypy_boto3_accessanalyzer.type_defs import (
      AccessPreviewStatusReasonTypeDef,
      AclGranteeTypeDef,
      AnalyzedResourceSummaryTypeDef,
      AnalyzedResourceTypeDef,
      StatusReasonTypeDef,
      ApplyArchiveRuleRequestRequestTypeDef,
      CriterionTypeDef,
      CancelPolicyGenerationRequestRequestTypeDef,
      TrailTypeDef,
      TrailPropertiesTypeDef,
      EbsSnapshotConfigurationTypeDef,
      EcrRepositoryConfigurationTypeDef,
      EfsFileSystemConfigurationTypeDef,
      IamRoleConfigurationTypeDef,
      SecretsManagerSecretConfigurationTypeDef,
      SnsTopicConfigurationTypeDef,
      SqsQueueConfigurationTypeDef,
      ResponseMetadataTypeDef,
      DeleteAnalyzerRequestRequestTypeDef,
      DeleteArchiveRuleRequestRequestTypeDef,
      FindingSourceDetailTypeDef,
      GeneratedPolicyTypeDef,
      GetAccessPreviewRequestRequestTypeDef,
      GetAnalyzedResourceRequestRequestTypeDef,
      GetAnalyzerRequestRequestTypeDef,
      GetArchiveRuleRequestRequestTypeDef,
      GetFindingRequestRequestTypeDef,
      GetGeneratedPolicyRequestRequestTypeDef,
      JobErrorTypeDef,
      KmsGrantConstraintsTypeDef,
      PaginatorConfigTypeDef,
      ListAccessPreviewsRequestRequestTypeDef,
      ListAnalyzedResourcesRequestRequestTypeDef,
      ListAnalyzersRequestRequestTypeDef,
      ListArchiveRulesRequestRequestTypeDef,
      SortCriteriaTypeDef,
      ListPolicyGenerationsRequestRequestTypeDef,
      PolicyGenerationTypeDef,
      ListTagsForResourceRequestRequestTypeDef,
      VpcConfigurationTypeDef,
      SubstringTypeDef,
      PolicyGenerationDetailsTypeDef,
      PositionTypeDef,
      RdsDbClusterSnapshotAttributeValueTypeDef,
      RdsDbSnapshotAttributeValueTypeDef,
      S3PublicAccessBlockConfigurationTypeDef,
      StartResourceScanRequestRequestTypeDef,
      TagResourceRequestRequestTypeDef,
      UntagResourceRequestRequestTypeDef,
      UpdateFindingsRequestRequestTypeDef,
      ValidatePolicyRequestRequestTypeDef,
      AccessPreviewSummaryTypeDef,
      S3BucketAclGrantConfigurationTypeDef,
      AnalyzerSummaryTypeDef,
      ArchiveRuleSummaryTypeDef,
      CreateArchiveRuleRequestRequestTypeDef,
      InlineArchiveRuleTypeDef,
      ListAccessPreviewFindingsRequestRequestTypeDef,
      UpdateArchiveRuleRequestRequestTypeDef,
      CloudTrailDetailsTypeDef,
      CloudTrailPropertiesTypeDef,
      CreateAccessPreviewResponseTypeDef,
      CreateAnalyzerResponseTypeDef,
      EmptyResponseMetadataTypeDef,
      GetAnalyzedResourceResponseTypeDef,
      ListAnalyzedResourcesResponseTypeDef,
      ListTagsForResourceResponseTypeDef,
      StartPolicyGenerationResponseTypeDef,
      FindingSourceTypeDef,
      JobDetailsTypeDef,
      KmsGrantConfigurationTypeDef,
      ListAccessPreviewFindingsRequestListAccessPreviewFindingsPaginateTypeDef,
      ListAccessPreviewsRequestListAccessPreviewsPaginateTypeDef,
      ListAnalyzedResourcesRequestListAnalyzedResourcesPaginateTypeDef,
      ListAnalyzersRequestListAnalyzersPaginateTypeDef,
      ListArchiveRulesRequestListArchiveRulesPaginateTypeDef,
      ListPolicyGenerationsRequestListPolicyGenerationsPaginateTypeDef,
      ValidatePolicyRequestValidatePolicyPaginateTypeDef,
      ListFindingsRequestListFindingsPaginateTypeDef,
      ListFindingsRequestRequestTypeDef,
      ListPolicyGenerationsResponseTypeDef,
      NetworkOriginConfigurationTypeDef,
      PathElementTypeDef,
      SpanTypeDef,
      RdsDbClusterSnapshotConfigurationTypeDef,
      RdsDbSnapshotConfigurationTypeDef,
      ListAccessPreviewsResponseTypeDef,
      GetAnalyzerResponseTypeDef,
      ListAnalyzersResponseTypeDef,
      GetArchiveRuleResponseTypeDef,
      ListArchiveRulesResponseTypeDef,
      CreateAnalyzerRequestRequestTypeDef,
      StartPolicyGenerationRequestRequestTypeDef,
      GeneratedPolicyPropertiesTypeDef,
      AccessPreviewFindingTypeDef,
      FindingSummaryTypeDef,
      FindingTypeDef,
      KmsKeyConfigurationTypeDef,
      S3AccessPointConfigurationTypeDef,
      LocationTypeDef,
      GeneratedPolicyResultTypeDef,
      ListAccessPreviewFindingsResponseTypeDef,
      ListFindingsResponseTypeDef,
      GetFindingResponseTypeDef,
      S3BucketConfigurationTypeDef,
      ValidatePolicyFindingTypeDef,
      GetGeneratedPolicyResponseTypeDef,
      ConfigurationTypeDef,
      ValidatePolicyResponseTypeDef,
      AccessPreviewTypeDef,
      CreateAccessPreviewRequestRequestTypeDef,
      GetAccessPreviewResponseTypeDef,
  )


  def get_structure() -> AccessPreviewStatusReasonTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers a drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from the documentation (blame `botocore` docs if types
    are incorrect).
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [black](https://github.com/psf/black) and
    [isort](https://github.com/PyCQA/isort) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore` and `aiobotocore` libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.session` calls
  - Auto discovery of types for `session.client` and `session.session` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `mypy-boto3-accessanalyzer` version is the same as related `boto3` version and
  follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_accessanalyzer/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.

location_href:
  00014230-python-mypy-boto3-accessanalyzer/python-mypy-boto3-accessanalyzer-help-1.26.61-1.noarch.rpm


pkgId: cd2d3ff69c6a810399345bc2d443f6fe8296bc6e74f927eaeeea39ef19f1de17
name: python-mypy-boto3-acm
arch: src
version: 1.26.5
epoch: 0
release: 1
summary: Type annotations for boto3.ACM 1.26.5 service generated with mypy-boto3-builder 7.11.10
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e671922f-e67c-4864-93f5-9a32f7198212
location_href: 00013733-python-mypy-boto3-acm/python-mypy-boto3-acm-1.26.5-1.src.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-acm"></a>



  [![PyPI - mypy-boto3-acm](https://img.shields.io/pypi/v/mypy-boto3-acm.svg?color=blue)](https://pypi.org/project/mypy-boto3-acm)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-acm.svg?color=blue)](https://pypi.org/project/mypy-boto3-acm)
  [![Docs](https://img.shields.io/readthedocs/mypy-boto3-builder.svg?color=blue)](https://mypy-boto3-builder.readthedocs.io/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/mypy-boto3-acm?color=blue)](https://pypistats.org/packages/mypy-boto3-acm)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3.ACM 1.26.5](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/acm.html#ACM)
  service compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated by
  [mypy-boto3-builder 7.11.10](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-acm docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_acm/).

  See how it helps to find and fix potential bugs:

  ![boto3-stubs demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-acm](#mypy-boto3-acm)
    - [How to install](#how-to-install)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Waiters annotations](#waiters-annotations)
      - [Literals](#literals)
      - [Typed dictionaries](#typed-dictionaries)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `ACM`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `ACM` service.

  ```bash

  python -m pip install 'boto3-stubs[acm]'




  python -m pip install 'boto3-stubs-lite[acm]'



  python -m pip install mypy-boto3-acm
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-acm
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs[acm]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[acm]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  Install `boto3-stubs-lite[acm]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[acm]'`
  ```

  Both type checking and code completion should now work. Explicit type
  annotations **are required**.

  Use `boto3-stubs` package instead for implicit type discovery.

  <a id="emacs"></a>



  - Install `boto3-stubs` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[acm]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `boto3-stubs`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs[acm]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[acm]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs[acm]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[acm]'`
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs[acm]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[acm]'
  ```

  Optionally, you can install `boto3-stubs` to `typings` folder.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `ACMClient` provides annotations for `boto3.client("acm")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_acm import ACMClient

  client: ACMClient = Session().client("acm")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_acm.paginator` module contains type annotations for all paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_acm import ACMClient
  from mypy_boto3_acm.paginator import ListCertificatesPaginator

  client: ACMClient = Session().client("acm")



  list_certificates_paginator: ListCertificatesPaginator = client.get_paginator("list_certificates")
  ```

  <a id="waiters-annotations"></a>



  `mypy_boto3_acm.waiter` module contains type annotations for all waiters.

  ```python
  from boto3.session import Session

  from mypy_boto3_acm import ACMClient
  from mypy_boto3_acm.waiter import CertificateValidatedWaiter

  client: ACMClient = Session().client("acm")



  certificate_validated_waiter: CertificateValidatedWaiter = client.get_waiter(
      "certificate_validated"
  )
  ```

  <a id="literals"></a>



  `mypy_boto3_acm.literals` module contains literals extracted from shapes that
  can be used in user code for type checking.

  ```python
  from mypy_boto3_acm.literals import (
      CertificateStatusType,
      CertificateTransparencyLoggingPreferenceType,
      CertificateTypeType,
      CertificateValidatedWaiterName,
      DomainStatusType,
      ExtendedKeyUsageNameType,
      FailureReasonType,
      KeyAlgorithmType,
      KeyUsageNameType,
      ListCertificatesPaginatorName,
      RecordTypeType,
      RenewalEligibilityType,
      RenewalStatusType,
      RevocationReasonType,
      SortByType,
      SortOrderType,
      ValidationMethodType,
      ACMServiceName,
      ServiceName,
      ResourceServiceName,
      PaginatorName,
      WaiterName,
      RegionName,
  )


  def check_value(value: CertificateStatusType) -> bool:
      ...
  ```

  <a id="typed-dictionaries"></a>



  `mypy_boto3_acm.type_defs` module contains structures and shapes assembled to
  typed dictionaries for additional type checking.

  ```python
  from mypy_boto3_acm.type_defs import (
      TagTypeDef,
      CertificateOptionsTypeDef,
      ExtendedKeyUsageTypeDef,
      KeyUsageTypeDef,
      CertificateSummaryTypeDef,
      DeleteCertificateRequestRequestTypeDef,
      WaiterConfigTypeDef,
      DescribeCertificateRequestRequestTypeDef,
      ResponseMetadataTypeDef,
      DomainValidationOptionTypeDef,
      ResourceRecordTypeDef,
      ExpiryEventsConfigurationTypeDef,
      ExportCertificateRequestRequestTypeDef,
      FiltersTypeDef,
      GetCertificateRequestRequestTypeDef,
      PaginatorConfigTypeDef,
      ListTagsForCertificateRequestRequestTypeDef,
      RenewCertificateRequestRequestTypeDef,
      ResendValidationEmailRequestRequestTypeDef,
      AddTagsToCertificateRequestRequestTypeDef,
      ImportCertificateRequestRequestTypeDef,
      RemoveTagsFromCertificateRequestRequestTypeDef,
      UpdateCertificateOptionsRequestRequestTypeDef,
      DescribeCertificateRequestCertificateValidatedWaitTypeDef,
      EmptyResponseMetadataTypeDef,
      ExportCertificateResponseTypeDef,
      GetCertificateResponseTypeDef,
      ImportCertificateResponseTypeDef,
      ListCertificatesResponseTypeDef,
      ListTagsForCertificateResponseTypeDef,
      RequestCertificateResponseTypeDef,
      RequestCertificateRequestRequestTypeDef,
      DomainValidationTypeDef,
      GetAccountConfigurationResponseTypeDef,
      PutAccountConfigurationRequestRequestTypeDef,
      ListCertificatesRequestRequestTypeDef,
      ListCertificatesRequestListCertificatesPaginateTypeDef,
      RenewalSummaryTypeDef,
      CertificateDetailTypeDef,
      DescribeCertificateResponseTypeDef,
  )


  def get_structure() -> TagTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers a drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from the documentation (blame `botocore` docs if types
    are incorrect).
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [black](https://github.com/psf/black) and
    [isort](https://github.com/PyCQA/isort) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore` and `aiobotocore` libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.session` calls
  - Auto discovery of types for `session.client` and `session.session` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `mypy-boto3-acm` version is the same as related `boto3` version and follows
  [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_acm/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: e933ae2eb3ab887c999e0789a03eadb7b50e10ee8fc444c6354a39f0f695cd28
name: python-mypy-boto3-alexaforbusiness
arch: src
version: 1.26.0.post1
epoch: 0
release: 1
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f110812-300a-4743-b08d-6ed0f9dac762
checksum_type: sha256
summary:
  Type annotations for boto3.AlexaForBusiness 1.26.0 service generated with mypy-boto3-builder 7.11.10

description:
  <a id="mypy-boto3-alexaforbusiness"></a>



  [![PyPI - mypy-boto3-alexaforbusiness](https://img.shields.io/pypi/v/mypy-boto3-alexaforbusiness.svg?color=blue)](https://pypi.org/project/mypy-boto3-alexaforbusiness)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-alexaforbusiness.svg?color=blue)](https://pypi.org/project/mypy-boto3-alexaforbusiness)
  [![Docs](https://img.shields.io/readthedocs/mypy-boto3-builder.svg?color=blue)](https://mypy-boto3-builder.readthedocs.io/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/mypy-boto3-alexaforbusiness?color=blue)](https://pypistats.org/packages/mypy-boto3-alexaforbusiness)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3.AlexaForBusiness 1.26.0](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/alexaforbusiness.html#AlexaForBusiness)
  service compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated by
  [mypy-boto3-builder 7.11.10](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-alexaforbusiness docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_alexaforbusiness/).

  See how it helps to find and fix potential bugs:

  ![boto3-stubs demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-alexaforbusiness](#mypy-boto3-alexaforbusiness)
    - [How to install](#how-to-install)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Typed dictionaries](#typed-dictionaries)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `AlexaForBusiness`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `AlexaForBusiness` service.

  ```bash

  python -m pip install 'boto3-stubs[alexaforbusiness]'




  python -m pip install 'boto3-stubs-lite[alexaforbusiness]'



  python -m pip install mypy-boto3-alexaforbusiness
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-alexaforbusiness
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs[alexaforbusiness]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  Install `boto3-stubs-lite[alexaforbusiness]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[alexaforbusiness]'`
  ```

  Both type checking and code completion should now work. Explicit type
  annotations **are required**.

  Use `boto3-stubs` package instead for implicit type discovery.

  <a id="emacs"></a>



  - Install `boto3-stubs` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `boto3-stubs`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs[alexaforbusiness]` with services you use in your
    environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs[alexaforbusiness]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'`
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs[alexaforbusiness]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'
  ```

  Optionally, you can install `boto3-stubs` to `typings` folder.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `AlexaForBusinessClient` provides annotations for
  `boto3.client("alexaforbusiness")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_alexaforbusiness import AlexaForBusinessClient

  client: AlexaForBusinessClient = Session().client("alexaforbusiness")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_alexaforbusiness.paginator` module contains type annotations for
  all paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_alexaforbusiness import AlexaForBusinessClient
  from mypy_boto3_alexaforbusiness.paginator import (
      ListBusinessReportSchedulesPaginator,
      ListConferenceProvidersPaginator,
      ListDeviceEventsPaginator,
      ListSkillsPaginator,
      ListSkillsStoreCategoriesPaginator,
      ListSkillsStoreSkillsByCategoryPaginator,
      ListSmartHomeAppliancesPaginator,
      ListTagsPaginator,
      SearchDevicesPaginator,
      SearchProfilesPaginator,
      SearchRoomsPaginator,
      SearchSkillGroupsPaginator,
      SearchUsersPaginator,
  )

  client: AlexaForBusinessClient = Session().client("alexaforbusiness")



  list_business_report_schedules_paginator: ListBusinessReportSchedulesPaginator = (
      client.get_paginator("list_business_report_schedules")
  )
  list_conference_providers_paginator: ListConferenceProvidersPaginator = client.get_paginator(
      "list_conference_providers"
  )
  list_device_events_paginator: ListDeviceEventsPaginator = client.get_paginator("list_device_events")
  list_skills_paginator: ListSkillsPaginator = client.get_paginator("list_skills")
  list_skills_store_categories_paginator: ListSkillsStoreCategoriesPaginator = client.get_paginator(
      "list_skills_store_categories"
  )
  list_skills_store_skills_by_category_paginator: ListSkillsStoreSkillsByCategoryPaginator = (
      client.get_paginator("list_skills_store_skills_by_category")
  )
  list_smart_home_appliances_paginator: ListSmartHomeAppliancesPaginator = client.get_paginator(
      "list_smart_home_appliances"
  )
  list_tags_paginator: ListTagsPaginator = client.get_paginator("list_tags")
  search_devices_paginator: SearchDevicesPaginator = client.get_paginator("search_devices")
  search_profiles_paginator: SearchProfilesPaginator = client.get_paginator("search_profiles")
  search_rooms_paginator: SearchRoomsPaginator = client.get_paginator("search_rooms")
  search_skill_groups_paginator: SearchSkillGroupsPaginator = client.get_paginator(
      "search_skill_groups"
  )
  search_users_paginator: SearchUsersPaginator = client.get_paginator("search_users")
  ```

  <a id="literals"></a>



  `mypy_boto3_alexaforbusiness.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  ```python
  from mypy_boto3_alexaforbusiness.literals import (
      BusinessReportFailureCodeType,
      BusinessReportFormatType,
      BusinessReportIntervalType,
      BusinessReportStatusType,
      CommsProtocolType,
      ConferenceProviderTypeType,
      ConnectionStatusType,
      DeviceEventTypeType,
      DeviceStatusDetailCodeType,
      DeviceStatusType,
      DeviceUsageTypeType,
      DistanceUnitType,
      EnablementTypeFilterType,
      EnablementTypeType,
      EndOfMeetingReminderTypeType,
      EnrollmentStatusType,
      FeatureType,
      ListBusinessReportSchedulesPaginatorName,
      ListConferenceProvidersPaginatorName,
      ListDeviceEventsPaginatorName,
      ListSkillsPaginatorName,
      ListSkillsStoreCategoriesPaginatorName,
      ListSkillsStoreSkillsByCategoryPaginatorName,
      ListSmartHomeAppliancesPaginatorName,
      ListTagsPaginatorName,
      LocaleType,
      NetworkEapMethodType,
      NetworkSecurityTypeType,
      PhoneNumberTypeType,
      RequirePinType,
      SearchDevicesPaginatorName,
      SearchProfilesPaginatorName,
      SearchRoomsPaginatorName,
      SearchSkillGroupsPaginatorName,
      SearchUsersPaginatorName,
      SipTypeType,
      SkillTypeFilterType,
      SkillTypeType,
      SortValueType,
      TemperatureUnitType,
      WakeWordType,
      AlexaForBusinessServiceName,
      ServiceName,
      ResourceServiceName,
      PaginatorName,
      RegionName,
  )


  def check_value(value: BusinessReportFailureCodeType) -> bool:
      ...
  ```

  <a id="typed-dictionaries"></a>



  `mypy_boto3_alexaforbusiness.type_defs` module contains structures and shapes
  assembled to typed dictionaries for additional type checking.

  ```python
  from mypy_boto3_alexaforbusiness.type_defs import (
      AddressBookDataTypeDef,
      AddressBookTypeDef,
      ApproveSkillRequestRequestTypeDef,
      AssociateContactWithAddressBookRequestRequestTypeDef,
      AssociateDeviceWithNetworkProfileRequestRequestTypeDef,
      AssociateDeviceWithRoomRequestRequestTypeDef,
      AssociateSkillGroupWithRoomRequestRequestTypeDef,
      AssociateSkillWithSkillGroupRequestRequestTypeDef,
      AssociateSkillWithUsersRequestRequestTypeDef,
      AudioTypeDef,
      BusinessReportContentRangeTypeDef,
      BusinessReportRecurrenceTypeDef,
      BusinessReportS3LocationTypeDef,
      CategoryTypeDef,
      ConferencePreferenceTypeDef,
      IPDialInTypeDef,
      MeetingSettingTypeDef,
      PSTNDialInTypeDef,
      PhoneNumberTypeDef,
      SipAddressTypeDef,
      SsmlTypeDef,
      TextTypeDef,
      TagTypeDef,
      ResponseMetadataTypeDef,
      CreateEndOfMeetingReminderTypeDef,
      CreateInstantBookingTypeDef,
      CreateRequireCheckInTypeDef,
      DeleteAddressBookRequestRequestTypeDef,
      DeleteBusinessReportScheduleRequestRequestTypeDef,
      DeleteConferenceProviderRequestRequestTypeDef,
      DeleteContactRequestRequestTypeDef,
      DeleteDeviceRequestRequestTypeDef,
      DeleteDeviceUsageDataRequestRequestTypeDef,
      DeleteGatewayGroupRequestRequestTypeDef,
      DeleteNetworkProfileRequestRequestTypeDef,
      DeleteProfileRequestRequestTypeDef,
      DeleteRoomRequestRequestTypeDef,
      DeleteRoomSkillParameterRequestRequestTypeDef,
      DeleteSkillAuthorizationRequestRequestTypeDef,
      DeleteSkillGroupRequestRequestTypeDef,
      DeleteUserRequestRequestTypeDef,
      DeveloperInfoTypeDef,
      DeviceEventTypeDef,
      DeviceNetworkProfileInfoTypeDef,
      DeviceStatusDetailTypeDef,
      DisassociateContactFromAddressBookRequestRequestTypeDef,
      DisassociateDeviceFromRoomRequestRequestTypeDef,
      DisassociateSkillFromSkillGroupRequestRequestTypeDef,
      DisassociateSkillFromUsersRequestRequestTypeDef,
      DisassociateSkillGroupFromRoomRequestRequestTypeDef,
      EndOfMeetingReminderTypeDef,
      FilterTypeDef,
      ForgetSmartHomeAppliancesRequestRequestTypeDef,
      GatewayGroupSummaryTypeDef,
      GatewayGroupTypeDef,
      GatewaySummaryTypeDef,
      GatewayTypeDef,
      GetAddressBookRequestRequestTypeDef,
      GetConferenceProviderRequestRequestTypeDef,
      GetContactRequestRequestTypeDef,
      GetDeviceRequestRequestTypeDef,
      GetGatewayGroupRequestRequestTypeDef,
      GetGatewayRequestRequestTypeDef,
      GetNetworkProfileRequestRequestTypeDef,
      NetworkProfileTypeDef,
      GetProfileRequestRequestTypeDef,
      GetRoomRequestRequestTypeDef,
      RoomTypeDef,
      GetRoomSkillParameterRequestRequestTypeDef,
      RoomSkillParameterTypeDef,
      GetSkillGroupRequestRequestTypeDef,
      SkillGroupTypeDef,
      InstantBookingTypeDef,
      PaginatorConfigTypeDef,
      ListBusinessReportSchedulesRequestRequestTypeDef,
      ListConferenceProvidersRequestRequestTypeDef,
      ListDeviceEventsRequestRequestTypeDef,
      ListGatewayGroupsRequestRequestTypeDef,
      ListGatewaysRequestRequestTypeDef,
      ListSkillsRequestRequestTypeDef,
      SkillSummaryTypeDef,
      ListSkillsStoreCategoriesRequestRequestTypeDef,
      ListSkillsStoreSkillsByCategoryRequestRequestTypeDef,
      ListSmartHomeAppliancesRequestRequestTypeDef,
      SmartHomeApplianceTypeDef,
      ListTagsRequestRequestTypeDef,
      RequireCheckInTypeDef,
      NetworkProfileDataTypeDef,
      ProfileDataTypeDef,
      PutInvitationConfigurationRequestRequestTypeDef,
      PutSkillAuthorizationRequestRequestTypeDef,
      RejectSkillRequestRequestTypeDef,
      ResolveRoomRequestRequestTypeDef,
      RevokeInvitationRequestRequestTypeDef,
      RoomDataTypeDef,
      SortTypeDef,
      SkillGroupDataTypeDef,
      UserDataTypeDef,
      SendInvitationRequestRequestTypeDef,
      StartDeviceSyncRequestRequestTypeDef,
      StartSmartHomeApplianceDiscoveryRequestRequestTypeDef,
      UntagResourceRequestRequestTypeDef,
      UpdateAddressBookRequestRequestTypeDef,
      UpdateDeviceRequestRequestTypeDef,
      UpdateEndOfMeetingReminderTypeDef,
      UpdateGatewayGroupRequestRequestTypeDef,
      UpdateGatewayRequestRequestTypeDef,
      UpdateInstantBookingTypeDef,
      UpdateRequireCheckInTypeDef,
      UpdateNetworkProfileRequestRequestTypeDef,
      UpdateRoomRequestRequestTypeDef,
      UpdateSkillGroupRequestRequestTypeDef,
      UpdateBusinessReportScheduleRequestRequestTypeDef,
      BusinessReportTypeDef,
      PutConferencePreferenceRequestRequestTypeDef,
      ConferenceProviderTypeDef,
      UpdateConferenceProviderRequestRequestTypeDef,
      ContactDataTypeDef,
      ContactTypeDef,
      UpdateContactRequestRequestTypeDef,
      ContentTypeDef,
      CreateAddressBookRequestRequestTypeDef,
      CreateBusinessReportScheduleRequestRequestTypeDef,
      CreateConferenceProviderRequestRequestTypeDef,
      CreateContactRequestRequestTypeDef,
      CreateGatewayGroupRequestRequestTypeDef,
      CreateNetworkProfileRequestRequestTypeDef,
      CreateRoomRequestRequestTypeDef,
      CreateSkillGroupRequestRequestTypeDef,
      CreateUserRequestRequestTypeDef,
      RegisterAVSDeviceRequestRequestTypeDef,
      TagResourceRequestRequestTypeDef,
      CreateAddressBookResponseTypeDef,
      CreateBusinessReportScheduleResponseTypeDef,
      CreateConferenceProviderResponseTypeDef,
      CreateContactResponseTypeDef,
      CreateGatewayGroupResponseTypeDef,
      CreateNetworkProfileResponseTypeDef,
      CreateProfileResponseTypeDef,
      CreateRoomResponseTypeDef,
      CreateSkillGroupResponseTypeDef,
      CreateUserResponseTypeDef,
      GetAddressBookResponseTypeDef,
      GetConferencePreferenceResponseTypeDef,
      GetInvitationConfigurationResponseTypeDef,
      ListSkillsStoreCategoriesResponseTypeDef,
      ListTagsResponseTypeDef,
      RegisterAVSDeviceResponseTypeDef,
      SearchAddressBooksResponseTypeDef,
      SendAnnouncementResponseTypeDef,
      CreateMeetingRoomConfigurationTypeDef,
      SkillDetailsTypeDef,
      ListDeviceEventsResponseTypeDef,
      DeviceStatusInfoTypeDef,
      ListGatewayGroupsResponseTypeDef,
      GetGatewayGroupResponseTypeDef,
      ListGatewaysResponseTypeDef,
      GetGatewayResponseTypeDef,
      GetNetworkProfileResponseTypeDef,
      GetRoomResponseTypeDef,
      GetRoomSkillParameterResponseTypeDef,
      PutRoomSkillParameterRequestRequestTypeDef,
      ResolveRoomResponseTypeDef,
      GetSkillGroupResponseTypeDef,
      ListBusinessReportSchedulesRequestListBusinessReportSchedulesPaginateTypeDef,
      ListConferenceProvidersRequestListConferenceProvidersPaginateTypeDef,
      ListDeviceEventsRequestListDeviceEventsPaginateTypeDef,
      ListSkillsRequestListSkillsPaginateTypeDef,
      ListSkillsStoreCategoriesRequestListSkillsStoreCategoriesPaginateTypeDef,
      ListSkillsStoreSkillsByCategoryRequestListSkillsStoreSkillsByCategoryPaginateTypeDef,
      ListSmartHomeAppliancesRequestListSmartHomeAppliancesPaginateTypeDef,
      ListTagsRequestListTagsPaginateTypeDef,
      ListSkillsResponseTypeDef,
      ListSmartHomeAppliancesResponseTypeDef,
      MeetingRoomConfigurationTypeDef,
      SearchNetworkProfilesResponseTypeDef,
      SearchProfilesResponseTypeDef,
      SearchRoomsResponseTypeDef,
      SearchAddressBooksRequestRequestTypeDef,
      SearchContactsRequestRequestTypeDef,
      SearchDevicesRequestRequestTypeDef,
      SearchDevicesRequestSearchDevicesPaginateTypeDef,
      SearchNetworkProfilesRequestRequestTypeDef,
      SearchProfilesRequestRequestTypeDef,
      SearchProfilesRequestSearchProfilesPaginateTypeDef,
      SearchRoomsRequestRequestTypeDef,
      SearchRoomsRequestSearchRoomsPaginateTypeDef,
      SearchSkillGroupsRequestRequestTypeDef,
      SearchSkillGroupsRequestSearchSkillGroupsPaginateTypeDef,
      SearchUsersRequestRequestTypeDef,
      SearchUsersRequestSearchUsersPaginateTypeDef,
      SearchSkillGroupsResponseTypeDef,
      SearchUsersResponseTypeDef,
      UpdateMeetingRoomConfigurationTypeDef,
      BusinessReportScheduleTypeDef,
      GetConferenceProviderResponseTypeDef,
      ListConferenceProvidersResponseTypeDef,
      SearchContactsResponseTypeDef,
      GetContactResponseTypeDef,
      SendAnnouncementRequestRequestTypeDef,
      CreateProfileRequestRequestTypeDef,
      SkillsStoreSkillTypeDef,
      DeviceDataTypeDef,
      DeviceTypeDef,
      ProfileTypeDef,
      UpdateProfileRequestRequestTypeDef,
      ListBusinessReportSchedulesResponseTypeDef,
      ListSkillsStoreSkillsByCategoryResponseTypeDef,
      SearchDevicesResponseTypeDef,
      GetDeviceResponseTypeDef,
      GetProfileResponseTypeDef,
  )


  def get_structure() -> AddressBookDataTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers a drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from the documentation (blame `botocore` docs if types
    are incorrect).
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [black](https://github.com/psf/black) and
    [isort](https://github.com/PyCQA/isort) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore` and `aiobotocore` libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.session` calls
  - Auto discovery of types for `session.client` and `session.session` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `mypy-boto3-alexaforbusiness` version is the same as related `boto3` version
  and follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_alexaforbusiness/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.

location_href:
  00014370-python-mypy-boto3-alexaforbusiness/python-mypy-boto3-alexaforbusiness-1.26.0.post1-1.src.rpm


pkgId: b3ed6bd14aea376cae4ae356bcc32b1dbe59b2f7373c8c687334693170aa7f45
name: python-mypy-boto3-alexaforbusiness-help
arch: noarch
version: 1.26.0.post1
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-alexaforbusiness
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f110812-300a-4743-b08d-6ed0f9dac762
rpm_sourcerpm: python-mypy-boto3-alexaforbusiness-1.26.0.post1-1.src.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-alexaforbusiness"></a>



  [![PyPI - mypy-boto3-alexaforbusiness](https://img.shields.io/pypi/v/mypy-boto3-alexaforbusiness.svg?color=blue)](https://pypi.org/project/mypy-boto3-alexaforbusiness)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-alexaforbusiness.svg?color=blue)](https://pypi.org/project/mypy-boto3-alexaforbusiness)
  [![Docs](https://img.shields.io/readthedocs/mypy-boto3-builder.svg?color=blue)](https://mypy-boto3-builder.readthedocs.io/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/mypy-boto3-alexaforbusiness?color=blue)](https://pypistats.org/packages/mypy-boto3-alexaforbusiness)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3.AlexaForBusiness 1.26.0](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/alexaforbusiness.html#AlexaForBusiness)
  service compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated by
  [mypy-boto3-builder 7.11.10](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-alexaforbusiness docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_alexaforbusiness/).

  See how it helps to find and fix potential bugs:

  ![boto3-stubs demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-alexaforbusiness](#mypy-boto3-alexaforbusiness)
    - [How to install](#how-to-install)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Typed dictionaries](#typed-dictionaries)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `AlexaForBusiness`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `AlexaForBusiness` service.

  ```bash

  python -m pip install 'boto3-stubs[alexaforbusiness]'




  python -m pip install 'boto3-stubs-lite[alexaforbusiness]'



  python -m pip install mypy-boto3-alexaforbusiness
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-alexaforbusiness
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs[alexaforbusiness]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  Install `boto3-stubs-lite[alexaforbusiness]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[alexaforbusiness]'`
  ```

  Both type checking and code completion should now work. Explicit type
  annotations **are required**.

  Use `boto3-stubs` package instead for implicit type discovery.

  <a id="emacs"></a>



  - Install `boto3-stubs` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `boto3-stubs`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs[alexaforbusiness]` with services you use in your
    environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs[alexaforbusiness]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'`
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs[alexaforbusiness]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[alexaforbusiness]'
  ```

  Optionally, you can install `boto3-stubs` to `typings` folder.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `AlexaForBusinessClient` provides annotations for
  `boto3.client("alexaforbusiness")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_alexaforbusiness import AlexaForBusinessClient

  client: AlexaForBusinessClient = Session().client("alexaforbusiness")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_alexaforbusiness.paginator` module contains type annotations for
  all paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_alexaforbusiness import AlexaForBusinessClient
  from mypy_boto3_alexaforbusiness.paginator import (
      ListBusinessReportSchedulesPaginator,
      ListConferenceProvidersPaginator,
      ListDeviceEventsPaginator,
      ListSkillsPaginator,
      ListSkillsStoreCategoriesPaginator,
      ListSkillsStoreSkillsByCategoryPaginator,
      ListSmartHomeAppliancesPaginator,
      ListTagsPaginator,
      SearchDevicesPaginator,
      SearchProfilesPaginator,
      SearchRoomsPaginator,
      SearchSkillGroupsPaginator,
      SearchUsersPaginator,
  )

  client: AlexaForBusinessClient = Session().client("alexaforbusiness")



  list_business_report_schedules_paginator: ListBusinessReportSchedulesPaginator = (
      client.get_paginator("list_business_report_schedules")
  )
  list_conference_providers_paginator: ListConferenceProvidersPaginator = client.get_paginator(
      "list_conference_providers"
  )
  list_device_events_paginator: ListDeviceEventsPaginator = client.get_paginator("list_device_events")
  list_skills_paginator: ListSkillsPaginator = client.get_paginator("list_skills")
  list_skills_store_categories_paginator: ListSkillsStoreCategoriesPaginator = client.get_paginator(
      "list_skills_store_categories"
  )
  list_skills_store_skills_by_category_paginator: ListSkillsStoreSkillsByCategoryPaginator = (
      client.get_paginator("list_skills_store_skills_by_category")
  )
  list_smart_home_appliances_paginator: ListSmartHomeAppliancesPaginator = client.get_paginator(
      "list_smart_home_appliances"
  )
  list_tags_paginator: ListTagsPaginator = client.get_paginator("list_tags")
  search_devices_paginator: SearchDevicesPaginator = client.get_paginator("search_devices")
  search_profiles_paginator: SearchProfilesPaginator = client.get_paginator("search_profiles")
  search_rooms_paginator: SearchRoomsPaginator = client.get_paginator("search_rooms")
  search_skill_groups_paginator: SearchSkillGroupsPaginator = client.get_paginator(
      "search_skill_groups"
  )
  search_users_paginator: SearchUsersPaginator = client.get_paginator("search_users")
  ```

  <a id="literals"></a>



  `mypy_boto3_alexaforbusiness.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  ```python
  from mypy_boto3_alexaforbusiness.literals import (
      BusinessReportFailureCodeType,
      BusinessReportFormatType,
      BusinessReportIntervalType,
      BusinessReportStatusType,
      CommsProtocolType,
      ConferenceProviderTypeType,
      ConnectionStatusType,
      DeviceEventTypeType,
      DeviceStatusDetailCodeType,
      DeviceStatusType,
      DeviceUsageTypeType,
      DistanceUnitType,
      EnablementTypeFilterType,
      EnablementTypeType,
      EndOfMeetingReminderTypeType,
      EnrollmentStatusType,
      FeatureType,
      ListBusinessReportSchedulesPaginatorName,
      ListConferenceProvidersPaginatorName,
      ListDeviceEventsPaginatorName,
      ListSkillsPaginatorName,
      ListSkillsStoreCategoriesPaginatorName,
      ListSkillsStoreSkillsByCategoryPaginatorName,
      ListSmartHomeAppliancesPaginatorName,
      ListTagsPaginatorName,
      LocaleType,
      NetworkEapMethodType,
      NetworkSecurityTypeType,
      PhoneNumberTypeType,
      RequirePinType,
      SearchDevicesPaginatorName,
      SearchProfilesPaginatorName,
      SearchRoomsPaginatorName,
      SearchSkillGroupsPaginatorName,
      SearchUsersPaginatorName,
      SipTypeType,
      SkillTypeFilterType,
      SkillTypeType,
      SortValueType,
      TemperatureUnitType,
      WakeWordType,
      AlexaForBusinessServiceName,
      ServiceName,
      ResourceServiceName,
      PaginatorName,
      RegionName,
  )


  def check_value(value: BusinessReportFailureCodeType) -> bool:
      ...
  ```

  <a id="typed-dictionaries"></a>



  `mypy_boto3_alexaforbusiness.type_defs` module contains structures and shapes
  assembled to typed dictionaries for additional type checking.

  ```python
  from mypy_boto3_alexaforbusiness.type_defs import (
      AddressBookDataTypeDef,
      AddressBookTypeDef,
      ApproveSkillRequestRequestTypeDef,
      AssociateContactWithAddressBookRequestRequestTypeDef,
      AssociateDeviceWithNetworkProfileRequestRequestTypeDef,
      AssociateDeviceWithRoomRequestRequestTypeDef,
      AssociateSkillGroupWithRoomRequestRequestTypeDef,
      AssociateSkillWithSkillGroupRequestRequestTypeDef,
      AssociateSkillWithUsersRequestRequestTypeDef,
      AudioTypeDef,
      BusinessReportContentRangeTypeDef,
      BusinessReportRecurrenceTypeDef,
      BusinessReportS3LocationTypeDef,
      CategoryTypeDef,
      ConferencePreferenceTypeDef,
      IPDialInTypeDef,
      MeetingSettingTypeDef,
      PSTNDialInTypeDef,
      PhoneNumberTypeDef,
      SipAddressTypeDef,
      SsmlTypeDef,
      TextTypeDef,
      TagTypeDef,
      ResponseMetadataTypeDef,
      CreateEndOfMeetingReminderTypeDef,
      CreateInstantBookingTypeDef,
      CreateRequireCheckInTypeDef,
      DeleteAddressBookRequestRequestTypeDef,
      DeleteBusinessReportScheduleRequestRequestTypeDef,
      DeleteConferenceProviderRequestRequestTypeDef,
      DeleteContactRequestRequestTypeDef,
      DeleteDeviceRequestRequestTypeDef,
      DeleteDeviceUsageDataRequestRequestTypeDef,
      DeleteGatewayGroupRequestRequestTypeDef,
      DeleteNetworkProfileRequestRequestTypeDef,
      DeleteProfileRequestRequestTypeDef,
      DeleteRoomRequestRequestTypeDef,
      DeleteRoomSkillParameterRequestRequestTypeDef,
      DeleteSkillAuthorizationRequestRequestTypeDef,
      DeleteSkillGroupRequestRequestTypeDef,
      DeleteUserRequestRequestTypeDef,
      DeveloperInfoTypeDef,
      DeviceEventTypeDef,
      DeviceNetworkProfileInfoTypeDef,
      DeviceStatusDetailTypeDef,
      DisassociateContactFromAddressBookRequestRequestTypeDef,
      DisassociateDeviceFromRoomRequestRequestTypeDef,
      DisassociateSkillFromSkillGroupRequestRequestTypeDef,
      DisassociateSkillFromUsersRequestRequestTypeDef,
      DisassociateSkillGroupFromRoomRequestRequestTypeDef,
      EndOfMeetingReminderTypeDef,
      FilterTypeDef,
      ForgetSmartHomeAppliancesRequestRequestTypeDef,
      GatewayGroupSummaryTypeDef,
      GatewayGroupTypeDef,
      GatewaySummaryTypeDef,
      GatewayTypeDef,
      GetAddressBookRequestRequestTypeDef,
      GetConferenceProviderRequestRequestTypeDef,
      GetContactRequestRequestTypeDef,
      GetDeviceRequestRequestTypeDef,
      GetGatewayGroupRequestRequestTypeDef,
      GetGatewayRequestRequestTypeDef,
      GetNetworkProfileRequestRequestTypeDef,
      NetworkProfileTypeDef,
      GetProfileRequestRequestTypeDef,
      GetRoomRequestRequestTypeDef,
      RoomTypeDef,
      GetRoomSkillParameterRequestRequestTypeDef,
      RoomSkillParameterTypeDef,
      GetSkillGroupRequestRequestTypeDef,
      SkillGroupTypeDef,
      InstantBookingTypeDef,
      PaginatorConfigTypeDef,
      ListBusinessReportSchedulesRequestRequestTypeDef,
      ListConferenceProvidersRequestRequestTypeDef,
      ListDeviceEventsRequestRequestTypeDef,
      ListGatewayGroupsRequestRequestTypeDef,
      ListGatewaysRequestRequestTypeDef,
      ListSkillsRequestRequestTypeDef,
      SkillSummaryTypeDef,
      ListSkillsStoreCategoriesRequestRequestTypeDef,
      ListSkillsStoreSkillsByCategoryRequestRequestTypeDef,
      ListSmartHomeAppliancesRequestRequestTypeDef,
      SmartHomeApplianceTypeDef,
      ListTagsRequestRequestTypeDef,
      RequireCheckInTypeDef,
      NetworkProfileDataTypeDef,
      ProfileDataTypeDef,
      PutInvitationConfigurationRequestRequestTypeDef,
      PutSkillAuthorizationRequestRequestTypeDef,
      RejectSkillRequestRequestTypeDef,
      ResolveRoomRequestRequestTypeDef,
      RevokeInvitationRequestRequestTypeDef,
      RoomDataTypeDef,
      SortTypeDef,
      SkillGroupDataTypeDef,
      UserDataTypeDef,
      SendInvitationRequestRequestTypeDef,
      StartDeviceSyncRequestRequestTypeDef,
      StartSmartHomeApplianceDiscoveryRequestRequestTypeDef,
      UntagResourceRequestRequestTypeDef,
      UpdateAddressBookRequestRequestTypeDef,
      UpdateDeviceRequestRequestTypeDef,
      UpdateEndOfMeetingReminderTypeDef,
      UpdateGatewayGroupRequestRequestTypeDef,
      UpdateGatewayRequestRequestTypeDef,
      UpdateInstantBookingTypeDef,
      UpdateRequireCheckInTypeDef,
      UpdateNetworkProfileRequestRequestTypeDef,
      UpdateRoomRequestRequestTypeDef,
      UpdateSkillGroupRequestRequestTypeDef,
      UpdateBusinessReportScheduleRequestRequestTypeDef,
      BusinessReportTypeDef,
      PutConferencePreferenceRequestRequestTypeDef,
      ConferenceProviderTypeDef,
      UpdateConferenceProviderRequestRequestTypeDef,
      ContactDataTypeDef,
      ContactTypeDef,
      UpdateContactRequestRequestTypeDef,
      ContentTypeDef,
      CreateAddressBookRequestRequestTypeDef,
      CreateBusinessReportScheduleRequestRequestTypeDef,
      CreateConferenceProviderRequestRequestTypeDef,
      CreateContactRequestRequestTypeDef,
      CreateGatewayGroupRequestRequestTypeDef,
      CreateNetworkProfileRequestRequestTypeDef,
      CreateRoomRequestRequestTypeDef,
      CreateSkillGroupRequestRequestTypeDef,
      CreateUserRequestRequestTypeDef,
      RegisterAVSDeviceRequestRequestTypeDef,
      TagResourceRequestRequestTypeDef,
      CreateAddressBookResponseTypeDef,
      CreateBusinessReportScheduleResponseTypeDef,
      CreateConferenceProviderResponseTypeDef,
      CreateContactResponseTypeDef,
      CreateGatewayGroupResponseTypeDef,
      CreateNetworkProfileResponseTypeDef,
      CreateProfileResponseTypeDef,
      CreateRoomResponseTypeDef,
      CreateSkillGroupResponseTypeDef,
      CreateUserResponseTypeDef,
      GetAddressBookResponseTypeDef,
      GetConferencePreferenceResponseTypeDef,
      GetInvitationConfigurationResponseTypeDef,
      ListSkillsStoreCategoriesResponseTypeDef,
      ListTagsResponseTypeDef,
      RegisterAVSDeviceResponseTypeDef,
      SearchAddressBooksResponseTypeDef,
      SendAnnouncementResponseTypeDef,
      CreateMeetingRoomConfigurationTypeDef,
      SkillDetailsTypeDef,
      ListDeviceEventsResponseTypeDef,
      DeviceStatusInfoTypeDef,
      ListGatewayGroupsResponseTypeDef,
      GetGatewayGroupResponseTypeDef,
      ListGatewaysResponseTypeDef,
      GetGatewayResponseTypeDef,
      GetNetworkProfileResponseTypeDef,
      GetRoomResponseTypeDef,
      GetRoomSkillParameterResponseTypeDef,
      PutRoomSkillParameterRequestRequestTypeDef,
      ResolveRoomResponseTypeDef,
      GetSkillGroupResponseTypeDef,
      ListBusinessReportSchedulesRequestListBusinessReportSchedulesPaginateTypeDef,
      ListConferenceProvidersRequestListConferenceProvidersPaginateTypeDef,
      ListDeviceEventsRequestListDeviceEventsPaginateTypeDef,
      ListSkillsRequestListSkillsPaginateTypeDef,
      ListSkillsStoreCategoriesRequestListSkillsStoreCategoriesPaginateTypeDef,
      ListSkillsStoreSkillsByCategoryRequestListSkillsStoreSkillsByCategoryPaginateTypeDef,
      ListSmartHomeAppliancesRequestListSmartHomeAppliancesPaginateTypeDef,
      ListTagsRequestListTagsPaginateTypeDef,
      ListSkillsResponseTypeDef,
      ListSmartHomeAppliancesResponseTypeDef,
      MeetingRoomConfigurationTypeDef,
      SearchNetworkProfilesResponseTypeDef,
      SearchProfilesResponseTypeDef,
      SearchRoomsResponseTypeDef,
      SearchAddressBooksRequestRequestTypeDef,
      SearchContactsRequestRequestTypeDef,
      SearchDevicesRequestRequestTypeDef,
      SearchDevicesRequestSearchDevicesPaginateTypeDef,
      SearchNetworkProfilesRequestRequestTypeDef,
      SearchProfilesRequestRequestTypeDef,
      SearchProfilesRequestSearchProfilesPaginateTypeDef,
      SearchRoomsRequestRequestTypeDef,
      SearchRoomsRequestSearchRoomsPaginateTypeDef,
      SearchSkillGroupsRequestRequestTypeDef,
      SearchSkillGroupsRequestSearchSkillGroupsPaginateTypeDef,
      SearchUsersRequestRequestTypeDef,
      SearchUsersRequestSearchUsersPaginateTypeDef,
      SearchSkillGroupsResponseTypeDef,
      SearchUsersResponseTypeDef,
      UpdateMeetingRoomConfigurationTypeDef,
      BusinessReportScheduleTypeDef,
      GetConferenceProviderResponseTypeDef,
      ListConferenceProvidersResponseTypeDef,
      SearchContactsResponseTypeDef,
      GetContactResponseTypeDef,
      SendAnnouncementRequestRequestTypeDef,
      CreateProfileRequestRequestTypeDef,
      SkillsStoreSkillTypeDef,
      DeviceDataTypeDef,
      DeviceTypeDef,
      ProfileTypeDef,
      UpdateProfileRequestRequestTypeDef,
      ListBusinessReportSchedulesResponseTypeDef,
      ListSkillsStoreSkillsByCategoryResponseTypeDef,
      SearchDevicesResponseTypeDef,
      GetDeviceResponseTypeDef,
      GetProfileResponseTypeDef,
  )


  def get_structure() -> AddressBookDataTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers a drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from the documentation (blame `botocore` docs if types
    are incorrect).
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [black](https://github.com/psf/black) and
    [isort](https://github.com/PyCQA/isort) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore` and `aiobotocore` libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.session` calls
  - Auto discovery of types for `session.client` and `session.session` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `mypy-boto3-alexaforbusiness` version is the same as related `boto3` version
  and follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_alexaforbusiness/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.

location_href:
  00014370-python-mypy-boto3-alexaforbusiness/python-mypy-boto3-alexaforbusiness-help-1.26.0.post1-1.noarch.rpm


pkgId: 757dd3386192834acae5a4e270c6d9b81871e391a73769ad12795457cc7c989f
name: python-mypy-boto3-amplify
arch: src
version: 1.26.12
epoch: 0
release: 1
summary: Type annotations for boto3.Amplify 1.26.12 service generated with mypy-boto3-builder 7.11.10
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a97f3e10-fa38-4fd5-b4f3-46dff5e89aff
location_href: 00014326-python-mypy-boto3-amplify/python-mypy-boto3-amplify-1.26.12-1.src.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-amplify"></a>



  [![PyPI - mypy-boto3-amplify](https://img.shields.io/pypi/v/mypy-boto3-amplify.svg?color=blue)](https://pypi.org/project/mypy-boto3-amplify)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-amplify.svg?color=blue)](https://pypi.org/project/mypy-boto3-amplify)
  [![Docs](https://img.shields.io/readthedocs/mypy-boto3-builder.svg?color=blue)](https://mypy-boto3-builder.readthedocs.io/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/mypy-boto3-amplify?color=blue)](https://pypistats.org/packages/mypy-boto3-amplify)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3.Amplify 1.26.12](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/amplify.html#Amplify)
  service compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated by
  [mypy-boto3-builder 7.11.10](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-amplify docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amplify/).

  See how it helps to find and fix potential bugs:

  ![boto3-stubs demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-amplify](#mypy-boto3-amplify)
    - [How to install](#how-to-install)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Typed dictionaries](#typed-dictionaries)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `Amplify`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `Amplify` service.

  ```bash

  python -m pip install 'boto3-stubs[amplify]'




  python -m pip install 'boto3-stubs-lite[amplify]'



  python -m pip install mypy-boto3-amplify
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-amplify
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs[amplify]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  Install `boto3-stubs-lite[amplify]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[amplify]'`
  ```

  Both type checking and code completion should now work. Explicit type
  annotations **are required**.

  Use `boto3-stubs` package instead for implicit type discovery.

  <a id="emacs"></a>



  - Install `boto3-stubs` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `boto3-stubs`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs[amplify]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs[amplify]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'`
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs[amplify]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  Optionally, you can install `boto3-stubs` to `typings` folder.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `AmplifyClient` provides annotations for `boto3.client("amplify")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_amplify import AmplifyClient

  client: AmplifyClient = Session().client("amplify")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_amplify.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_amplify import AmplifyClient
  from mypy_boto3_amplify.paginator import (
      ListAppsPaginator,
      ListBranchesPaginator,
      ListDomainAssociationsPaginator,
      ListJobsPaginator,
  )

  client: AmplifyClient = Session().client("amplify")



  list_apps_paginator: ListAppsPaginator = client.get_paginator("list_apps")
  list_branches_paginator: ListBranchesPaginator = client.get_paginator("list_branches")
  list_domain_associations_paginator: ListDomainAssociationsPaginator = client.get_paginator(
      "list_domain_associations"
  )
  list_jobs_paginator: ListJobsPaginator = client.get_paginator("list_jobs")
  ```

  <a id="literals"></a>



  `mypy_boto3_amplify.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  ```python
  from mypy_boto3_amplify.literals import (
      DomainStatusType,
      JobStatusType,
      JobTypeType,
      ListAppsPaginatorName,
      ListBranchesPaginatorName,
      ListDomainAssociationsPaginatorName,
      ListJobsPaginatorName,
      PlatformType,
      RepositoryCloneMethodType,
      StageType,
      AmplifyServiceName,
      ServiceName,
      ResourceServiceName,
      PaginatorName,
      RegionName,
  )


  def check_value(value: DomainStatusType) -> bool:
      ...
  ```

  <a id="typed-dictionaries"></a>



  `mypy_boto3_amplify.type_defs` module contains structures and shapes assembled
  to typed dictionaries for additional type checking.

  ```python
  from mypy_boto3_amplify.type_defs import (
      AutoBranchCreationConfigTypeDef,
      CustomRuleTypeDef,
      ProductionBranchTypeDef,
      ArtifactTypeDef,
      BackendEnvironmentTypeDef,
      BranchTypeDef,
      ResponseMetadataTypeDef,
      CreateBackendEnvironmentRequestRequestTypeDef,
      CreateBranchRequestRequestTypeDef,
      CreateDeploymentRequestRequestTypeDef,
      SubDomainSettingTypeDef,
      CreateWebhookRequestRequestTypeDef,
      WebhookTypeDef,
      DeleteAppRequestRequestTypeDef,
      DeleteBackendEnvironmentRequestRequestTypeDef,
      DeleteBranchRequestRequestTypeDef,
      DeleteDomainAssociationRequestRequestTypeDef,
      DeleteJobRequestRequestTypeDef,
      JobSummaryTypeDef,
      DeleteWebhookRequestRequestTypeDef,
      GenerateAccessLogsRequestRequestTypeDef,
      GetAppRequestRequestTypeDef,
      GetArtifactUrlRequestRequestTypeDef,
      GetBackendEnvironmentRequestRequestTypeDef,
      GetBranchRequestRequestTypeDef,
      GetDomainAssociationRequestRequestTypeDef,
      GetJobRequestRequestTypeDef,
      GetWebhookRequestRequestTypeDef,
      StepTypeDef,
      PaginatorConfigTypeDef,
      ListAppsRequestRequestTypeDef,
      ListArtifactsRequestRequestTypeDef,
      ListBackendEnvironmentsRequestRequestTypeDef,
      ListBranchesRequestRequestTypeDef,
      ListDomainAssociationsRequestRequestTypeDef,
      ListJobsRequestRequestTypeDef,
      ListTagsForResourceRequestRequestTypeDef,
      ListWebhooksRequestRequestTypeDef,
      StartDeploymentRequestRequestTypeDef,
      StartJobRequestRequestTypeDef,
      StopJobRequestRequestTypeDef,
      TagResourceRequestRequestTypeDef,
      UntagResourceRequestRequestTypeDef,
      UpdateBranchRequestRequestTypeDef,
      UpdateWebhookRequestRequestTypeDef,
      CreateAppRequestRequestTypeDef,
      UpdateAppRequestRequestTypeDef,
      AppTypeDef,
      CreateBackendEnvironmentResultTypeDef,
      CreateBranchResultTypeDef,
      CreateDeploymentResultTypeDef,
      DeleteBackendEnvironmentResultTypeDef,
      DeleteBranchResultTypeDef,
      GenerateAccessLogsResultTypeDef,
      GetArtifactUrlResultTypeDef,
      GetBackendEnvironmentResultTypeDef,
      GetBranchResultTypeDef,
      ListArtifactsResultTypeDef,
      ListBackendEnvironmentsResultTypeDef,
      ListBranchesResultTypeDef,
      ListTagsForResourceResponseTypeDef,
      UpdateBranchResultTypeDef,
      CreateDomainAssociationRequestRequestTypeDef,
      SubDomainTypeDef,
      UpdateDomainAssociationRequestRequestTypeDef,
      CreateWebhookResultTypeDef,
      DeleteWebhookResultTypeDef,
      GetWebhookResultTypeDef,
      ListWebhooksResultTypeDef,
      UpdateWebhookResultTypeDef,
      DeleteJobResultTypeDef,
      ListJobsResultTypeDef,
      StartDeploymentResultTypeDef,
      StartJobResultTypeDef,
      StopJobResultTypeDef,
      JobTypeDef,
      ListAppsRequestListAppsPaginateTypeDef,
      ListBranchesRequestListBranchesPaginateTypeDef,
      ListDomainAssociationsRequestListDomainAssociationsPaginateTypeDef,
      ListJobsRequestListJobsPaginateTypeDef,
      CreateAppResultTypeDef,
      DeleteAppResultTypeDef,
      GetAppResultTypeDef,
      ListAppsResultTypeDef,
      UpdateAppResultTypeDef,
      DomainAssociationTypeDef,
      GetJobResultTypeDef,
      CreateDomainAssociationResultTypeDef,
      DeleteDomainAssociationResultTypeDef,
      GetDomainAssociationResultTypeDef,
      ListDomainAssociationsResultTypeDef,
      UpdateDomainAssociationResultTypeDef,
  )


  def get_structure() -> AutoBranchCreationConfigTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers a drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from the documentation (blame `botocore` docs if types
    are incorrect).
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [black](https://github.com/psf/black) and
    [isort](https://github.com/PyCQA/isort) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore` and `aiobotocore` libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.session` calls
  - Auto discovery of types for `session.client` and `session.session` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `mypy-boto3-amplify` version is the same as related `boto3` version and follows
  [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amplify/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: b191b4a8f167300a93f8532210ca974e72decd344225ceff3dcf577dc1e90f3f
name: python-mypy-boto3-apigatewayv2
arch: src
version: 1.26.0.post1
epoch: 0
release: 1
summary: Type annotations for boto3.ApiGatewayV2 1.26.0 service generated with mypy-boto3-builder 7.11.10
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c0ba0add-3c0f-418f-8772-77f8a945946d
location_href: 00014291-python-mypy-boto3-apigatewayv2/python-mypy-boto3-apigatewayv2-1.26.0.post1-1.src.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-apigatewayv2"></a>



  [![PyPI - mypy-boto3-apigatewayv2](https://img.shields.io/pypi/v/mypy-boto3-apigatewayv2.svg?color=blue)](https://pypi.org/project/mypy-boto3-apigatewayv2)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-apigatewayv2.svg?color=blue)](https://pypi.org/project/mypy-boto3-apigatewayv2)
  [![Docs](https://img.shields.io/readthedocs/mypy-boto3-builder.svg?color=blue)](https://mypy-boto3-builder.readthedocs.io/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/mypy-boto3-apigatewayv2?color=blue)](https://pypistats.org/packages/mypy-boto3-apigatewayv2)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3.ApiGatewayV2 1.26.0](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigatewayv2.html#ApiGatewayV2)
  service compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated by
  [mypy-boto3-builder 7.11.10](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-apigatewayv2 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_apigatewayv2/).

  See how it helps to find and fix potential bugs:

  ![boto3-stubs demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-apigatewayv2](#mypy-boto3-apigatewayv2)
    - [How to install](#how-to-install)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Typed dictionaries](#typed-dictionaries)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `ApiGatewayV2`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `ApiGatewayV2` service.

  ```bash

  python -m pip install 'boto3-stubs[apigatewayv2]'




  python -m pip install 'boto3-stubs-lite[apigatewayv2]'



  python -m pip install mypy-boto3-apigatewayv2
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-apigatewayv2
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs[apigatewayv2]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[apigatewayv2]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  Install `boto3-stubs-lite[apigatewayv2]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[apigatewayv2]'`
  ```

  Both type checking and code completion should now work. Explicit type
  annotations **are required**.

  Use `boto3-stubs` package instead for implicit type discovery.

  <a id="emacs"></a>



  - Install `boto3-stubs` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[apigatewayv2]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `boto3-stubs`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs[apigatewayv2]` with services you use in your
    environment:

  ```bash
  python -m pip install 'boto3-stubs[apigatewayv2]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs[apigatewayv2]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[apigatewayv2]'`
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs[apigatewayv2]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[apigatewayv2]'
  ```

  Optionally, you can install `boto3-stubs` to `typings` folder.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `ApiGatewayV2Client` provides annotations for `boto3.client("apigatewayv2")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_apigatewayv2 import ApiGatewayV2Client

  client: ApiGatewayV2Client = Session().client("apigatewayv2")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_apigatewayv2.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_apigatewayv2 import ApiGatewayV2Client
  from mypy_boto3_apigatewayv2.paginator import (
      GetApisPaginator,
      GetAuthorizersPaginator,
      GetDeploymentsPaginator,
      GetDomainNamesPaginator,
      GetIntegrationResponsesPaginator,
      GetIntegrationsPaginator,
      GetModelsPaginator,
      GetRouteResponsesPaginator,
      GetRoutesPaginator,
      GetStagesPaginator,
  )

  client: ApiGatewayV2Client = Session().client("apigatewayv2")



  get_apis_paginator: GetApisPaginator = client.get_paginator("get_apis")
  get_authorizers_paginator: GetAuthorizersPaginator = client.get_paginator("get_authorizers")
  get_deployments_paginator: GetDeploymentsPaginator = client.get_paginator("get_deployments")
  get_domain_names_paginator: GetDomainNamesPaginator = client.get_paginator("get_domain_names")
  get_integration_responses_paginator: GetIntegrationResponsesPaginator = client.get_paginator(
      "get_integration_responses"
  )
  get_integrations_paginator: GetIntegrationsPaginator = client.get_paginator("get_integrations")
  get_models_paginator: GetModelsPaginator = client.get_paginator("get_models")
  get_route_responses_paginator: GetRouteResponsesPaginator = client.get_paginator(
      "get_route_responses"
  )
  get_routes_paginator: GetRoutesPaginator = client.get_paginator("get_routes")
  get_stages_paginator: GetStagesPaginator = client.get_paginator("get_stages")
  ```

  <a id="literals"></a>



  `mypy_boto3_apigatewayv2.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  ```python
  from mypy_boto3_apigatewayv2.literals import (
      AuthorizationTypeType,
      AuthorizerTypeType,
      ConnectionTypeType,
      ContentHandlingStrategyType,
      DeploymentStatusType,
      DomainNameStatusType,
      EndpointTypeType,
      GetApisPaginatorName,
      GetAuthorizersPaginatorName,
      GetDeploymentsPaginatorName,
      GetDomainNamesPaginatorName,
      GetIntegrationResponsesPaginatorName,
      GetIntegrationsPaginatorName,
      GetModelsPaginatorName,
      GetRouteResponsesPaginatorName,
      GetRoutesPaginatorName,
      GetStagesPaginatorName,
      IntegrationTypeType,
      JSONYAMLType,
      LoggingLevelType,
      OAS30Type,
      PassthroughBehaviorType,
      ProtocolTypeType,
      SecurityPolicyType,
      VpcLinkStatusType,
      VpcLinkVersionType,
      ApiGatewayV2ServiceName,
      ServiceName,
      ResourceServiceName,
      PaginatorName,
      RegionName,
  )


  def check_value(value: AuthorizationTypeType) -> bool:
      ...
  ```

  <a id="typed-dictionaries"></a>



  `mypy_boto3_apigatewayv2.type_defs` module contains structures and shapes
  assembled to typed dictionaries for additional type checking.

  ```python
  from mypy_boto3_apigatewayv2.type_defs import (
      AccessLogSettingsTypeDef,
      ApiMappingTypeDef,
      CorsTypeDef,
      JWTConfigurationTypeDef,
      CreateApiMappingRequestRequestTypeDef,
      ResponseMetadataTypeDef,
      CreateDeploymentRequestRequestTypeDef,
      DomainNameConfigurationTypeDef,
      MutualTlsAuthenticationInputTypeDef,
      MutualTlsAuthenticationTypeDef,
      TlsConfigInputTypeDef,
      CreateIntegrationResponseRequestRequestTypeDef,
      TlsConfigTypeDef,
      CreateModelRequestRequestTypeDef,
      ParameterConstraintsTypeDef,
      RouteSettingsTypeDef,
      CreateVpcLinkRequestRequestTypeDef,
      DeleteAccessLogSettingsRequestRequestTypeDef,
      DeleteApiMappingRequestRequestTypeDef,
      DeleteApiRequestRequestTypeDef,
      DeleteAuthorizerRequestRequestTypeDef,
      DeleteCorsConfigurationRequestRequestTypeDef,
      DeleteDeploymentRequestRequestTypeDef,
      DeleteDomainNameRequestRequestTypeDef,
      DeleteIntegrationRequestRequestTypeDef,
      DeleteIntegrationResponseRequestRequestTypeDef,
      DeleteModelRequestRequestTypeDef,
      DeleteRouteRequestParameterRequestRequestTypeDef,
      DeleteRouteRequestRequestTypeDef,
      DeleteRouteResponseRequestRequestTypeDef,
      DeleteRouteSettingsRequestRequestTypeDef,
      DeleteStageRequestRequestTypeDef,
      DeleteVpcLinkRequestRequestTypeDef,
      DeploymentTypeDef,
      ExportApiRequestRequestTypeDef,
      GetApiMappingRequestRequestTypeDef,
      GetApiMappingsRequestRequestTypeDef,
      GetApiRequestRequestTypeDef,
      PaginatorConfigTypeDef,
      GetApisRequestRequestTypeDef,
      GetAuthorizerRequestRequestTypeDef,
      GetAuthorizersRequestRequestTypeDef,
      GetDeploymentRequestRequestTypeDef,
      GetDeploymentsRequestRequestTypeDef,
      GetDomainNameRequestRequestTypeDef,
      GetDomainNamesRequestRequestTypeDef,
      GetIntegrationRequestRequestTypeDef,
      GetIntegrationResponseRequestRequestTypeDef,
      GetIntegrationResponsesRequestRequestTypeDef,
      IntegrationResponseTypeDef,
      GetIntegrationsRequestRequestTypeDef,
      GetModelRequestRequestTypeDef,
      GetModelTemplateRequestRequestTypeDef,
      GetModelsRequestRequestTypeDef,
      ModelTypeDef,
      GetRouteRequestRequestTypeDef,
      GetRouteResponseRequestRequestTypeDef,
      GetRouteResponsesRequestRequestTypeDef,
      GetRoutesRequestRequestTypeDef,
      GetStageRequestRequestTypeDef,
      GetStagesRequestRequestTypeDef,
      GetTagsRequestRequestTypeDef,
      GetVpcLinkRequestRequestTypeDef,
      GetVpcLinksRequestRequestTypeDef,
      VpcLinkTypeDef,
      ImportApiRequestRequestTypeDef,
      ReimportApiRequestRequestTypeDef,
      ResetAuthorizersCacheRequestRequestTypeDef,
      TagResourceRequestRequestTypeDef,
      UntagResourceRequestRequestTypeDef,
      UpdateApiMappingRequestRequestTypeDef,
      UpdateDeploymentRequestRequestTypeDef,
      UpdateIntegrationResponseRequestRequestTypeDef,
      UpdateModelRequestRequestTypeDef,
      UpdateVpcLinkRequestRequestTypeDef,
      ApiTypeDef,
      CreateApiRequestRequestTypeDef,
      UpdateApiRequestRequestTypeDef,
      AuthorizerTypeDef,
      CreateAuthorizerRequestRequestTypeDef,
      UpdateAuthorizerRequestRequestTypeDef,
      CreateApiMappingResponseTypeDef,
      CreateApiResponseTypeDef,
      CreateAuthorizerResponseTypeDef,
      CreateDeploymentResponseTypeDef,
      CreateIntegrationResponseResponseTypeDef,
      CreateModelResponseTypeDef,
      CreateVpcLinkResponseTypeDef,
      EmptyResponseMetadataTypeDef,
      ExportApiResponseTypeDef,
      GetApiMappingResponseTypeDef,
      GetApiMappingsResponseTypeDef,
      GetApiResponseTypeDef,
      GetAuthorizerResponseTypeDef,
      GetDeploymentResponseTypeDef,
      GetIntegrationResponseResponseTypeDef,
      GetModelResponseTypeDef,
      GetModelTemplateResponseTypeDef,
      GetTagsResponseTypeDef,
      GetVpcLinkResponseTypeDef,
      ImportApiResponseTypeDef,
      ReimportApiResponseTypeDef,
      UpdateApiMappingResponseTypeDef,
      UpdateApiResponseTypeDef,
      UpdateAuthorizerResponseTypeDef,
      UpdateDeploymentResponseTypeDef,
      UpdateIntegrationResponseResponseTypeDef,
      UpdateModelResponseTypeDef,
      UpdateVpcLinkResponseTypeDef,
      CreateDomainNameRequestRequestTypeDef,
      UpdateDomainNameRequestRequestTypeDef,
      CreateDomainNameResponseTypeDef,
      DomainNameTypeDef,
      GetDomainNameResponseTypeDef,
      UpdateDomainNameResponseTypeDef,
      CreateIntegrationRequestRequestTypeDef,
      UpdateIntegrationRequestRequestTypeDef,
      CreateIntegrationResultTypeDef,
      GetIntegrationResultTypeDef,
      IntegrationTypeDef,
      UpdateIntegrationResultTypeDef,
      CreateRouteRequestRequestTypeDef,
      CreateRouteResponseRequestRequestTypeDef,
      CreateRouteResponseResponseTypeDef,
      CreateRouteResultTypeDef,
      GetRouteResponseResponseTypeDef,
      GetRouteResultTypeDef,
      RouteResponseTypeDef,
      RouteTypeDef,
      UpdateRouteRequestRequestTypeDef,
      UpdateRouteResponseRequestRequestTypeDef,
      UpdateRouteResponseResponseTypeDef,
      UpdateRouteResultTypeDef,
      CreateStageRequestRequestTypeDef,
      CreateStageResponseTypeDef,
      GetStageResponseTypeDef,
      StageTypeDef,
      UpdateStageRequestRequestTypeDef,
      UpdateStageResponseTypeDef,
      GetDeploymentsResponseTypeDef,
      GetApisRequestGetApisPaginateTypeDef,
      GetAuthorizersRequestGetAuthorizersPaginateTypeDef,
      GetDeploymentsRequestGetDeploymentsPaginateTypeDef,
      GetDomainNamesRequestGetDomainNamesPaginateTypeDef,
      GetIntegrationResponsesRequestGetIntegrationResponsesPaginateTypeDef,
      GetIntegrationsRequestGetIntegrationsPaginateTypeDef,
      GetModelsRequestGetModelsPaginateTypeDef,
      GetRouteResponsesRequestGetRouteResponsesPaginateTypeDef,
      GetRoutesRequestGetRoutesPaginateTypeDef,
      GetStagesRequestGetStagesPaginateTypeDef,
      GetIntegrationResponsesResponseTypeDef,
      GetModelsResponseTypeDef,
      GetVpcLinksResponseTypeDef,
      GetApisResponseTypeDef,
      GetAuthorizersResponseTypeDef,
      GetDomainNamesResponseTypeDef,
      GetIntegrationsResponseTypeDef,
      GetRouteResponsesResponseTypeDef,
      GetRoutesResponseTypeDef,
      GetStagesResponseTypeDef,
  )


  def get_structure() -> AccessLogSettingsTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers a drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from the documentation (blame `botocore` docs if types
    are incorrect).
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [black](https://github.com/psf/black) and
    [isort](https://github.com/PyCQA/isort) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore` and `aiobotocore` libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.session` calls
  - Auto discovery of types for `session.client` and `session.session` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `mypy-boto3-apigatewayv2` version is the same as related `boto3` version and
  follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_apigatewayv2/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


