# packages

pkgId: 9eeca3fb3134c56336c06205898cb74cf89e7ab902f343488fbdebf683ce82fe
name: rh-python36-itsdangerous
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Various helpers to pass data to untrusted environments and back.
url: https://palletsprojects.com/p/itsdangerous/
rpm_license: BSD
rpm_vendor: Pallets Team <contact@palletsprojects.com>
rpm_group: Development/Libraries
rpm_buildhost: 13c1a1e7bed747068eda30c9ececd9f7
rpm_sourcerpm: rh-python36-itsdangerous-1.1.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887848-rh-python36-itsdangerous/rh-python36-itsdangerous-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  itsdangerous
  ============

  ... so better sign this

  Various helpers to pass data to untrusted environments and to get it
  back safe and sound. Data is cryptographically signed to ensure that a
  token has not been tampered with.

  It's possible to customize how data is serialized. Data is compressed as
  needed. A timestamp can be added and verified automatically while
  loading a token.


  Installing
  ----------

  Install and update using `pip`_:

  .. code-block:: text

      pip install -U itsdangerous

  .. _pip: https://pip.pypa.io/en/stable/quickstart/


  A Simple Example
  ----------------

  Here's how you could generate a token for transmitting a user's id and
  name between web requests.

  .. code-block:: python

      from itsdangerous import URLSafeSerializer
      auth_s = URLSafeSerializer("secret key", "auth")
      token = auth_s.dumps({"id": 5, "name": "itsdangerous"})

      print(token)
      

      data = auth_s.loads(token)
      print(data["name"])
      


  Donate
  ------

  The Pallets organization develops and supports itsdangerous and other
  popular packages. In order to grow the community of contributors and
  users, and allow the maintainers to devote more time to the projects,
  `please donate today`_.

  .. _please donate today: https://palletsprojects.com/donate


  Links
  -----

  *   Website: https://palletsprojects.com/p/itsdangerous/
  *   Documentation: https://itsdangerous.palletsprojects.com/
  *   License: `BSD <https://github.com/pallets/itsdangerous/blob/master/LICENSE.rst>`_
  *   Releases: https://pypi.org/project/itsdangerous/
  *   Code: https://github.com/pallets/itsdangerous
  *   Issue tracker: https://github.com/pallets/itsdangerous/issues
  *   Test status: https://travis-ci.org/pallets/itsdangerous
  *   Test coverage: https://codecov.io/gh/pallets/itsdangerous


pkgId: 159b7ed0e4fdaa7af0e2b300440136eb81172794af95b9eddbdfe83329a9fc28
name: rh-python36-jaraco.classes
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: Utility functions for Python class constructs
url: https://github.com/jaraco/jaraco.classes
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: aadecafde0e24f709f7cbf9549ef9a4a
rpm_sourcerpm: rh-python36-jaraco.classes-3.1.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311570-rh-python36-jaraco.classes/rh-python36-jaraco.classes-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/jaraco.classes.svg
     :target: https://pypi.org/project/jaraco.classes

  .. image:: https://img.shields.io/pypi/pyversions/jaraco.classes.svg

  .. image:: https://img.shields.io/travis/jaraco/jaraco.classes/master.svg
     :target: http://travis-ci.org/jaraco/jaraco.classes

  .. image:: https://readthedocs.org/projects/skeleton/badge/?version=latest
     :target: http://skeleton.readthedocs.io/en/latest/?badge=latest


pkgId: 94c2a2c13bc61db15fbdb862733e05407b7b81fa7c8ab79163255af7be58e0f4
name: rh-python36-jaraco.collections
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: jaraco.collections
url: https://github.com/jaraco/jaraco.collections
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: 928823b250734603bd5540bb24ae657e
rpm_sourcerpm: rh-python36-jaraco.collections-3.0.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311572-rh-python36-jaraco.collections/rh-python36-jaraco.collections-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/jaraco.collections.svg
     :target: https://pypi.io/project/jaraco.collections

  .. image:: https://img.shields.io/pypi/pyversions/jaraco.collections.svg

  .. image:: https://img.shields.io/travis/jaraco/jaraco.collections/master.svg
     :target: https://travis-ci.org/jaraco/jaraco.collections

  .. .. image:: https://img.shields.io/appveyor/ci/jaraco/skeleton/master.svg
  ..    :target: https://ci.appveyor.com/project/jaraco/skeleton/branch/master

  .. image:: https://readthedocs.org/projects/jaracocollections/badge/?version=latest
     :target: https://jaracocollections.readthedocs.io/en/latest/?badge=latest

  Models and classes to supplement the stdlib 'collections' module.

  RangeMap
  --------

  A dictionary-like object that maps a range of values to a given value.


pkgId: 2dd31664ea8ca6b00a5e35239add60470c620d1a7580ca91d4498d137a36a78f
name: rh-python36-jaraco.functools
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: jaraco.functools
url: https://github.com/jaraco/jaraco.functools
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: 6b5aaecfae27412ea1640a5c531a3580
rpm_sourcerpm: rh-python36-jaraco.functools-3.0.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143890-rh-python36-jaraco.functools/rh-python36-jaraco.functools-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/jaraco.functools.svg
     :target: https://pypi.org/project/jaraco.functools

  .. image:: https://img.shields.io/pypi/pyversions/jaraco.functools.svg

  .. image:: https://img.shields.io/travis/jaraco/jaraco.functools/master.svg
     :target: http://travis-ci.org/jaraco/jaraco.functools

  .. image:: https://readthedocs.org/projects/jaracofunctools/badge/?version=latest
     :target: http://jaracofunctools.readthedocs.io/en/latest/?badge=latest

  Additional functools in the spirit of stdlib's functools.


pkgId: d3c2e5a083bb98255aa7f5dd24c60a8d4bf15cf4d2ef78cd66cbae442350fef7
name: rh-python36-jaraco.itertools
arch: noarch
version: 4.4.2
epoch: 0
release: 1
summary: jaraco.itertools
url: https://github.com/jaraco/jaraco.itertools
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: 397473a7a12e4560bb7c9fdb6f8dc758
rpm_sourcerpm: rh-python36-jaraco.itertools-4.4.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00914999-rh-python36-jaraco.itertools/rh-python36-jaraco.itertools-4.4.2-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/jaraco.itertools.svg
     :target: https://pypi.org/project/jaraco.itertools

  .. image:: https://img.shields.io/pypi/pyversions/jaraco.itertools.svg

  .. image:: https://img.shields.io/travis/jaraco/jaraco.itertools/master.svg
     :target: https://travis-ci.org/jaraco/jaraco.itertools

  .. .. image:: https://img.shields.io/appveyor/ci/jaraco/jaraco.itertools/master.svg
  ..    :target: https://ci.appveyor.com/project/jaraco/jaraco.itertools/branch/master

  .. image:: https://readthedocs.org/projects/jaracoitertools/badge/?version=latest
     :target: https://jaracoitertools.readthedocs.io/en/latest/?badge=latest


pkgId: 3f57ca598c127097f87131d3eb9f1c636be469b22c734cd5985ec571591d883f
name: rh-python36-jaraco.logging
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: jaraco.logging
url: https://github.com/jaraco/jaraco.logging
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: cc190ca2639b421aaf1d56a58e23b0f3
rpm_sourcerpm: rh-python36-jaraco.logging-3.0.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311573-rh-python36-jaraco.logging/rh-python36-jaraco.logging-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/jaraco.logging.svg
     :target: https://pypi.org/project/jaraco.logging

  .. image:: https://img.shields.io/pypi/pyversions/jaraco.logging.svg

  .. image:: https://img.shields.io/travis/jaraco/jaraco.logging/master.svg
     :target: http://travis-ci.org/jaraco/jaraco.logging

  .. image:: https://readthedocs.org/projects/jaracologging/badge/?version=latest
     :target: https://jaracologging.readthedocs.io/en/latest/?badge=latest

  Argument Parsing
  ================

  Quickly solicit log level info from command-line parameters::

      parser = argparse.ArgumentParser()
      jaraco.logging.add_arguments(parser)
      args = parser.parse_args()
      jaraco.logging.setup(args)


pkgId: 7f51b97f3fe191c42cf30bb21272aef57ddc5cf173d8cf30262de56ecc8c3da0
name: rh-python36-jaraco.stream
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: routines for dealing with data streams
url: https://github.com/jaraco/jaraco.stream
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: c9aa9ef16a414261b877f78e4fc65496
rpm_sourcerpm: rh-python36-jaraco.stream-3.0.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143535-rh-python36-jaraco.stream/rh-python36-jaraco.stream-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/jaraco.stream.svg
     :target: https://pypi.org/project/jaraco.stream

  .. image:: https://img.shields.io/pypi/pyversions/jaraco.stream.svg

  .. image:: https://img.shields.io/pypi/dm/jaraco.stream.svg

  .. image:: https://img.shields.io/travis/jaraco/jaraco.stream/master.svg
     :target: http://travis-ci.org/jaraco/jaraco.stream

  Routines for handling streaming data, including a
  set of generators for loading gzip data on the fly.

  License
  =======

  License is indicated in the project metadata (typically one or more
  of the Trove classifiers). For more details, see `this explanation
  <https://github.com/jaraco/skeleton/issues/1>`_.


pkgId: 62941963dd9160685741626d4b7bdd4e12cfe9ecf49c8654c7a7e3103f60ab28
name: rh-python36-jaraco.text
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: jaraco.text
url: https://github.com/jaraco/jaraco.text
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: e87f749554414172a3c7442337d9634d
rpm_sourcerpm: rh-python36-jaraco.text-3.2.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143802-rh-python36-jaraco.text/rh-python36-jaraco.text-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/jaraco.text.svg
     :target: https://pypi.org/project/jaraco.text

  .. image:: https://img.shields.io/pypi/pyversions/jaraco.text.svg

  .. image:: https://img.shields.io/travis/jaraco/jaraco.text/master.svg
     :target: https://travis-ci.org/jaraco/jaraco.text

  .. .. image:: https://img.shields.io/appveyor/ci/jaraco/skeleton/master.svg
  ..    :target: https://ci.appveyor.com/project/jaraco/skeleton/branch/master

  .. .. image:: https://readthedocs.org/projects/skeleton/badge/?version=latest
  ..    :target: https://skeleton.readthedocs.io/en/latest/?badge=latest


pkgId: b7a8ac1b61dc2e0116f9f0ed895fc18852a4f43fad5fef762280bd8b477f3272
name: rh-python36-jmespath
arch: noarch
version: 0.9.4
epoch: 0
release: 1
summary: JSON Matching Expressions
url: https://github.com/jmespath/jmespath.py
rpm_license: MIT
rpm_vendor: James Saryerwinnie <js@jamesls.com>
rpm_group: Development/Libraries
rpm_buildhost: b8abd5646b5f46a1b5ef6203d74c4dd8
rpm_sourcerpm: rh-python36-jmespath-0.9.4-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00877828-rh-python36-jmespath/rh-python36-jmespath-0.9.4-1.noarch.rpm
checksum_type: sha256
description:
  JMESPath
  ========


  .. image:: https://badges.gitter.im/Join Chat.svg
     :target: https://gitter.im/jmespath/chat


  .. image:: https://secure.travis-ci.org/jmespath/jmespath.py.png?branch=develop
     :target: http://travis-ci.org/jmespath/jmespath.py


  .. image:: https://codecov.io/github/jmespath/jmespath.py/coverage.svg?branch=develop
      :target: https://codecov.io/github/jmespath/jmespath.py?branch=develop


  JMESPath (pronounced "james path") allows you to declaratively specify how to
  extract elements from a JSON document.

  For example, given this document::

      {"foo": {"bar": "baz"}}

  The jmespath expression ``foo.bar`` will return "baz".

  JMESPath also supports:

  Referencing elements in a list.  Given the data::

      {"foo": {"bar": ["one", "two"]}}

  The expression: ``foo.bar[0]`` will return "one".
  You can also reference all the items in a list using the ``*``
  syntax::

     {"foo": {"bar": [{"name": "one"}, {"name": "two"}]}}

  The expression: ``foo.bar[*].name`` will return ["one", "two"].
  Negative indexing is also supported (-1 refers to the last element
  in the list).  Given the data above, the expression
  ``foo.bar[-1].name`` will return "two".

  The ``*`` can also be used for hash types::

     {"foo": {"bar": {"name": "one"}, "baz": {"name": "two"}}}

  The expression: ``foo.*.name`` will return ["one", "two"].


  API
  ===

  The ``jmespath.py`` library has two functions
  that operate on python data structures.  You can use ``search``
  and give it the jmespath expression and the data:

  .. code:: python

      >>> import jmespath
      >>> path = jmespath.search('foo.bar', {'foo': {'bar': 'baz'}})
      'baz'

  Similar to the ``re`` module, you can use the ``compile`` function
  to compile the JMESPath expression and use this parsed expression
  to perform repeated searches:

  .. code:: python

      >>> import jmespath
      >>> expression = jmespath.compile('foo.bar')
      >>> expression.search({'foo': {'bar': 'baz'}})
      'baz'
      >>> expression.search({'foo': {'bar': 'other'}})
      'other'

  This is useful if you're going to use the same jmespath expression to
  search multiple documents.  This avoids having to reparse the
  JMESPath expression each time you search a new document.

  Options
  -------

  You can provide an instance of ``jmespath.Options`` to control how
  a JMESPath expression is evaluated.  The most common scenario for
  using an ``Options`` instance is if you want to have ordered output
  of your dict keys.  To do this you can use either of these options:

  .. code:: python

      >>> import jmespath
      >>> jmespath.search('{a: a, b: b},
      ...                 mydata,
      ...                 jmespath.Options(dict_cls=collections.OrderedDict))


      >>> import jmespath
      >>> parsed = jmespath.compile('{a: a, b: b}')
      >>> parsed.search('{a: a, b: b},
      ...               mydata,
      ...               jmespath.Options(dict_cls=collections.OrderedDict))


  Custom Functions
  ~~~~~~~~~~~~~~~~

  The JMESPath language has numerous
  `built-in functions
  <http://jmespath.org/specification.html#built-in-functions>`__, but it is
  also possible to add your own custom functions.  Keep in mind that
  custom function support in jmespath.py is experimental and the API may
  change based on feedback.

  **If you have a custom function that you've found useful, consider submitting
  it to jmespath.site and propose that it be added to the JMESPath language.**
  You can submit proposals
  `here <https://github.com/jmespath/jmespath.site/issues>`__.

  To create custom functions:

  * Create a subclass of ``jmespath.functions.Functions``.
  * Create a method with the name ``_func_<your function name>``.
  * Apply the ``jmespath.functions.signature`` decorator that indicates
    the expected types of the function arguments.
  * Provide an instance of your subclass in a ``jmespath.Options`` object.

  Below are a few examples:

  .. code:: python

      import jmespath
      from jmespath import functions

      
      
      
      
      class CustomFunctions(functions.Functions):

          
          
          
          
          
          
          @functions.signature({'types': ['string']})
          def _func_unique_letters(self, s):
              
              
              return ''.join(sorted(set(s)))

          
          
          
          @functions.signature({'types': ['number']}, {'types': ['number']})
          def _func_my_add(self, x, y):
              return x + y

      
      options = jmespath.Options(custom_functions=CustomFunctions())

      
      
      print(
          jmespath.search(
              'my_add(`1`, `2`)', {}, options=options)
      )

      
      print(
          jmespath.search(
              'foo.bar | unique_letters(@)',
              {'foo': {'bar': 'ccbbadd'}},
              options=options)
      )

  Again, if you come up with useful functions that you think make
  sense in the JMESPath language (and make sense to implement in all
  JMESPath libraries, not just python), please let us know at
  `jmespath.site <https://github.com/jmespath/jmespath.site/issues>`__.


  Specification
  =============

  If you'd like to learn more about the JMESPath language, you can check out
  the `JMESPath tutorial <http://jmespath.org/tutorial.html>`__.  Also check
  out the `JMESPath examples page <http://jmespath.org/examples.html>`__ for
  examples of more complex jmespath queries.

  The grammar is specified using ABNF, as described in
  `RFC4234 <http://www.ietf.org/rfc/rfc4234.txt>`_.
  You can find the most up to date
  `grammar for JMESPath here <http://jmespath.org/specification.html#grammar>`__.

  You can read the full
  `JMESPath specification here <http://jmespath.org/specification.html>`__.


  Testing
  =======

  In addition to the unit tests for the jmespath modules,
  there is a ``tests/compliance`` directory that contains
  .json files with test cases.  This allows other implementations
  to verify they are producing the correct output.  Each json
  file is grouped by feature.


  Discuss
  =======

  Join us on our `Gitter channel <https://gitter.im/jmespath/chat>`__
  if you want to chat or if you have any questions.


pkgId: 434ead743a7161d00c1316ffbd2f3f1fe413c9e18d1823998a95b17646b68269
name: rh-python36-jsonpatch
arch: noarch
version: 1.25
epoch: 0
release: 1
summary: Apply JSON-Patches (RFC 6902)
url: https://github.com/stefankoegl/python-json-patch
rpm_license: Modified BSD License
rpm_vendor: Stefan Kögl <stefan@skoegl.net>
rpm_group: Development/Libraries
rpm_buildhost: 07b405f2ecb0434caad5cf90a2a8783a
rpm_sourcerpm: rh-python36-jsonpatch-1.25-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01225014-rh-python36-jsonpatch/rh-python36-jsonpatch-1.25-1.noarch.rpm
checksum_type: sha256
description:
  python-json-patch [![Build Status](https://secure.travis-ci.org/stefankoegl/python-json-patch.png?branch=master)](https://travis-ci.org/stefankoegl/python-json-patch) [![Coverage Status](https://coveralls.io/repos/stefankoegl/python-json-patch/badge.png?branch=master)](https://coveralls.io/r/stefankoegl/python-json-patch?branch=master)
  =================
  Applying JSON Patches in Python
  -------------------------------

  Library to apply JSON Patches according to
  [RFC 6902](http://tools.ietf.org/html/rfc6902)

  See Sourcecode for Examples

  * Website: https://github.com/stefankoegl/python-json-patch
  * Repository: https://github.com/stefankoegl/python-json-patch.git
  * Documentation: https://python-json-patch.readthedocs.org/
  * PyPI: https://pypi.python.org/pypi/jsonpatch
  * Travis-CI: https://travis-ci.org/stefankoegl/python-json-patch
  * Coveralls: https://coveralls.io/r/stefankoegl/python-json-patch

  Running external tests
  ----------------------
  To run external tests (such as those from https://github.com/json-patch/json-patch-tests) use ext_test.py

      ./ext_tests.py ../json-patch-tests/tests.json


pkgId: db384fac81341e45c8a9c4b872733092c5a4269e1b55c1c72115d37a7afcdedf
name: rh-python36-jsonpointer
arch: noarch
version: 2.0
epoch: 0
release: 1
summary: Identify specific nodes in a JSON document (RFC 6901)
url: https://github.com/stefankoegl/python-json-pointer
rpm_license: Modified BSD License
rpm_vendor: Stefan Kögl <stefan@skoegl.net>
rpm_group: Development/Libraries
rpm_buildhost: ef61957dea984e768f50595759413701
rpm_sourcerpm: rh-python36-jsonpointer-2.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850806-rh-python36-jsonpointer/rh-python36-jsonpointer-2.0-1.noarch.rpm
checksum_type: sha256
description:
  python-json-pointer
  ===================

  [![PyPI version](https://img.shields.io/pypi/v/jsonpointer.svg)](https://pypi.python.org/pypi/jsonpointer/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/jsonpointer.svg)](https://pypi.python.org/pypi/jsonpointer/)
  [![Build Status](https://travis-ci.org/stefankoegl/python-json-pointer.png?branch=master)](https://travis-ci.org/stefankoegl/python-json-pointer)
  [![Coverage Status](https://coveralls.io/repos/stefankoegl/python-json-pointer/badge.png?branch=master)](https://coveralls.io/r/stefankoegl/python-json-pointer?branch=master)


  Resolve JSON Pointers in Python
  -------------------------------

  Library to resolve JSON Pointers according to
  [RFC 6901](http://tools.ietf.org/html/rfc6901)

  See source code for examples
  * Website: https://github.com/stefankoegl/python-json-pointer
  * Repository: https://github.com/stefankoegl/python-json-pointer.git
  * Documentation: https://python-json-pointer.readthedocs.org/
  * PyPI: https://pypi.python.org/pypi/jsonpointer
  * Travis CI: https://travis-ci.org/stefankoegl/python-json-pointer
  * Coveralls: https://coveralls.io/r/stefankoegl/python-json-pointer


pkgId: 783bc89901e28c788b3acc593d1f6b5986f06b0f2e4d1703c182624e668b647e
name: rh-python36-jsonschema
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: An implementation of JSON Schema validation for Python
url: http://github.com/Julian/jsonschema
rpm_license: MIT
rpm_vendor: Julian Berman <Julian@GrayVines.com>
rpm_group: Development/Libraries
rpm_buildhost: a590be96f3a249edbc953a297c2e0a0a
rpm_sourcerpm: rh-python36-jsonschema-3.2.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143804-rh-python36-jsonschema/rh-python36-jsonschema-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/jsonschema.svg
      :target: https://pypi.python.org/pypi/jsonschema
  .. image:: https://travis-ci.org/Julian/jsonschema.svg?branch=master
      :target: https://travis-ci.org/Julian/jsonschema
  .. image:: https://img.shields.io/pypi/l/jsonschema.svg
      :target: https://pypi.python.org/pypi/jsonschema

  ==========
  jsonschema
  ==========

  ``jsonschema`` is an implementation of `JSON Schema <http://json-schema.org>`_
  for Python (supporting 2.7+ including Python 3).

  .. code-block:: python

      >>> from jsonschema import validate

      >>> # A sample schema, like what we'd get from json.load()
      >>> schema = {
      ...     "type" : "object",
      ...     "properties" : {
      ...         "price" : {"type" : "number"},
      ...         "name" : {"type" : "string"},
      ...     },
      ... }

      >>> # If no exception is raised by validate(), the instance is valid.
      >>> validate({"name" : "Eggs", "price" : 34.99}, schema)

      >>> validate(
      ...     {"name" : "Eggs", "price" : "Invalid"}, schema
      ... )                                   # doctest: +IGNORE_EXCEPTION_DETAIL
      Traceback (most recent call last):
          ...
      ValidationError: 'Invalid' is not of type 'number'

  It can also be used from console:

  .. code-block:: bash

      $ jsonschema -i sample.json sample.schema

  Features
  --------

  * Full support for
    `Draft 3 <https://python-jsonschema.readthedocs.io/en/latest/validate/#jsonschema.Draft3Validator>`_
    **and** `Draft 4 <https://python-jsonschema.readthedocs.io/en/latest/validate/#jsonschema.Draft4Validator>`_
    of the schema.

  * `Lazy validation <https://python-jsonschema.readthedocs.io/en/latest/validate/#jsonschema.IValidator.iter_errors>`_
    that can iteratively report *all* validation errors.

  * Small and extensible

  * `Programmatic querying <https://python-jsonschema.readthedocs.io/en/latest/errors/#module-jsonschema>`_
    of which properties or items failed validation.


  Release Notes
  -------------

  Version 2.5.0 is mainly a performance release. The interface for `RefResolver`
  was extended to add methods that improve performance on CPython.

  Support for custom `RefResolver` objects with the legacy interface should *not*
  be affected. If you notice something amiss please file an issue ticket.


  Running the Test Suite
  ----------------------

  If you have ``tox`` installed (perhaps via ``pip install tox`` or your
  package manager), running``tox`` in the directory of your source checkout will
  run ``jsonschema``'s test suite on all of the versions of Python ``jsonschema``
  supports. Note that you'll need to have all of those versions installed in
  order to run the tests on each of them, otherwise ``tox`` will skip (and fail)
  the tests on that version.

  Of course you're also free to just run the tests on a single version with your
  favorite test runner. The tests live in the ``jsonschema.tests`` package.


  Community
  ---------

  There's a `mailing list <https://groups.google.com/forum/#!forum/jsonschema>`_
  for this implementation on Google Groups.

  Please join, and feel free to send questions there.


  Contributing
  ------------

  I'm Julian Berman.

  ``jsonschema`` is on `GitHub <http://github.com/Julian/jsonschema>`_.

  Get in touch, via GitHub or otherwise, if you've got something to contribute,
  it'd be most welcome!

  You can also generally find me on Freenode (nick: ``tos9``) in various
  channels, including ``#python``.

  If you feel overwhelmingly grateful, you can woo me with beer money on
  `Gittip <https://www.gittip.com/Julian/>`_ or via Google Wallet with the email
  in my GitHub profile.


pkgId: b6cdc85a26fea3f10fce7debad948e15b6ff8351a53af444fa55811bb7ae1887
name: rh-python36-junit-xml
arch: noarch
version: 1.8
epoch: 0
release: 1
summary: Creates JUnit XML test result documents that can be read by tools such as Jenkins
url: https://github.com/kyrus/python-junit-xml
rpm_license: MIT
rpm_vendor: Brian Beyer <brian@kyr.us>
rpm_group: Development/Libraries
rpm_buildhost: 718759af52074f1988343b188477ddd5
rpm_sourcerpm: rh-python36-junit-xml-1.8-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887818-rh-python36-junit-xml/rh-python36-junit-xml-1.8-1.noarch.rpm
checksum_type: sha256
description:
  python-junit-xml
  ================
  .. image:: https://travis-ci.org/kyrus/python-junit-xml.png?branch=master

  About
  -----

  A Python module for creating JUnit XML test result documents that can be
  read by tools such as Jenkins. If you are ever working with test tool or
  test suite written in Python and want to take advantage of Jenkins'
  pretty graphs and test reporting capabilities, this module will let you
  generate the XML test reports.

  *As there is no definitive Jenkins JUnit XSD that I could find, the XML
  documents created by this module support a schema based on Google
  searches and the Jenkins JUnit XML reader source code. File a bug if
  something doesn't work like you expect it to.*

  Installation
  ------------

  Install using pip or easy_install:

  ::

  	pip install junit-xml
  	or
  	easy_install junit-xml

  You can also clone the Git repository from Github and install it manually:

  ::

      git clone https://github.com/kyrus/python-junit-xml.git
      python setup.py install

  Using
  -----

  Create a test suite, add a test case, and print it to the screen:

  .. code-block:: python

      from junit_xml import TestSuite, TestCase

      test_cases = [TestCase('Test1', 'some.class.name', 123.345, 'I am stdout!', 'I am stderr!')]
      ts = TestSuite("my test suite", test_cases)
      
      print(TestSuite.to_xml_string([ts]))

  Produces the following output

  .. code-block:: xml

      <?xml version="1.0" ?>
      <testsuites>
          <testsuite errors="0" failures="0" name="my test suite" tests="1">
              <testcase classname="some.class.name" name="Test1" time="123.345000">
                  <system-out>
                      I am stdout!
                  </system-out>
                  <system-err>
                      I am stderr!
                  </system-err>
              </testcase>
          </testsuite>
      </testsuites>

  Writing XML to a file:

  .. code-block:: python

      
      with open('output.xml', 'w') as f:
          TestSuite.to_file(f, [ts], prettyprint=False)

  See the docs and unit tests for more examples.

  NOTE: Unicode characters identified as "illegal or discouraged" are automatically
  stripped from the XML string or file.

  Running the tests
  -----------------

  ::

      
      pip install tox
      tox


pkgId: d73f2549b9c04f4b751f6e3396d3f5403e6ab0ff26765ac4aae0499f3087b987
name: rh-python36-keyring
arch: noarch
version: 15.1.0
epoch: 0
release: 1
summary: Store and access your passwords safely.
url: https://github.com/jaraco/keyring
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: 5bfb6ee411724e23bbf0165574ffded0
rpm_sourcerpm: rh-python36-keyring-15.1.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850807-rh-python36-keyring/rh-python36-keyring-15.1.0-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/keyring.svg
     :target: https://pypi.org/project/keyring

  .. image:: https://img.shields.io/pypi/pyversions/keyring.svg

  .. image:: https://img.shields.io/travis/jaraco/keyring/master.svg
     :target: https://travis-ci.org/jaraco/keyring

  .. .. image:: https://img.shields.io/appveyor/ci/jaraco/keyring/master.svg
  ..    :target: https://ci.appveyor.com/project/jaraco/keyring/branch/master

  .. image:: https://readthedocs.org/projects/keyring/badge/?version=latest
     :target: https://keyring.readthedocs.io/en/latest/?badge=latest

  =======================================
  Installing and Using Python Keyring Lib
  =======================================

  .. contents:: **Table of Contents**

  ---------------------------
  What is Python keyring lib?
  ---------------------------

  The Python keyring lib provides an easy way to access the system keyring service
  from python. It can be used in any application that needs safe password storage.

  The keyring library is licensed under both the `MIT license
  <http://opensource.org/licenses/MIT>`_ and the PSF license.

  These recommended keyring backends are supported by the Python keyring lib:

  * macOS `Keychain
    <https://en.wikipedia.org/wiki/Keychain_%28software%29>`_
  * Freedesktop `Secret Service
    <http://standards.freedesktop.org/secret-service/>`_ supports many DE including
    GNOME (requires `secretstorage <https://pypi.python.org/pypi/secretstorage>`_)
  * KDE4 & KDE5 `KWallet <https://en.wikipedia.org/wiki/KWallet>`_
    (requires `dbus <https://pypi.python.org/pypi/dbus-python>`_)
  * `Windows Credential Locker
    <https://docs.microsoft.com/en-us/windows/uwp/security/credential-locker>`_

  Other keyring implementations are available through `Third-Party Backends`_.

  -------------------------
  Installation Instructions
  -------------------------

  Install from Index
  ==================

  Install using your favorite installer. For example:

      $ pip install keyring

  Linux
  -----

  On Linux, the recommended keyring relies on SecretStorage, which in
  turn relies on dbus-python, but dbus-python does not install correctly
  when using the Python installers, so dbus-python must be installed
  as a system package. See `the SecretStorage GitHub repo
  <https://github.com/mitya57/secretstorage>`_ for details.

  -------------
  Using Keyring
  -------------

  The basic usage of keyring is pretty simple: just call `keyring.set_password`
  and `keyring.get_password`:

      >>> import keyring
      >>> keyring.set_password("system", "username", "password")
      >>> keyring.get_password("system", "username")
      'password'

  Command-line Utility
  ====================

  Keyring supplies a ``keyring`` command which is installed with the
  package. After installing keyring in most environments, the
  command should be available for setting, getting, and deleting
  passwords. For more information on usage, invoke with no arguments
  or with ``--help`` as so::

      $ keyring --help
      $ keyring set system username
      Password for 'username' in 'system':
      $ keyring get system username
      password

  The command-line functionality is also exposed as an executable
  package, suitable for invoking from Python like so::

      $ python -m keyring --help
      $ python -m keyring set system username
      Password for 'username' in 'system':
      $ python -m keyring get system username
      password

  --------------------------
  Configure your keyring lib
  --------------------------

  The python keyring lib contains implementations for several backends. The
  library will
  automatically choose the keyring that is most suitable for your current
  environment. You can also specify the keyring you like to be used in the
  config file or by calling the ``set_keyring()`` function.

  Customize your keyring by config file
  =====================================

  This section describes how to change your option in the config file.

  Config file path
  ----------------

  The configuration of the lib is stored in a file named "keyringrc.cfg". This
  file must be found in a platform-specific location. To determine
  where the config file is stored, run the following::

      python -c "import keyring.util.platform_; print(keyring.util.platform_.config_root())"

  Some keyrings also store the keyring data in the file system. To determine
  where the data files are stored, run this command::

      python -c "import keyring.util.platform_; print(keyring.util.platform_.data_root())"


  Config file content
  -------------------

  To specify a keyring backend, set the **default-keyring** option to the
  full path of the class for that backend, such as
  ``keyring.backends.OS_X.Keyring``.

  If **keyring-path** is indicated, keyring will add that path to the Python
  module search path before loading the backend.

  For example, this config might be used to load the SimpleKeyring from the demo
  directory in the project checkout::

      [backend]
      default-keyring=simplekeyring.SimpleKeyring
      keyring-path=/home/kang/pyworkspace/python-keyring-lib/demo/

  Third-Party Backends
  ====================

  In addition to the backends provided by the core keyring package for
  the most common and secure use cases, there
  are additional keyring backend implementations available for other
  use-cases. Simply install them to make them available:

  - `keyrings.cryptfile <https://pypi.org/project/keyrings.cryptfile>`_
    - Encrypted text file storage.
  - `keyring_jeepney <https://pypi.org/project/keyring_jeepney>`__ - a
    pure Python backend using the secret service DBus API for desktop
    Linux.
  - `keyrings.alt <https://pypi.org/project/keyrings.alt>`_ - "alternate",
    possibly-insecure backends, originally part of the core package, but
    available for opt-in.
  - `gsheet-keyring <https://pypi.org/project/gsheet-keyring>`_
    - a backend that stores secrets in a Google Sheet. For use with
    `ipython-secrets <https://pypi.org/project/ipython-secrets>`_.

  Write your own keyring backend
  ==============================

  The interface for the backend is defined by ``keyring.backend.KeyringBackend``.
  Every backend should derive from that base class and define a ``priority``
  attribute and three functions: ``get_password()``, ``set_password()``, and
  ``delete_password()``.

  See the ``backend`` module for more detail on the interface of this class.

  Keyring employs entry points to allow any third-party package to implement
  backends without any modification to the keyring itself. Those interested in
  creating new backends are encouraged to create new, third-party packages
  in the ``keyrings`` namespace, in a manner modeled by the `keyrings.alt
  package <https://github.com/jaraco/keyrings.alt>`_. See the ``setup.py`` file
  in that project for a hint on how to create the requisite entry points.
  Backends that prove essential may be considered for inclusion in the core
  library, although the ease of installing these third-party packages should
  mean that extensions may be readily available.

  If you've created an extension for Keyring, please submit a pull request to
  have your extension mentioned as an available extension.

  Set the keyring in runtime
  ==========================

  Keyring additionally allows programmatic configuration of the
  backend calling the api ``set_keyring()``. The indicated backend
  will subsequently be used to store and retrieve passwords.

  Here's an example demonstrating how to invoke ``set_keyring``::

      
      import keyring.backend

      class TestKeyring(keyring.backend.KeyringBackend):
          """A test keyring which always outputs same password
          """
          priority = 1

          def set_password(self, servicename, username, password):
              pass

          def get_password(self, servicename, username):
              return "password from TestKeyring"

          def delete_password(self, servicename, username, password):
              pass

      
      keyring.set_keyring(TestKeyring())

      
      try:
          keyring.set_password("demo-service", "tarek", "passexample")
          print("password stored successfully")
      except keyring.errors.PasswordSetError:
          print("failed to store password")
      print("password", keyring.get_password("demo-service", "tarek"))


  Using Keyring on Ubuntu 16.04
  =============================

  The following is a complete transcript for installing keyring in a
  virtual environment on Ubuntu 16.04.  No config file was used.::

    $ sudo apt install python3-venv libdbus-glib-1-dev
    $ cd /tmp
    $ pyvenv py3
    $ source py3/bin/activate
    $ pip install -U pip
    $ pip install secretstorage dbus-python
    $ pip install keyring
    $ python
    >>> import keyring
    >>> keyring.get_keyring()
    <keyring.backends.SecretService.Keyring object at 0x7f9b9c971ba8>
    >>> keyring.set_password("system", "username", "password")
    >>> keyring.get_password("system", "username")
    'password'


  Using Keyring on headless Linux systems
  =======================================

  It is possible to use the SecretService backend on Linux systems without
  X11 server available (only D-Bus is required). To do that, you need the
  following:

  * Install the `GNOME Keyring`_ daemon.
  * Start a D-Bus session, e.g. run ``dbus-run-session -- sh`` and run
    the following commands inside that shell.
  * Run ``gnome-keyring-daemon`` with ``--unlock`` option. The description of
    that option says:

        Read a password from stdin, and use it to unlock the login keyring
        or create it if the login keyring does not exist.

    When that command is started, enter your password into stdin and
    press Ctrl+D (end of data). After that the daemon will fork into
    background (use ``--foreground`` option to prevent that).
  * Now you can use the SecretService backend of Keyring. Remember to
    run your application in the same D-Bus session as the daemon.

  .. _GNOME Keyring: https://wiki.gnome.org/Projects/GnomeKeyring

  -----------------------------------------------
  Integrate the keyring lib with your application
  -----------------------------------------------

  API interface
  =============

  The keyring lib has a few functions:

  * ``get_keyring()``: Return the currently-loaded keyring implementation.
  * ``get_password(service, username)``: Returns the password stored in the
    active keyring. If the password does not exist, it will return None.
  * ``set_password(service, username, password)``: Store the password in the
    keyring.
  * ``delete_password(service, username)``: Delete the password stored in
    keyring. If the password does not exist, it will raise an exception.

  In all cases, the parameters (``service``, ``username``, ``password``)
  should be Unicode text. On Python 2, these parameters are accepted as
  simple ``str`` in the default encoding as they will be implicitly
  decoded to text. Some backends may accept ``bytes`` for these parameters,
  but such usage is discouraged.


  Exceptions
  ==========

  The keyring lib raises following exceptions:

  * ``keyring.errors.KeyringError``: Base Error class for all exceptions in keyring lib.
  * ``keyring.errors.InitError``: Raised when the keyring can't be initialized.
  * ``keyring.errors.PasswordSetError``: Raise when password can't be set in the keyring.
  * ``keyring.errors.PasswordDeleteError``: Raised when the password can't be deleted in the keyring.

  ------------
  Get involved
  ------------

  Python keyring lib is an open community project and highly welcomes new
  contributors.

  * Repository: https://github.com/jaraco/keyring/
  * Bug Tracker: https://github.com/jaraco/keyring/issues/
  * Mailing list: http://groups.google.com/group/python-keyring

  Making Releases
  ===============

  This project makes use of automated releases via Travis-CI. The
  simple workflow is to tag a commit and push it to Github. If it
  passes tests on a late Python version, it will be automatically
  deployed to PyPI.

  Other things to consider when making a release:

   - first ensure that tests pass (preferably on Windows and Linux)
   - check that the changelog is current for the intended release

  Running Tests
  =============

  Tests are `continuously run <https://travis-ci.org/#!/jaraco/keyring>`_ using
  Travis-CI.

  To run the tests yourself, you'll want keyring installed to some environment
  in which it can be tested. Recommended technique is described below.

  Using tox
  ---------

  Keyring prefers use of `tox <https://pypi.org/project/tox>`_ to run tests.
  Simply install and invoke ``tox``.

  This technique is the one used by the Travis-CI script.

  ----------
  Background
  ----------

  The project was based on Tarek Ziade's idea in `this post`_. Kang Zhang
  initially carried it out as a `Google Summer of Code`_ project, and Tarek
  mentored Kang on this project.

  .. _this post: http://tarekziade.wordpress.com/2009/03/27/pycon-hallway-session-1-a-keyring-library-for-python/
  .. _Google Summer of Code: http://socghop.appspot.com/


  .. image:: https://badges.gitter.im/jaraco/keyring.svg
     :alt: Join the chat at https://gitter.im/jaraco/keyring
     :target: https://gitter.im/jaraco/keyring?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge


pkgId: 0a6befb1786be76b4f2ff8ce56609401f45213f15ceca48dc595e3c3deb7cf36
name: rh-python36-keystoneauth1
arch: noarch
version: 3.18.0
epoch: 0
release: 1
summary: Authentication Library for OpenStack Identity
url: https://docs.openstack.org/keystoneauth/latest/
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-dev@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: bc13aca081d44cfe9581d468bd4bf92a
rpm_sourcerpm: rh-python36-keystoneauth1-3.18.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143877-rh-python36-keystoneauth1/rh-python36-keystoneauth1-3.18.0-1.noarch.rpm
checksum_type: sha256
description:
  ========================
  Team and repository tags
  ========================

  .. image:: https://governance.openstack.org/badges/keystoneauth.svg
      :target: https://governance.openstack.org/reference/tags/index.html

  .. Change things from this point on

  ============
  keystoneauth
  ============

  .. image:: https://img.shields.io/pypi/v/keystoneauth1.svg
      :target: https://pypi.python.org/pypi/keystoneauth1/
      :alt: Latest Version

  .. image:: https://img.shields.io/pypi/dm/keystoneauth1.svg
      :target: https://pypi.python.org/pypi/keystoneauth1/
      :alt: Downloads

  This package contains tools for authenticating to an OpenStack-based cloud.
  These tools include:

  * Authentication plugins (password, token, and federation based)
  * Discovery mechanisms to determine API version support
  * A session that is used to maintain client settings across requests (based on
    the requests Python library)

  Further information:

  * Free software: Apache license
  * Documentation: https://docs.openstack.org/keystoneauth/latest/
  * Source: https://git.openstack.org/cgit/openstack/keystoneauth
  * Bugs: https://bugs.launchpad.net/keystoneauth


pkgId: 7d533d086c80b65e08eb7e521b0d7b36f57c48940558a328174a31b906a98ae8
name: rh-python36-knack
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: A Command-Line Interface framework
url: https://github.com/microsoft/knack
rpm_license: MIT
rpm_vendor: Microsoft Corporation <azpycli@microsoft.com>
rpm_group: Development/Libraries
rpm_buildhost: 794d5fcfec8548f5b893ee1fce8e383d
rpm_sourcerpm: rh-python36-knack-0.3.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850809-rh-python36-knack/rh-python36-knack-0.3.3-1.noarch.rpm
checksum_type: sha256
description:
  Knack
  =====

  .. image:: https://img.shields.io/pypi/v/knack.svg
      :target: https://pypi.python.org/pypi/knack

  .. image:: https://img.shields.io/pypi/pyversions/knack.svg
      :target: https://pypi.python.org/pypi/knack

  .. image:: https://travis-ci.org/Microsoft/knack.svg?branch=master
      :target: https://travis-ci.org/Microsoft/knack


  ------------


  ::

      _                     _
     | | ___ __   __ _  ___| | __
     | |/ / '_ \ / _` |/ __| |/ /
     |   <| | | | (_| | (__|   <
     |_|\_\_| |_|\__,_|\___|_|\_\


  **A Command-Line Interface framework**


  .. code-block:: bash

      pip install knack


  ------------

  .. note:: The project is in `initial development phase <https://semver.org/#how-should-i-deal-with-revisions-in-the-0yz-initial-development-phase>`__ . We recommend pinning to at least a specific minor version when marking **knack** as a dependency in your project.

  ------------


  Usage
  =====


  .. code-block:: python

      import sys
      from collections import OrderedDict
      from knack import CLI, CLICommandsLoader, ArgumentsContext

      def abc_list(myarg):
          import string
          return list(string.ascii_lowercase)

      class MyCommandsLoader(CLICommandsLoader):
          def load_command_table(self, args):
              with CommandGroup(__name__, self, 'abc', '__main__#{}') as g:
                  g.command('list', 'abc_list')
              return OrderedDict(self.command_table)

          def load_arguments(self, command):
              with ArgumentsContext(self, 'abc list') as ac:
                  ac.argument('myarg', type=int, default=100)
              super(MyCommandsLoader, self).load_arguments(command)

      mycli = CLI(cli_name='mycli', commands_loader_cls=MyCommandsLoader)
      exit_code = mycli.invoke(sys.argv[1:])
      sys.exit(exit_code)


  More samples and snippets available at `examples <examples>`__.


  Documentation
  =============

  Documentation is available at `docs <docs>`__.

  Developer Setup
  ===============

  In a virtual environment, install the `requirements.txt` file.

  .. code-block:: bash

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

  Run Automation
  ==============

  This project supports running automation using `tox <https://tox.readthedocs.io/en/latest/>`__.

  .. code-block:: bash

      pip install tox
      tox


  Real-world uses
  ===============

  - `Azure CLI <https://github.com/Azure/azure-cli/>`__: The Azure CLI 2.0 is Azure's new command line experience for managing Azure resources.
  - `VSTS CLI <https://github.com/Microsoft/vsts-cli>`__: A command-line interface for Visual Studio Team Services (VSTS) and Team Foundation Server (TFS). With the VSTS CLI, you can manage and work with resources including pull requests, work items, builds, and more.
  - `Service Fabric CLI <https://github.com/Azure/service-fabric-cli>`__: A command-line interface for interacting with Azure Service Fabric clusters and their related entities.

  Do you use knack in your CLI as well? Open a pull request to include it here. We would love to have it in our list.


  Release History
  ===============

  See `GitHub Releases <https://github.com/Microsoft/knack/releases>`__.


  Contribute Code
  ===============

  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.

  If you would like to become an active contributor to this project please
  follow the instructions provided in `Contribution License Agreement <https://cla.microsoft.com/>`__


  License
  =======

  Knack is licensed under `MIT <LICENSE>`__.


pkgId: 37f8e90811f87a98caa394ee716f38a3bb48c192c1644dde4b9ebc4eb0dbde88
name: rh-python36-kombu
arch: noarch
version: 4.6.7
epoch: 0
release: 1
summary: Messaging library for Python.
url: https://kombu.readthedocs.io
rpm_license: BSD
rpm_vendor: Ask Solem <ask@celeryproject.org>
rpm_group: Development/Libraries
rpm_buildhost: 96ab44d297844584ba6e54237bfb0297
rpm_sourcerpm: rh-python36-kombu-4.6.7-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143806-rh-python36-kombu/rh-python36-kombu-4.6.7-1.noarch.rpm
checksum_type: sha256
description:
  ========================================
   kombu - Messaging library for Python
  ========================================

  |build-status| |coverage| |license| |wheel| |pyversion| |pyimp|

  :Version: 4.2.1
  :Web: http://kombu.me/
  :Download: https://pypi.python.org/pypi/kombu/
  :Source: https://github.com/celery/kombu/
  :Keywords: messaging, amqp, rabbitmq, redis, mongodb, python, queue

  About
  =====

  `Kombu` is a messaging library for Python.

  The aim of `Kombu` is to make messaging in Python as easy as possible by
  providing an idiomatic high-level interface for the AMQ protocol, and also
  provide proven and tested solutions to common messaging problems.

  `AMQP`_ is the Advanced Message Queuing Protocol, an open standard protocol
  for message orientation, queuing, routing, reliability and security,
  for which the `RabbitMQ`_ messaging server is the most popular implementation.

  Features
  ========

  * Allows application authors to support several message server
    solutions by using pluggable transports.

      * AMQP transport using the `py-amqp`_, `librabbitmq`_, or `qpid-python`_ libraries.

      * High performance AMQP transport written in C - when using `librabbitmq`_

        This is automatically enabled if librabbitmq is installed:

        ::

          $ pip install librabbitmq

      * Virtual transports makes it really easy to add support for non-AMQP
        transports. There is already built-in support for `Redis`_,
        `Amazon SQS`_, `ZooKeeper`_, `SoftLayer MQ`_ and `Pyro`_.

      * In-memory transport for unit testing.

  * Supports automatic encoding, serialization and compression of message
    payloads.

  * Consistent exception handling across transports.

  * The ability to ensure that an operation is performed by gracefully
    handling connection and channel errors.

  * Several annoyances with `amqplib`_ has been fixed, like supporting
    timeouts and the ability to wait for events on more than one channel.

  * Projects already using `carrot`_ can easily be ported by using
    a compatibility layer.

  For an introduction to AMQP you should read the article `Rabbits and warrens`_,
  and the `Wikipedia article about AMQP`_.

  .. _`RabbitMQ`: https://www.rabbitmq.com/
  .. _`AMQP`: https://amqp.org
  .. _`py-amqp`: https://pypi.python.org/pypi/amqp/
  .. _`qpid-python`: https://pypi.python.org/pypi/qpid-python/
  .. _`Redis`: https://redis.io
  .. _`Amazon SQS`: https://aws.amazon.com/sqs/
  .. _`Zookeeper`: https://zookeeper.apache.org/
  .. _`Rabbits and warrens`: http://web.archive.org/web/20160323134044/http://blogs.digitar.com/jjww/2009/01/rabbits-and-warrens/
  .. _`amqplib`: https://barryp.org/software/py-amqplib/
  .. _`Wikipedia article about AMQP`: https://en.wikipedia.org/wiki/AMQP
  .. _`carrot`: https://pypi.python.org/pypi/carrot/
  .. _`librabbitmq`: https://pypi.python.org/pypi/librabbitmq
  .. _`Pyro`: https://pythonhosting.org/Pyro4
  .. _`SoftLayer MQ`: https://sldn.softlayer.com/reference/messagequeueapi

  .. _transport-comparison:

  Transport Comparison
  ====================

  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | **Client**    | **Type** | **Direct** | **Topic**  | **Fanout**    | **Priority** | **TTL**               |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | *amqp*        | Native   | Yes        | Yes        | Yes           | Yes [#f3]_   | Yes [#f4]_            |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | *qpid*        | Native   | Yes        | Yes        | Yes           | No           | No                    |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | *redis*       | Virtual  | Yes        | Yes        | Yes (PUB/SUB) | Yes          | No                    |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | *mongodb*     | Virtual  | Yes        | Yes        | Yes           | Yes          | Yes                   |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | *SQS*         | Virtual  | Yes        | Yes [#f1]_ | Yes [#f2]_    | No           | No                    |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | *zookeeper*   | Virtual  | Yes        | Yes [#f1]_ | No            | Yes          | No                    |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | *in-memory*   | Virtual  | Yes        | Yes [#f1]_ | No            | No           | No                    |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+
  | *SLMQ*        | Virtual  | Yes        | Yes [#f1]_ | No            | No           | No                    |
  +---------------+----------+------------+------------+---------------+--------------+-----------------------+


  .. [#f1] Declarations only kept in memory, so exchanges/queues
           must be declared by all clients that needs them.

  .. [#f2] Fanout supported via storing routing tables in SimpleDB.
           Disabled by default, but can be enabled by using the
           ``supports_fanout`` transport option.

  .. [#f3] AMQP Message priority support depends on broker implementation.

  .. [#f4] AMQP Message/Queue TTL support depends on broker implementation.

  Documentation
  -------------

  Kombu is using Sphinx, and the latest documentation can be found here:

      https://kombu.readthedocs.io/

  Quick overview
  --------------

  .. code:: python

      from kombu import Connection, Exchange, Queue

      media_exchange = Exchange('media', 'direct', durable=True)
      video_queue = Queue('video', exchange=media_exchange, routing_key='video')

      def process_media(body, message):
          print body
          message.ack()

      
      with Connection('amqp://guest:guest@localhost//') as conn:

          
          producer = conn.Producer(serializer='json')
          producer.publish({'name': '/tmp/lolcat1.avi', 'size': 1301013},
                            exchange=media_exchange, routing_key='video',
                            declare=[video_queue])

          
          
          
          
          
          

          
          with conn.Consumer(video_queue, callbacks=[process_media]) as consumer:
              
              while True:
                  conn.drain_events()

      
      video_queue = Queue('video', exchange=media_exchange, key='video')
      image_queue = Queue('image', exchange=media_exchange, key='image')

      with connection.Consumer([video_queue, image_queue],
                               callbacks=[process_media]) as consumer:
          while True:
              connection.drain_events()


  Or handle channels manually:

  .. code:: python

      with connection.channel() as channel:
          producer = Producer(channel, ...)
          consumer = Producer(channel)


  All objects can be used outside of with statements too,
  just remember to close the objects after use:

  .. code:: python

      from kombu import Connection, Consumer, Producer

      connection = Connection()
          
      connection.release()

      consumer = Consumer(channel_or_connection, ...)
      consumer.register_callback(my_callback)
      consumer.consume()
          
      consumer.cancel()


  `Exchange` and `Queue` are simply declarations that can be pickled
  and used in configuration files etc.

  They also support operations, but to do so they need to be bound
  to a channel.

  Binding exchanges and queues to a connection will make it use
  that connections default channel.

  ::

      >>> exchange = Exchange('tasks', 'direct')

      >>> connection = Connection()
      >>> bound_exchange = exchange(connection)
      >>> bound_exchange.delete()

      
      >>> exchange.delete()
      raise NotBoundError: Can't call delete on Exchange not bound to
          a channel.

  Terminology
  ===========

  There are some concepts you should be familiar with before starting:

      * Producers

          Producers sends messages to an exchange.

      * Exchanges

          Messages are sent to exchanges. Exchanges are named and can be
          configured to use one of several routing algorithms. The exchange
          routes the messages to consumers by matching the routing key in the
          message with the routing key the consumer provides when binding to
          the exchange.

      * Consumers

          Consumers declares a queue, binds it to a exchange and receives
          messages from it.

      * Queues

          Queues receive messages sent to exchanges. The queues are declared
          by consumers.

      * Routing keys

          Every message has a routing key. The interpretation of the routing
          key depends on the exchange type. There are four default exchange
          types defined by the AMQP standard, and vendors can define custom
          types (so see your vendors manual for details).

          These are the default exchange types defined by AMQP/0.8:

              * Direct exchange

                  Matches if the routing key property of the message and
                  the `routing_key` attribute of the consumer are identical.

              * Fan-out exchange

                  Always matches, even if the binding does not have a routing
                  key.

              * Topic exchange

                  Matches the routing key property of the message by a primitive
                  pattern matching scheme. The message routing key then consists
                  of words separated by dots (`"."`, like domain names), and
                  two special characters are available; star (`"*"`) and hash
                  (`"#"`). The star matches any word, and the hash matches
                  zero or more words. For example `"*.stock.#"` matches the
                  routing keys `"usd.stock"` and `"eur.stock.db"` but not
                  `"stock.nasdaq"`.


  Installation
  ============

  You can install `Kombu` either via the Python Package Index (PyPI)
  or from source.

  To install using `pip`,:

  ::

      $ pip install kombu

  To install using `easy_install`,:

  ::

      $ easy_install kombu

  If you have downloaded a source tarball you can install it
  by doing the following,:

  ::

      $ python setup.py build
      



  Getting Help
  ============

  Mailing list
  ------------

  Join the `celery-users`_ mailing list.

  .. _`celery-users`: https://groups.google.com/group/celery-users/

  Bug tracker
  ===========

  If you have any suggestions, bug reports or annoyances please report them
  to our issue tracker at https://github.com/celery/kombu/issues/

  Contributing
  ============

  Development of `Kombu` happens at Github: https://github.com/celery/kombu

  You are highly encouraged to participate in the development. If you don't
  like Github (for some reason) you're welcome to send regular patches.

  License
  =======

  This software is licensed under the `New BSD License`. See the `LICENSE`
  file in the top distribution directory for the full license text.


  .. |build-status| image:: https://secure.travis-ci.org/celery/kombu.png?branch=master
      :alt: Build status
      :target: https://travis-ci.org/celery/kombu

  .. |coverage| image:: https://codecov.io/github/celery/kombu/coverage.svg?branch=master
      :target: https://codecov.io/github/celery/kombu?branch=master

  .. |license| image:: https://img.shields.io/pypi/l/kombu.svg
      :alt: BSD License
      :target: https://opensource.org/licenses/BSD-3-Clause

  .. |wheel| image:: https://img.shields.io/pypi/wheel/kombu.svg
      :alt: Kombu can be installed via wheel
      :target: https://pypi.python.org/pypi/kombu/

  .. |pyversion| image:: https://img.shields.io/pypi/pyversions/kombu.svg
      :alt: Supported Python versions.
      :target: https://pypi.python.org/pypi/kombu/

  .. |pyimp| image:: https://img.shields.io/pypi/implementation/kombu.svg
      :alt: Support Python implementations.
      :target: https://pypi.python.org/pypi/kombu/
  --


pkgId: 286ee5ad0f3f777982e37ae1a1deaabd38609c95553e8fc5099470516a7322a1
name: rh-python36-libselinux-python
arch: src
version: 2.5
epoch: 0
release: 14.1.el7
summary: SELinux SCL Python36 python bindings
url: https://github.com/SELinuxProject/selinux/wiki
rpm_license: Public Domain
rpm_group: System Environment/Libraries
rpm_buildhost: 10a5f8b093454c9ea1163556aa99c099
location_href: 00885597-rh-python36-libselinux-python/rh-python36-libselinux-python-2.5-14.1.el7.src.rpm
checksum_type: sha256
description:
  Security-enhanced Linux is a feature of the Linux® kernel and a number
  of utilities with enhanced security functionality designed to add
  mandatory access controls to Linux.  The Security-enhanced Linux
  kernel contains new architectural components originally developed to
  improve the security of the Flask operating system. These
  architectural components provide general support for the enforcement
  of many kinds of mandatory access control policies, including those
  based on the concepts of Type Enforcement®, Role-based Access
  Control, and Multi-level Security.

  libselinux provides an API for SELinux applications to get and set
  process and file security contexts and to obtain security policy
  decisions.  Required for any applications that use the SELinux API.


pkgId: bffd3e4375ce6e152e3353081a1fa1f644020e19a76b3435a127d17aa4724517
name: rh-python36-libselinux-python-debuginfo
arch: x86_64
version: 2.5
epoch: 0
release: 14.1.el7
summary: Debug information for package rh-python36-libselinux-python
url: https://github.com/SELinuxProject/selinux/wiki
rpm_license: Public Domain
rpm_group: Development/Debug
rpm_buildhost: 858b478f217d4ad088c0a106211208ae
rpm_sourcerpm: rh-python36-libselinux-python-2.5-14.1.el7.src.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-libselinux-python.
  Debug information is useful when developing applications that use this
  package or when debugging this package.

location_href:
  00885597-rh-python36-libselinux-python/rh-python36-libselinux-python-debuginfo-2.5-14.1.el7.x86_64.rpm


pkgId: 95a5af44d3c3bcf0514159347fb8ab36c5e9013aaabc0a414042d8ccd86fdbb0
name: rh-python36-lockfile
arch: noarch
version: 0.12.2
epoch: 0
release: 1
summary: Platform-independent file locking module
url: http://launchpad.net/pylockfile
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-dev@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: 7428f3c3409a4678a1438c60862f2b0e
rpm_sourcerpm: rh-python36-lockfile-0.12.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00872299-rh-python36-lockfile/rh-python36-lockfile-0.12.2-1.noarch.rpm
checksum_type: sha256
description:
  Note: This package is **deprecated**. It is highly preferred that instead of
  using this code base that instead `fasteners`_ or `oslo.concurrency`_ is
  used instead. For any questions or comments or further help needed
  please email `openstack-dev`_ and prefix your email subject
  with ``[oslo][pylockfile]`` (for a faster response).

  The lockfile package exports a LockFile class which provides a simple API for
  locking files.  Unlike the Windows msvcrt.locking function, the fcntl.lockf
  and flock functions, and the deprecated posixfile module, the API is
  identical across both Unix (including Linux and Mac) and Windows platforms.
  The lock mechanism relies on the atomic nature of the link (on Unix) and
  mkdir (on Windows) system calls.  An implementation based on SQLite is also
  provided, more as a demonstration of the possibilities it provides than as
  production-quality code.

  Note: In version 0.9 the API changed in two significant ways:

   * It changed from a module defining several classes to a package containing
     several modules, each defining a single class.

   * Where classes had been named SomethingFileLock before the last two words
     have been reversed, so that class is now SomethingLockFile.

  The previous module-level definitions of LinkFileLock, MkdirFileLock and
  SQLiteFileLock will be retained until the 1.0 release.

  To install:

      python setup.py install

  * Documentation: http://docs.openstack.org/developer/pylockfile
  * Source: http://git.openstack.org/cgit/openstack/pylockfile
  * Bugs: http://bugs.launchpad.net/pylockfile


pkgId: effde91ace129acc72e65d2d9347764832346972c96b465ecb5caf14e2740360
name: rh-python36-lxml
arch: src
version: 4.5.0
epoch: 0
release: 1
summary: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API.
url: http://lxml.de/
rpm_license: BSD
rpm_vendor: lxml dev team <lxml-dev@lxml.de>
rpm_group: Development/Libraries
rpm_buildhost: ec87853fd3bf41e88a959a90549f0f0a
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01314004-rh-python36-lxml/rh-python36-lxml-4.5.0-1.src.rpm
checksum_type: sha256
description:
  lxml is a Pythonic, mature binding for the libxml2 and libxslt libraries.  It
  provides safe and convenient access to these libraries using the ElementTree
  API.

  It extends the ElementTree API significantly to offer support for XPath,
  RelaxNG, XML Schema, XSLT, C14N and much more.

  To contact the project, go to the `project home page
  <http://lxml.de/>`_ or see our bug tracker at
  https://launchpad.net/lxml

  In case you want to use the current in-development version of lxml,
  you can get it from the github repository at
  https://github.com/lxml/lxml .  Note that this requires Cython to
  build the sources, see the build instructions on the project home
  page.  To the same end, running ``easy_install lxml==dev`` will
  install lxml from
  https://github.com/lxml/lxml/tarball/master#egg=lxml-dev if you have
  an appropriate version of Cython installed.


  After an official release of a new stable series, bug fixes may become
  available at
  https://github.com/lxml/lxml/tree/lxml-4.1 .
  Running ``easy_install lxml==4.1bugfix`` will install
  the unreleased branch state from
  https://github.com/lxml/lxml/tarball/lxml-4.1#egg=lxml-4.1bugfix
  as soon as a maintenance branch has been established.  Note that this
  requires Cython to be installed at an appropriate version for the build.

  4.1.1 (2017-11-04)
  ==================

  * Rebuild with Cython 0.27.3 to improve support for Py3.7.


pkgId: 59c61af7978d22a887bdfaa4ee7e1c852b2631189438341066f4f7a8a9166a95
name: rh-python36-lxml-debuginfo
arch: x86_64
version: 4.5.0
epoch: 0
release: 1
summary: Debug information for package rh-python36-lxml
url: http://lxml.de/
rpm_license: BSD
rpm_vendor: lxml dev team <lxml-dev@lxml.de>
rpm_group: Development/Debug
rpm_buildhost: e87ae2e3895447139dd875096db65bee
rpm_sourcerpm: rh-python36-lxml-4.5.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01314004-rh-python36-lxml/rh-python36-lxml-debuginfo-4.5.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-lxml.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: c18c9d508623aa0618d05988c2b2d96367bff5de49e3539bcec363bd68bbadd8
name: rh-python36-m2r
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Markdown and reStructuredText in a single file.
url: https://github.com/miyakogi/m2r
rpm_license: MIT
rpm_vendor: Hiroyuki Takagi <miyako.dev@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: da2f1ec44a134b9ea5b032498c1b549e
rpm_sourcerpm: rh-python36-m2r-0.2.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850408-rh-python36-m2r/rh-python36-m2r-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  M2R
  ===

  [![PyPI](https://img.shields.io/pypi/v/m2r.svg)](https://pypi.python.org/pypi/m2r)
  [![PyPI version](https://img.shields.io/pypi/pyversions/m2r.svg)](https://pypi.python.org/pypi/m2r)
  [![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://miyakogi.github.io/m2r)
  [![Build Status](https://travis-ci.org/miyakogi/m2r.svg?branch=master)](https://travis-ci.org/miyakogi/m2r)
  [![codecov](https://codecov.io/gh/miyakogi/m2r/branch/master/graph/badge.svg)](https://codecov.io/gh/miyakogi/m2r)

  --------------------------------------------------------------------------------

  M2R converts a markdown file including reStructuredText (rst) markups to a valid
  rst format.



  I wanted to write sphinx document in markdown, since it's widely used now and
  easy to write code blocks and lists. However, converters using pandoc or
  recommonmark do not support many rst markups and sphinx extensions. For
  example, rst's reference link like ``see `ref`_`` (this is very convenient in
  long document in which same link appears multiple times) will be converted to
  a code block in HTML like `see <code>ref</code>_`, which is not expected.



  * Basic markdown and some extensions (see below)
      * inline/block-level raw html
      * fenced-code block
      * tables
      * footnotes (``[^1]``)
  * Inline- and Block-level rst markups
      * single- and multi-line directives (`.. directive::`)
      * inline-roles (``:code:`print(1)` ...``)
      * ref-link (``see `ref`_``)
      * footnotes (``[#fn]_``)
      * math extension inspired by [recommonmark](https://recommonmark.readthedocs.io/en/latest/index.html)
  * Sphinx extension
      * add markdown support for sphinx
      * ``mdinclude`` directive to include markdown from md or rst files
      * option to parse relative links into ref and doc directives (``m2r_parse_relative_links``)
  * Pure python implementation
      * pandoc is not required



  Python 2.7 or Python 3.4+ is required.

  ```
  pip install m2r
  ```

  Or,

  ```
  python3 -m pip install m2r
  ```





  `m2r` command converts markdown file to rst format.

  ```
  m2r your_document.md [your_document2.md ...]
  ```

  Then you will find `your_document.rst` in the same directory.



  Import `m2r.convert` function and call it with markdown text.
  Then it will return converted text.

  ```python
  from m2r import convert
  rst = convert('# Title\n\nSentence.')
  print(rst)




  ```

  Or, use `parse_from_file` function to load markdown file and obtain converted
  text.

  ```python
  from m2r import parse_from_file
  output = parse_from_file('markdown_file.md')
  ```

  This is an example of setup.py to write README in markdown, and publish it to
  PyPI as rst format.

  ```python
  readme_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'README.md')
  try:
      from m2r import parse_from_file
      readme = parse_from_file(readme_file)
  except ImportError:
      
      with open(readme_file) as f:
          readme = f.read()
  setup(
      ...,
      long_description=readme,
      ...,
  )
  ```



  In your conf.py, add the following lines.

  ```python
  extensions = [
      ...,
      'm2r',
  ]


  source_suffix = ['.rst', '.md']
  ```

  Write index.md and run `make html`.

  When `m2r` extension is enabled on sphinx and `.md` file is loaded, m2r
  converts to rst and pass to sphinx, not making new `.rst` file.



  Like `.. include:: file` directive, `.. mdinclude:: file` directive inserts
  markdown file at the line.

  Note: do not use `.. include:: file` directive to include markdown file even if
  in the markdown file, please use `.. mdinclude:: file` instead.



  * In the rst's directives, markdown is not available. Please write in rst.
  * Column alignment of tables is not supported. (rst does not support this feature)
  * Heading with overline-and-underline is not supported.
    * Heading with underline is OK
  * Rst heading marks are currently hard-coded and unchangeable.
    * H1: `=`, H2: `-`, H3: `^`, H4: `~`, H5: `"`, H6: `#`

  If you find any bug or unexpected behaviour, please report it to
  [Issues](https://github.com/miyakogi/m2r/issues).



  See [example document](https://miyakogi.github.io/m2r/example.html) and [its
  source code](https://github.com/miyakogi/m2r/blob/master/docs/example.md).

  I'm using m2r for writing user guide of [WDOM](https://github.com/miyakogi/wdom).
  So you can see it as another example. Its [HTML is
  here](http://wdom-py.readthedocs.io/en/latest/guide/index.html), and [its
  source code is here](https://github.com/miyakogi/wdom/tree/dev/docs/guide).



  Demo editor of m2r is available.
  If you are interested in m2r, please try it.

  [https://github.com/miyakogi/m2rdemo](https://github.com/miyakogi/m2rdemo)



  m2r is written as an extension of
  [mistune](http://mistune.readthedocs.io/en/latest/), which is highly extensible
  pure-python markdown parser.
  Without the mistune, I couldn't write this. Thank you!



  [MIT](https://github.com/miyakogi/m2r/blob/master/LICENSE)


pkgId: bda0d2bf5584bab38c9c1d5ef4a97287311eee31d41adfc80fd1894fbc9de702
name: rh-python36-mistune
arch: noarch
version: 0.8.4
epoch: 0
release: 1
summary: The fastest markdown parser in pure Python
url: https://github.com/lepture/mistune
rpm_license: BSD
rpm_vendor: Hsiaoming Yang <me@lepture.com>
rpm_group: Development/Libraries
rpm_buildhost: 27ef3850cc3448f7b122100c32a52cb5
rpm_sourcerpm: rh-python36-mistune-0.8.4-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850409-rh-python36-mistune/rh-python36-mistune-0.8.4-1.noarch.rpm
checksum_type: sha256
description:
  Mistune
  =======

  The fastest markdown parser in pure Python with renderer features,
  inspired by marked_.

  .. image:: https://img.shields.io/badge/donate-lepture-green.svg
     :target: https://lepture.com/donate
     :alt: Donate lepture
  .. image:: https://img.shields.io/pypi/wheel/mistune.svg?style=flat
     :target: https://pypi.python.org/pypi/mistune/
     :alt: Wheel Status
  .. image:: https://anaconda.org/conda-forge/mistune/badges/version.svg
     :target: https://anaconda.org/conda-forge/mistune
     :alt: Conda Version
  .. image:: https://img.shields.io/pypi/v/mistune.svg
     :target: https://pypi.python.org/pypi/mistune/
     :alt: Latest Version
  .. image:: https://travis-ci.org/lepture/mistune.svg?branch=master
     :target: https://travis-ci.org/lepture/mistune
     :alt: Travis CI Status
  .. image:: https://coveralls.io/repos/lepture/mistune/badge.svg?branch=master
     :target: https://coveralls.io/r/lepture/mistune
     :alt: Coverage Status
  .. image:: https://ci.appveyor.com/api/projects/status/8ai8tfwp75oela17?svg=true
     :target: https://ci.appveyor.com/project/lepture/mistune
     :alt: App Veyor CI Status

  .. _marked: https://github.com/chjj/marked


  Features
  --------

  * **Pure Python**. Tested in Python 2.7, Python 3.5+ and PyPy.
  * **Very Fast**. It is the fastest in all **pure Python** markdown parsers.
  * **More Features**. Table, footnotes, autolink, fenced code etc.

  View the `benchmark results <https://github.com/lepture/mistune/issues/1>`_.

  Installation
  ------------

  Installing mistune with pip::

      $ pip install mistune


  Mistune can be faster, if you compile with cython::

      $ pip install cython mistune


  Basic Usage
  -----------

  A simple API that render a markdown formatted text:

  .. code:: python

      import mistune

      mistune.markdown('I am using **mistune markdown parser**')
      

  If you care about performance, it is better to re-use the Markdown instance:

  .. code:: python

      import mistune

      markdown = mistune.Markdown()
      markdown('I am using **mistune markdown parser**')

  Mistune has enabled all features by default. You don't have to configure
  anything. But there are options for you to change the parser behaviors.


  Options
  -------

  Here is a list of all options that will affect the rendering results,
  configure them with ``mistune.Renderer``:

  .. code:: python

      renderer = mistune.Renderer(escape=True, hard_wrap=True)
      
      markdown = mistune.Markdown(renderer=renderer)
      markdown(text)

  * **escape**: if set to *False*, all raw html tags will not be escaped.
  * **hard_wrap**: if set to *True*, it will has GFM line breaks feature.
    All new lines will be replaced with ``<br>`` tag
  * **use_xhtml**: if set to *True*, all tags will be in xhtml, for example: ``<hr />``.
  * **parse_block_html**: parse text only in block level html.
  * **parse_inline_html**: parse text only in inline level html.

  When using the default renderer, you can use one of the following shortcuts::

      mistune.markdown(text, escape=True, hard_wrap=True)

      markdown = mistune.Markdown(escape=True, hard_wrap=True)
      markdown(text)


  Renderer
  --------

  Like misaka/sundown, you can influence the rendering by custom renderers.
  All you need to do is subclassing a `Renderer` class.

  Here is an example of code highlighting:

  .. code:: python

      import mistune
      from pygments import highlight
      from pygments.lexers import get_lexer_by_name
      from pygments.formatters import html

      class HighlightRenderer(mistune.Renderer):
          def block_code(self, code, lang):
              if not lang:
                  return '\n<pre><code>%s</code></pre>\n' % \
                      mistune.escape(code)
              lexer = get_lexer_by_name(lang, stripall=True)
              formatter = html.HtmlFormatter()
              return highlight(code, lexer, formatter)

      renderer = HighlightRenderer()
      markdown = mistune.Markdown(renderer=renderer)
      print(markdown('```python\nassert 1 == 1\n```'))

  Find more renderers in `mistune-contrib`_.

  Block Level
  ~~~~~~~~~~~

  Here is a list of block level renderer API::

      block_code(code, language=None)
      block_quote(text)
      block_html(html)
      header(text, level, raw=None)
      hrule()
      list(body, ordered=True)
      list_item(text)
      paragraph(text)
      table(header, body)
      table_row(content)
      table_cell(content, **flags)

  The *flags* tells you whether it is header with ``flags['header']``. And it
  also tells you the align with ``flags['align']``.


  Span Level
  ~~~~~~~~~~

  Here is a list of span level renderer API::

      autolink(link, is_email=False)
      codespan(text)
      double_emphasis(text)
      emphasis(text)
      image(src, title, alt_text)
      linebreak()
      newline()
      link(link, title, content)
      strikethrough(text)
      text(text)
      inline_html(text)

  Footnotes
  ~~~~~~~~~

  Here is a list of renderers related to footnotes::

      footnote_ref(key, index)
      footnote_item(key, text)
      footnotes(text)

  Lexers
  ------

  Sometimes you want to add your own rules to Markdown, such as GitHub Wiki
  links. You can't achieve this goal with renderers. You will need to deal
  with the lexers, it would be a little difficult for the first time.

  We will take an example for GitHub Wiki links: ``[[Page 2|Page 2]]``.
  It is an inline grammar, which requires custom ``InlineGrammar`` and
  ``InlineLexer``:

  .. code:: python

      import copy,re
      from mistune import Renderer, InlineGrammar, InlineLexer

      class WikiLinkRenderer(Renderer):
          def wiki_link(self, alt, link):
              return '<a href="%s">%s</a>' % (link, alt)

      class WikiLinkInlineLexer(InlineLexer):
          def enable_wiki_link(self):
              
              self.rules.wiki_link = re.compile(
                  r'\[\['                   # [[
                  r'([\s\S]+?\|[\s\S]+?)'   # Page 2|Page 2
                  r'\]\](?!\])'             # ]]
              )

              
              
              
              self.default_rules.insert(3, 'wiki_link')

          def output_wiki_link(self, m):
              text = m.group(1)
              alt, link = text.split('|')
              
              
              return self.renderer.wiki_link(alt, link)

  You should pass the inline lexer to ``Markdown`` parser:

  .. code:: python

      renderer = WikiLinkRenderer()
      inline = WikiLinkInlineLexer(renderer)
      
      inline.enable_wiki_link()
      markdown = Markdown(renderer, inline=inline)
      markdown('[[Link Text|Wiki Link]]')

  It is the same with block level lexer. It would take a while to understand
  the whole mechanism. But you won't do the trick a lot.


  Contribution & Extensions
  -------------------------

  Mistune itself doesn't accept any extension. It will always be a simple one
  file script.

  If you want to add features, you can head over to `mistune-contrib`_.

  Here are some extensions already in `mistune-contrib`_:

  * Math/MathJax features
  * Highlight Code Renderer
  * TOC table of content features
  * MultiMarkdown Metadata parser

  Get inspired with the contrib repository.

  .. _`mistune-contrib`: https://github.com/lepture/mistune-contrib


pkgId: 41448e1dd760e0754930099e9d28cbe80f02d674ed77eed2bf6b9404849387c3
name: rh-python36-monotonic
arch: noarch
version: 1.5
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: Ori Livneh <ori@wikimedia.org>
rpm_group: Development/Libraries
rpm_buildhost: 62efcbc4ccd34a5b86b71623aa68a5f3
rpm_sourcerpm: rh-python36-monotonic-1.5-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00929393-rh-python36-monotonic/rh-python36-monotonic-1.5-1.noarch.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: a4958b111485c36f71224ec3ba4ef165e3ea78e15fee3c83af3e2b17a332f860
name: rh-python36-more-itertools
arch: noarch
version: 8.2.0
epoch: 0
release: 1
summary: More routines for operating on iterables, beyond itertools
url: https://github.com/erikrose/more-itertools
rpm_license: MIT
rpm_vendor: Erik Rose <erikrose@grinchcentral.com>
rpm_group: Development/Libraries
rpm_buildhost: 4dacd616faac40d5a90315b0693cc7ad
rpm_sourcerpm: rh-python36-more-itertools-8.2.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311594-rh-python36-more-itertools/rh-python36-more-itertools-8.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ==============
  More Itertools
  ==============

  .. image:: https://coveralls.io/repos/github/erikrose/more-itertools/badge.svg?branch=master
    :target: https://coveralls.io/github/erikrose/more-itertools?branch=master

  Python's ``itertools`` library is a gem - you can compose elegant solutions
  for a variety of problems with the functions it provides. In ``more-itertools``
  we collect additional building blocks, recipes, and routines for working with
  Python iterables.

  Getting started
  ===============

  To get started, install the library with `pip <https://pip.pypa.io/en/stable/>`_:

  .. code-block:: shell

      pip install more-itertools

  The recipes from the `itertools docs <https://docs.python.org/3/library/itertools.html#itertools-recipes>`_
  are included in the top-level package:

  .. code-block:: python

      >>> from more_itertools import flatten
      >>> iterable = [(0, 1), (2, 3)]
      >>> list(flatten(iterable))
      [0, 1, 2, 3]

  Several new recipes are available as well:

  .. code-block:: python

      >>> from more_itertools import chunked
      >>> iterable = [0, 1, 2, 3, 4, 5, 6, 7, 8]
      >>> list(chunked(iterable, 3))
      [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

      >>> from more_itertools import spy
      >>> iterable = (x * x for x in range(1, 6))
      >>> head, iterable = spy(iterable, n=3)
      >>> list(head)
      [1, 4, 9]
      >>> list(iterable)
      [1, 4, 9, 16, 25]



  For the full listing of functions, see the `API documentation <https://more-itertools.readthedocs.io/en/latest/api.html>`_.

  Development
  ===========

  ``more-itertools`` is maintained by `@erikrose <https://github.com/erikrose>`_
  and `@bbayles <https://github.com/bbayles>`_, with help from `many others <https://github.com/erikrose/more-itertools/graphs/contributors>`_.
  If you have a problem or suggestion, please file a bug or pull request in this
  repository. Thanks for contributing!


  Version History
  ===============



  4.1.0
  -----

  * New itertools:
      * split_at (thanks to michael-celani)
      * circular_shifts (thanks to hiqua)
      * make_decorator - see the blog post `Yo, I heard you like decorators <https://sites.google.com/site/bbayles/index/decorator_factory>`_
        for a tour (thanks to pylang)
      * always_reversible (thanks to michael-celani)
      * nth_combination (from the `Python 3.7 docs <https://docs.python.org/3.7/library/itertools.html#itertools-recipes>`_)

  * Improvements to existing itertools:
      * seekable now has an ``elements`` method to return cached items.
      * The performance tradeoffs between roundrobin and
        interleave_longest are now documented (thanks michael-celani,
        pylang, and MSeifert04)

  4.0.1
  -----

  * No code changes - this release fixes how the docs display on PyPI.

  4.0.0
  -----

  * New itertools:
      * consecutive_groups (Based on the example in the `Python 2.4 docs <https://docs.python.org/release/2.4.4/lib/itertools-example.html>`_)
      * seekable (If you're looking for how to "reset" an iterator,
        you're in luck!)
      * exactly_n (thanks to michael-celani)
      * run_length.encode and run_length.decode
      * difference

  * Improvements to existing itertools:
      * The number of items between filler elements in intersperse can
        now be specified (thanks to pylang)
      * distinct_permutations and peekable got some minor
        adjustments (thanks to MSeifert04)
      * always_iterable now returns an iterator object. It also now
        allows different types to be considered iterable (thanks to jaraco)
      * bucket can now limit the keys it stores in memory
      * one now allows for custom exceptions (thanks to kalekundert)

  * Other changes:
      * A few typos were fixed (thanks to EdwardBetts)
      * All tests can now be run with ``python setup.py test``

  The major version update is due to the change in the return value of always_iterable.
  It now always returns iterator objects:

  .. code-block:: python

      >>> from more_itertools import always_iterable
      
      >>> always_iterable(12345)
      <tuple_iterator object at 0x7fb24c9488d0>
      >>> list(always_iterable(12345))
      [12345]
      
      >>> always_iterable([1, 2, 3, 4, 5])
      <list_iterator object at 0x7fb24c948c50>

  3.2.0
  -----

  * New itertools:
      * lstrip, rstrip, and strip
        (thanks to MSeifert04 and pylang)
      * islice_extended
  * Improvements to existing itertools:
      * Some bugs with slicing peekable-wrapped iterables were fixed

  3.1.0
  -----

  * New itertools:
      * numeric_range (Thanks to BebeSparkelSparkel and MSeifert04)
      * count_cycle (Thanks to BebeSparkelSparkel)
      * locate (Thanks to pylang and MSeifert04)
  * Improvements to existing itertools:
      * A few itertools are now slightly faster due to some function
        optimizations. (Thanks to MSeifert04)
  * The docs have been substantially revised with installation notes,
    categories for library functions, links, and more. (Thanks to pylang)


  3.0.0
  -----

  * Removed itertools:
      * ``context`` has been removed due to a design flaw - see below for
        replacement options. (thanks to NeilGirdhar)
  * Improvements to existing itertools:
      * ``side_effect`` now supports ``before`` and ``after`` keyword
        arguments. (Thanks to yardsale8)
  * PyPy and PyPy3 are now supported.

  The major version change is due to the removal of the ``context`` function.
  Replace it with standard ``with`` statement context management:

  .. code-block:: python

      
      file_obj = StringIO()
      consume(print(x, file=f) for f in context(file_obj) for x in u'123')

      
      file_obj = StringIO()
      with file_obj as f:
          consume(print(x, file=f) for x in u'123')

  2.6.0
  -----

  * New itertools:
      * ``adjacent`` and ``groupby_transform`` (Thanks to diazona)
      * ``always_iterable`` (Thanks to jaraco)
      * (Removed in 3.0.0) ``context`` (Thanks to yardsale8)
      * ``divide`` (Thanks to mozbhearsum)
  * Improvements to existing itertools:
      * ``ilen`` is now slightly faster. (Thanks to wbolster)
      * ``peekable`` can now prepend items to an iterable. (Thanks to diazona)

  2.5.0
  -----

  * New itertools:
      * ``distribute`` (Thanks to mozbhearsum and coady)
      * ``sort_together`` (Thanks to clintval)
      * ``stagger`` and ``zip_offset`` (Thanks to joshbode)
      * ``padded``
  * Improvements to existing itertools:
      * ``peekable`` now handles negative indexes and slices with negative
        components properly.
      * ``intersperse`` is now slightly faster. (Thanks to pylang)
      * ``windowed`` now accepts a ``step`` keyword argument.
        (Thanks to pylang)
  * Python 3.6 is now supported.

  2.4.1
  -----

  * Move docs 100% to readthedocs.io.

  2.4
  -----

  * New itertools:
      * ``accumulate``, ``all_equal``, ``first_true``, ``partition``, and
        ``tail`` from the itertools documentation.
      * ``bucket`` (Thanks to Rosuav and cvrebert)
      * ``collapse`` (Thanks to abarnet)
      * ``interleave`` and ``interleave_longest`` (Thanks to abarnet)
      * ``side_effect`` (Thanks to nvie)
      * ``sliced`` (Thanks to j4mie and coady)
      * ``split_before`` and ``split_after`` (Thanks to astronouth7303)
      * ``spy`` (Thanks to themiurgo and mathieulongtin)
  * Improvements to existing itertools:
      * ``chunked`` is now simpler and more friendly to garbage collection.
        (Contributed by coady, with thanks to piskvorky)
      * ``collate`` now delegates to ``heapq.merge`` when possible.
        (Thanks to kmike and julianpistorius)
      * ``peekable``-wrapped iterables are now indexable and sliceable.
        Iterating through ``peekable``-wrapped iterables is also faster.
      * ``one`` and ``unique_to_each`` have been simplified.
        (Thanks to coady)


  2.3
  -----

  * Added ``one`` from ``jaraco.util.itertools``. (Thanks, jaraco!)
  * Added ``distinct_permutations`` and ``unique_to_each``. (Contributed by
    bbayles)
  * Added ``windowed``. (Contributed by bbayles, with thanks to buchanae,
    jaraco, and abarnert)
  * Simplified the implementation of ``chunked``. (Thanks, nvie!)
  * Python 3.5 is now supported. Python 2.6 is no longer supported.
  * Python 3 is now supported directly; there is no 2to3 step.

  2.2
  -----

  * Added ``iterate`` and ``with_iter``. (Thanks, abarnert!)

  2.1
  -----

  * Added (tested!) implementations of the recipes from the itertools
    documentation. (Thanks, Chris Lonnen!)
  * Added ``ilen``. (Thanks for the inspiration, Matt Basta!)

  2.0
  -----

  * ``chunked`` now returns lists rather than tuples. After all, they're
    homogeneous. This slightly backward-incompatible change is the reason for
    the major version bump.
  * Added ``@consumer``.
  * Improved test machinery.

  1.1
  -----

  * Added ``first`` function.
  * Added Python 3 support.
  * Added a default arg to ``peekable.peek()``.
  * Noted how to easily test whether a peekable iterator is exhausted.
  * Rewrote documentation.

  1.0
  -----

  * Initial release, with ``collate``, ``peekable``, and ``chunked``. Could
    really use better docs.


pkgId: 91bc3b48abc235303206bddfcbf94748121ccd77d1fec4137f02857133842aa7
name: rh-python36-msgpack
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: MessagePack (de)serializer.
url: https://msgpack.org/
rpm_license: Apache 2.0
rpm_vendor: INADA Naoki <songofacandy@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: ceb5b05e15ac48b0a1e90beb46237e67
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311574-rh-python36-msgpack/rh-python36-msgpack-0.6.2-1.src.rpm
checksum_type: sha256
description:
  ======================
  MessagePack for Python
  ======================

  .. image:: https://travis-ci.org/msgpack/msgpack-python.svg?branch=master
     :target: https://travis-ci.org/msgpack/msgpack-python
     :alt: Build Status

  .. image:: https://readthedocs.org/projects/msgpack-python/badge/?version=latest
     :target: https://msgpack-python.readthedocs.io/en/latest/?badge=latest
     :alt: Documentation Status


  What's this
  -----------

  `MessagePack <https://msgpack.org/>`_ is an efficient binary serialization format.
  It lets you exchange data among multiple languages like JSON.
  But it's faster and smaller.
  This package provides CPython bindings for reading and writing MessagePack data.


  Very important notes for existing users
  ---------------------------------------

  PyPI package name
  ^^^^^^^^^^^^^^^^^

  TL;DR: When upgrading from msgpack-0.4 or earlier, don't do `pip install -U msgpack-python`.
  Do `pip uninstall msgpack-python; pip install msgpack` instead.

  Package name on PyPI was changed to msgpack from 0.5.
  I upload transitional package (msgpack-python 0.5 which depending on msgpack)
  for smooth transition from msgpack-python to msgpack.

  Sadly, this doesn't work for upgrade install.  After `pip install -U msgpack-python`,
  msgpack is removed and `import msgpack` fail.


  Deprecating encoding option
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  encoding and unicode_errors options are deprecated.

  In case of packer, use UTF-8 always.  Storing other than UTF-8 is not recommended.

  For backward compatibility, you can use ``use_bin_type=False`` and pack ``bytes``
  object into msgpack raw type.

  In case of unpacker, there is new ``raw`` option.  It is ``True`` by default
  for backward compatibility, but it is changed to ``False`` in near future.
  You can use ``raw=False`` instead of ``encoding='utf-8'``.

  Planned backward incompatible changes
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  When msgpack 1.0, I planning these breaking changes:

  * packer and unpacker: Remove ``encoding`` and ``unicode_errors`` option.
  * packer: Change default of ``use_bin_type`` option from False to True.
  * unpacker: Change default of ``raw`` option from True to False.
  * unpacker: Reduce all ``max_xxx_len`` options for typical usage.
  * unpacker: Remove ``write_bytes`` option from all methods.

  To avoid these breaking changes breaks your application, please:

  * Don't use deprecated options.
  * Pass ``use_bin_type`` and ``raw`` options explicitly.
  * If your application handle large (>1MB) data, specify ``max_xxx_len`` options too.


  Install
  -------

  ::

     $ pip install msgpack

  PyPy
  ^^^^

  msgpack provides a pure Python implementation.  PyPy can use this.

  Windows
  ^^^^^^^

  When you can't use a binary distribution, you need to install Visual Studio
  or Windows SDK on Windows.
  Without extension, using pure Python implementation on CPython runs slowly.

  For Python 2.7, `Microsoft Visual C++ Compiler for Python 2.7 <https://www.microsoft.com/en-us/download/details.aspx?id=44266>`_
  is recommended solution.

  For Python 3.5, `Microsoft Visual Studio 2015 <https://www.visualstudio.com/en-us/products/vs-2015-product-editions.aspx>`_
  Community Edition or Express Edition can be used to build extension module.


  How to use
  ----------

  One-shot pack & unpack
  ^^^^^^^^^^^^^^^^^^^^^^

  Use ``packb`` for packing and ``unpackb`` for unpacking.
  msgpack provides ``dumps`` and ``loads`` as an alias for compatibility with
  ``json`` and ``pickle``.

  ``pack`` and ``dump`` packs to a file-like object.
  ``unpack`` and ``load`` unpacks from a file-like object.

  .. code-block:: pycon

     >>> import msgpack
     >>> msgpack.packb([1, 2, 3], use_bin_type=True)
     '\x93\x01\x02\x03'
     >>> msgpack.unpackb(_, raw=False)
     [1, 2, 3]

  ``unpack`` unpacks msgpack's array to Python's list, but can also unpack to tuple:

  .. code-block:: pycon

     >>> msgpack.unpackb(b'\x93\x01\x02\x03', use_list=False, raw=False)
     (1, 2, 3)

  You should always specify the ``use_list`` keyword argument for backward compatibility.
  See performance issues relating to `use_list option`_ below.

  Read the docstring for other options.


  Streaming unpacking
  ^^^^^^^^^^^^^^^^^^^

  ``Unpacker`` is a "streaming unpacker". It unpacks multiple objects from one
  stream (or from bytes provided through its ``feed`` method).

  .. code-block:: python

     import msgpack
     from io import BytesIO

     buf = BytesIO()
     for i in range(100):
        buf.write(msgpack.packb(i, use_bin_type=True))

     buf.seek(0)

     unpacker = msgpack.Unpacker(buf, raw=False)
     for unpacked in unpacker:
         print(unpacked)


  Packing/unpacking of custom data type
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  It is also possible to pack/unpack custom data types. Here is an example for
  ``datetime.datetime``.

  .. code-block:: python

      import datetime
      import msgpack

      useful_dict = {
          "id": 1,
          "created": datetime.datetime.now(),
      }

      def decode_datetime(obj):
          if b'__datetime__' in obj:
              obj = datetime.datetime.strptime(obj["as_str"], "%Y%m%dT%H:%M:%SOURCE.%f")
          return obj

      def encode_datetime(obj):
          if isinstance(obj, datetime.datetime):
              return {'__datetime__': True, 'as_str': obj.strftime("%Y%m%dT%H:%M:%SOURCE.%f")}
          return obj


      packed_dict = msgpack.packb(useful_dict, default=encode_datetime, use_bin_type=True)
      this_dict_again = msgpack.unpackb(packed_dict, object_hook=decode_datetime, raw=False)

  ``Unpacker``'s ``object_hook`` callback receives a dict; the
  ``object_pairs_hook`` callback may instead be used to receive a list of
  key-value pairs.


  Extended types
  ^^^^^^^^^^^^^^

  It is also possible to pack/unpack custom data types using the **ext** type.

  .. code-block:: pycon

      >>> import msgpack
      >>> import array
      >>> def default(obj):
      ...     if isinstance(obj, array.array) and obj.typecode == 'd':
      ...         return msgpack.ExtType(42, obj.tostring())
      ...     raise TypeError("Unknown type: %r" % (obj,))
      ...
      >>> def ext_hook(code, data):
      ...     if code == 42:
      ...         a = array.array('d')
      ...         a.fromstring(data)
      ...         return a
      ...     return ExtType(code, data)
      ...
      >>> data = array.array('d', [1.2, 3.4])
      >>> packed = msgpack.packb(data, default=default, use_bin_type=True)
      >>> unpacked = msgpack.unpackb(packed, ext_hook=ext_hook, raw=False)
      >>> data == unpacked
      True


  Advanced unpacking control
  ^^^^^^^^^^^^^^^^^^^^^^^^^^

  As an alternative to iteration, ``Unpacker`` objects provide ``unpack``,
  ``skip``, ``read_array_header`` and ``read_map_header`` methods. The former two
  read an entire message from the stream, respectively de-serialising and returning
  the result, or ignoring it. The latter two methods return the number of elements
  in the upcoming container, so that each element in an array, or key-value pair
  in a map, can be unpacked or skipped individually.

  Each of these methods may optionally write the packed data it reads to a
  callback function:

  .. code-block:: python

      from io import BytesIO

      def distribute(unpacker, get_worker):
          nelems = unpacker.read_map_header()
          for i in range(nelems):
              
              key = unpacker.unpack()
              worker = get_worker(key)

              
              bytestream = BytesIO()
              unpacker.skip(bytestream.write)
              worker.send(bytestream.getvalue())


  Notes
  -----

  string and binary type
  ^^^^^^^^^^^^^^^^^^^^^^

  Early versions of msgpack didn't distinguish string and binary types (like Python 1).
  The type for representing both string and binary types was named **raw**.

  For backward compatibility reasons, msgpack-python will still default all
  strings to byte strings, unless you specify the ``use_bin_type=True`` option in
  the packer. If you do so, it will use a non-standard type called **bin** to
  serialize byte arrays, and **raw** becomes to mean **str**. If you want to
  distinguish **bin** and **raw** in the unpacker, specify ``raw=False``.

  Note that Python 2 defaults to byte-arrays over Unicode strings:

  .. code-block:: pycon

      >>> import msgpack
      >>> msgpack.unpackb(msgpack.packb([b'spam', u'eggs']))
      ['spam', 'eggs']
      >>> msgpack.unpackb(msgpack.packb([b'spam', u'eggs'], use_bin_type=True),
                          raw=False)
      ['spam', u'eggs']

  This is the same code in Python 3 (same behaviour, but Python 3 has a
  different default):

  .. code-block:: pycon

      >>> import msgpack
      >>> msgpack.unpackb(msgpack.packb([b'spam', u'eggs']))
      [b'spam', b'eggs']
      >>> msgpack.unpackb(msgpack.packb([b'spam', u'eggs'], use_bin_type=True),
                          raw=False)
      [b'spam', 'eggs']


  ext type
  ^^^^^^^^

  To use the **ext** type, pass ``msgpack.ExtType`` object to packer.

  .. code-block:: pycon

      >>> import msgpack
      >>> packed = msgpack.packb(msgpack.ExtType(42, b'xyzzy'))
      >>> msgpack.unpackb(packed)
      ExtType(code=42, data='xyzzy')

  You can use it with ``default`` and ``ext_hook``. See below.


  Note about performance
  ----------------------

  GC
  ^^

  CPython's GC starts when growing allocated object.
  This means unpacking may cause useless GC.
  You can use ``gc.disable()`` when unpacking large message.

  use_list option
  ^^^^^^^^^^^^^^^

  List is the default sequence type of Python.
  But tuple is lighter than list.
  You can use ``use_list=False`` while unpacking when performance is important.

  Python's dict can't use list as key and MessagePack allows array for key of mapping.
  ``use_list=False`` allows unpacking such message.
  Another way to unpacking such object is using ``object_pairs_hook``.


  Development
  -----------

  Test
  ^^^^

  MessagePack uses `pytest` for testing.
  Run test with following command:

      $ make test


  ..
      vim: filetype=rst


pkgId: b0db97336f2bcd1c617847faefe4e1c6d9aaf3ded7948ad51b09883d13983b54
name: rh-python36-msgpack-debuginfo
arch: x86_64
version: 0.6.2
epoch: 0
release: 1
summary: Debug information for package rh-python36-msgpack
url: https://msgpack.org/
rpm_license: Apache 2.0
rpm_vendor: INADA Naoki <songofacandy@gmail.com>
rpm_group: Development/Debug
rpm_buildhost: ce2bb1070afd42ba8fd723a3915978f3
rpm_sourcerpm: rh-python36-msgpack-0.6.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311574-rh-python36-msgpack/rh-python36-msgpack-debuginfo-0.6.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-msgpack.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 723844ac38ac7221c6b8ec69e128f8ba56a341e2517f4f68b3d73f55787998a3
name: rh-python36-msgpack-python-debuginfo
arch: x86_64
version: 0.5.6
epoch: 0
release: 1
summary: Debug information for package rh-python36-msgpack-python
url: http://msgpack.org/
rpm_license: Apache 2.0
rpm_vendor: INADA Naoki <songofacandy@gmail.com>
rpm_group: Development/Debug
rpm_buildhost: 2ab7fd07cf224e9cbfa222dcafd9f310
rpm_sourcerpm: rh-python36-msgpack-python-0.5.6-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00888138-rh-python36-msgpack-python/rh-python36-msgpack-python-debuginfo-0.5.6-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-msgpack-python.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 80e8327bc29de1790bede2fcc802aed8880e956ceef4825e701ec2d47b7502b3
name: rh-python36-msrest
arch: noarch
version: 0.6.11
epoch: 0
release: 1
summary: AutoRest swagger generator Python client runtime.
url: https://github.com/Azure/msrest-for-python
rpm_license: MIT License
rpm_vendor: Microsoft Corporation <UNKNOWN>
rpm_group: Development/Libraries
rpm_buildhost: 3d266c7ee6314b7195371feaea3211ab
rpm_sourcerpm: rh-python36-msrest-0.6.11-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01212949-rh-python36-msrest/rh-python36-msrest-0.6.11-1.noarch.rpm
checksum_type: sha256
description:
  AutoRest: Python Client Runtime
  ===============================

  .. image:: https://travis-ci.org/Azure/msrest-for-python.svg?branch=master
   :target: https://travis-ci.org/Azure/msrest-for-python

  .. image:: https://codecov.io/gh/azure/msrest-for-python/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/azure/msrest-for-python

  Installation
  ------------

  To install:

  .. code-block:: bash

      $ pip install msrest


  Release History
  ---------------

  2018-04-30 Version 0.4.29
  +++++++++++++++++++++++++

  - Improve `SDKClient.__exit__` to take exc_details as optional parameters and not required

  2018-04-18 Version 0.4.28
  +++++++++++++++++++++++++

  **Features**

  - msrest is now able to keep the "requests.Session" alive for performance. To activate this behavior:

    - Use the final Client as a context manager (requires generation with Autorest.Python 3.0.50 at least)
    - Use `client.config.keep_alive = True` and `client.close()` (requires generation with Autorest.Python 3.0.50 at least)
    - Use `client.config.keep_alive = True` and client._client.close() (not recommended, but available in old releases of SDK)

  - All Authentication classes now define `signed_session` and `refresh_session` with an optional `session` parameter.
    To take benefits of the session improvement, a subclass of Authentication *MUST* add this optional parameter
    and use it if it's not `None`:

       def signed_session(self, session=None):
           session = session or requests.Session()

           

  2018-03-07 Version 0.4.27
  +++++++++++++++++++++++++

  **Features**

  - Disable HTTP log by default (security), add `enable_http_log` to restore it #86

  **BugFixes**

  - Fix incorrect date parsing if ms precision is over 6 digits #82

  2018-01-30 Version 0.4.26
  +++++++++++++++++++++++++

  **Features**

  - Add TopicCredentials for EventGrid client

  **Bugfixes**

  - Fix minimal dependency of isodate
  - Fix serialisation from dict if datetime provided

  2018-01-08 Version 0.4.25
  +++++++++++++++++++++++++

  **Features**

  - Add LROPoller class. This is a customizable LRO engine.
    This is the poller engine of Autorest.Python 3.0, and is not used by code generated by previous Autorest version.

  2018-01-03 Version 0.4.24
  +++++++++++++++++++++++++

  **Bugfixes**

  - Date parsing is now compliant with Autorest / Swagger 2.0 specification (less lenient)

  **Internal optimisation**

  - Call that does not return a streamable object are now executed in requests stream mode False (was True whatever the type of the call).
    This should reduce the number of leaked opened session and allow urllib3 to manage connection pooling more efficiently.
    Only clients generated with Autorest.Python >= 2.1.31 (not impacted otherwise, fully backward compatible)

  2017-12-21 Version 0.4.23
  +++++++++++++++++++++++++

  **Bugfixes**

  - Accept to deserialize enum of different type if content string match #75
  - Stop failing on deserialization if enum string is unkwon. Return the string instead.

  **Features**

  - Model now accept kwargs in constructor for future kwargs models

  2017-12-15 Version 0.4.22
  +++++++++++++++++++++++++

  **Bugfixes**

  - Do not validate additional_properties #73
  - Improve validation error if expected type is dict, but actual type is not #73

  2017-12-14 Version 0.4.21
  +++++++++++++++++++++++++

  **Bugfixes**

  - Fix additional_properties if Swagger was flatten #72

  2017-12-13 Version 0.4.20
  +++++++++++++++++++++++++

  **Features**

  - Add support for additional_properties

    - By default, all additional_properties are kept.
    - Additional properties are sent to the server only if it was specified in the Swagger,
      or if "enable_additional_properties_sending" is called on the model we want it.
      This is a class method that enables it for all instance of this model.

  2017-11-20 Version 0.4.19
  +++++++++++++++++++++++++

  **Features**

  - The interpretation of Swagger 2.0 "discriminator" is now lenient. This means for these two scenarios:

    - Discriminator value is missing from the received payload
    - Discriminator value is not defined in the Swagger

    Instead of failing with an exception, this now returns the base type for this "discriminator".

    Note that this is not a contradiction of the Swagger 2.0 spec, that specifies
    "validation SHOULD fail [...] there may exist valid reasons in particular circumstances to ignore a particular item,
    but the full implications must be understood and carefully weighed before choosing a different course."

    This cannot be configured for now and is the new default behvaior, but can be in the future if needed.

  **Bugfixes**

  - Optional formdata parameters were raising an exception (#65)
  - "application/x-www-form-urlencoded" form was sent using "multipart/form-data".
    This causes problems if the server does not support "multipart/form-data" (#66)

  2017-10-26 Version 0.4.18
  +++++++++++++++++++++++++

  **Features**

  - Add ApiKeyCredentials class. This can be used to support OpenAPI ApiKey feature.
  - Add CognitiveServicesAuthentication class. Pre-declared ApiKeyCredentials class for Cognitive Services.

  2017-10-12 Version 0.4.17
  +++++++++++++++++++++++++

  **Features**

  This make Authentication classes more consistent:

  - OAuthTokenAuthentication is now a subclass of BasicTokenAuthentication (was Authentication)
  - BasicTokenAuthentication has now a "set_token" methods that does nothing.

  This allows test like "isintance(o, BasicTokenAuthentication)" to be guaranted that the following attributes exists:

  - token
  - set_token()
  - signed_session()

  This means for users of "msrestazure", that they are guaranted that all AD classes somehow inherits from "BasicTokenAuthentication"

  2017-10-05 Version 0.4.16
  +++++++++++++++++++++++++

  **Bugfixes**

  - Fix regression: accept "set<str>" as a valid "[str]" (#60)

  2017-09-28 Version 0.4.15
  +++++++++++++++++++++++++

  **Bugfixes**

  - Always log response body (#16)
  - Improved exception message if error JSON is Odata v4 (#55)
  - Refuse "str" as a valid "[str]" type (#41)
  - Better exception handling if input from server is not JSON valid

  **Features**

  - Add Configuration.session_configuration_callback to customize the requests.Session if necessary (#52)
  - Add a flag to Serializer to disable client-side-validation (#51)
  - Remove "import requests" from "exceptions.py" for apps that require fast loading time (#23)

  Thank you to jayden-at-arista for his contribution

  2017-08-23 Version 0.4.14
  +++++++++++++++++++++++++

  **Bugfixes**

  - Fix regression introduced in msrest 0.4.12 - dict syntax with enum modeled as string and enum used

  2017-08-22 Version 0.4.13
  +++++++++++++++++++++++++

  **Bugfixes**

  - Fix regression introduced in msrest 0.4.12 - dict syntax using isodate.Duration (#42)

  2017-08-21 Version 0.4.12
  +++++++++++++++++++++++++

  **Features**

  - Input is now more lenient
  - Model have a "validate" method to check content constraints
  - Model have now 4 new methods:

    - "serialize" that gives the RestAPI that will be sent
    - "as_dict" that returns a dict version of the Model. Callbacks are available.
    - "deserialize" the parses the RestAPI JSON into a Model
    - "from_dict" that parses several dict syntax into a Model. Callbacks are available.

  More details and examples in the Wiki article on Github:
  https://github.com/Azure/msrest-for-python/wiki/msrest-0.4.12---Serialization-change

  **Bugfixes**

  - Better Enum checking (#38)

  2017-06-21 Version 0.4.11
  +++++++++++++++++++++++++

  **Bugfixes**

  - Fix incorrect dependency to "requests" 2.14.x, instead of 2.x meant in 0.4.8

  2017-06-15 Version 0.4.10
  +++++++++++++++++++++++++

  **Features**

  - Add requests hooks to configuration

  2017-06-08 Version 0.4.9
  ++++++++++++++++++++++++

  **Bugfixes**

  - Accept "null" value for paging array as an empty list and do not raise (#30)

  2017-05-22 Version 0.4.8
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fix random "pool is closed" error (#29)
  - Fix requests dependency to version 2.x, since version 3.x is annunced to be breaking.

  2017-04-04 Version 0.4.7
  ++++++++++++++++++++++++

  **BugFixes**

  - Refactor paging #22:

     - "next" is renamed "advance_page" and "next" returns only 1 element (Python 2 expected behavior)
     - paging objects are now real generator and support the "next()" built-in function without need for "iter()"

  - Raise accurate DeserialisationError on incorrect RestAPI discriminator usage #27
  - Fix discriminator usage of the base class name #27
  - Remove default mutable arguments in Clients #20
  - Fix object comparison in some scenarios #24

  2017-03-06 Version 0.4.6
  ++++++++++++++++++++++++

  **Bugfixes**

  - Allow Model sub-classes to be serialized if type is "object"

  2017-02-13 Version 0.4.5
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fix polymorphic deserialization #11
  - Fix regexp validation if '\\w' is used in Python 2.7 #13
  - Fix dict deserialization if keys are unicode in Python 2.7

  **Improvements**

  - Add polymorphic serialisation from dict objects
  - Remove chardet and use HTTP charset declaration (fallback to utf8)

  2016-09-14 Version 0.4.4
  ++++++++++++++++++++++++

  **Bugfixes**

  - Remove paging URL validation, part of fix https://github.com/Azure/autorest/pull/1420

  **Disclaimer**

  In order to get paging fixes for impacted clients, you need this package and Autorest > 0.17.0 Nightly 20160913

  2016-09-01 Version 0.4.3
  ++++++++++++++++++++++++

  **Bugfixes**

  - Better exception message (https://github.com/Azure/autorest/pull/1300)

  2016-08-15 Version 0.4.2
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fix serialization if "object" type contains None (https://github.com/Azure/autorest/issues/1353)

  2016-08-08 Version 0.4.1
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fix compatibility issues with requests 2.11.0 (https://github.com/Azure/autorest/issues/1337)
  - Allow url of ClientRequest to have parameters (https://github.com/Azure/autorest/issues/1217)

  2016-05-25 Version 0.4.0
  ++++++++++++++++++++++++

  This version has no bug fixes, but implements new features of Autorest:
  - Base64 url type
  - unixtime type
  - x-ms-enum modelAsString flag

  **Behaviour changes**

  - Add Platform information in UserAgent
  - Needs Autorest > 0.17.0 Nightly 20160525

  2016-04-26 Version 0.3.0
  ++++++++++++++++++++++++

  **Bugfixes**

  - Read only values are no longer in __init__ or sent to the server (https://github.com/Azure/autorest/pull/959)
  - Useless kwarg removed

  **Behaviour changes**

  - Needs Autorest > 0.16.0 Nightly 20160426


  2016-03-25 Version 0.2.0
  ++++++++++++++++++++++++

  **Bugfixes**

  - Manage integer enum values (https://github.com/Azure/autorest/pull/879)
  - Add missing application/json Accept HTTP header (https://github.com/Azure/azure-sdk-for-python/issues/553)

  **Behaviour changes**

  - Needs Autorest > 0.16.0 Nightly 20160324


  2016-03-21 Version 0.1.3
  ++++++++++++++++++++++++

  **Bugfixes**

  - Deserialisation of generic resource if null in JSON (https://github.com/Azure/azure-sdk-for-python/issues/544)


  2016-03-14 Version 0.1.2
  ++++++++++++++++++++++++

  **Bugfixes**

  - urllib3 side effect (https://github.com/Azure/autorest/issues/824)


  2016-03-04 Version 0.1.1
  ++++++++++++++++++++++++

  **Bugfixes**

  - Source package corrupted in Pypi (https://github.com/Azure/autorest/issues/799)

  2016-03-04 Version 0.1.0
  +++++++++++++++++++++++++

  **Behavioural Changes**

  - Removed custom logging set up and configuration. All loggers are now children of the root logger 'msrest' with no pre-defined configurations.
  - Replaced _required attribute in Model class with more extensive _validation dict.

  **Improvement**

  - Removed hierarchy scanning for attribute maps from base Model class - relies on generator to populate attribute
    maps according to hierarchy.
  - Base class Paged now inherits from collections.Iterable.
  - Data validation during serialization using custom parameters (e.g. max, min etc).
  - Added ValidationError to be raised if invalid data encountered during serialization.

  2016-02-29 Version 0.0.3
  ++++++++++++++++++++++++

  **Bugfixes**

  - Source package corrupted in Pypi (https://github.com/Azure/autorest/issues/718)

  2016-02-19 Version 0.0.2
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fixed bug in exception logging before logger configured.

  2016-02-19 Version 0.0.1
  ++++++++++++++++++++++++

  - Initial release.


pkgId: 9f6fbccd4432be645c6fc0bc2e1af433727a32c9efb8d7f3ddf93a3f81d09646
name: rh-python36-msrestazure
arch: noarch
version: 0.6.3
epoch: 0
release: 1
summary: AutoRest swagger generator Python client runtime. Azure-specific module.
url: https://github.com/Azure/msrestazure-for-python
rpm_license: MIT License
rpm_vendor: Microsoft Corporation <azpysdkhelp@microsoft.com>
rpm_group: Development/Libraries
rpm_buildhost: a34c01c2e892441fa34da0db98623222
rpm_sourcerpm: rh-python36-msrestazure-0.6.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01310516-rh-python36-msrestazure/rh-python36-msrestazure-0.6.3-1.noarch.rpm
checksum_type: sha256
description:
  AutoRest: Python Client Runtime - Azure Module
  ===============================================

  .. image:: https://travis-ci.org/Azure/msrestazure-for-python.svg?branch=master
   :target: https://travis-ci.org/Azure/msrestazure-for-python

  .. image:: https://codecov.io/gh/azure/msrestazure-for-python/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/azure/msrestazure-for-python

  Installation
  ------------

  To install:

  .. code-block:: bash

      $ pip install msrestazure


  Release History
  ---------------

  2018-05-17 Version 0.4.31
  +++++++++++++++++++++++++

  **Features**

  - Improve MSI for VM token polling algorithm

  2018-05-16 Version 0.4.30
  +++++++++++++++++++++++++

  **Features**

  - Allow ADAL 0.5.0 to 2.0.0 excluded as valid ADAL dependency

  2018-04-30 Version 0.4.29
  +++++++++++++++++++++++++

  **Bugfixes**

  - Fix refresh Token on `AADTokenCredentials` (was broken in 0.4.27)
  - Now `UserPasswordCredentials` correctly use the refreshToken, and not user/password to refresh the session (was broken in 0.4.27)
  - Bring back `keyring`, with minimal dependency 12.0.2 that fixes the installation problem on old Python

  2018-04-23 Version 0.4.28
  +++++++++++++++++++++++++

  **Disclaimer**

  Do to some stability issues with "keyring" dependency that highly change from one system to another,
  this package is no longer a dependency of "msrestazure".
  If you were using the secured token cache of `ServicePrincipalCredentials` and `UserPassCredentials`,
  the feature is still available, but you need to install manually "keyring". The functionnality will activate automatically.

  2018-04-18 Version 0.4.27
  +++++++++++++++++++++++++

  **Features**

  - Implements new features of msrest 0.4.28 on session improvement. See msrest ChangeLog for details.

  Update msrest dependency to 0.4.28

  2018-04-17 Version 0.4.26
  +++++++++++++++++++++++++

  **Bugfixes**

  - IMDS/MSI: Retry on more error codes (#87)
  - IMDS/MSI: fix a boundary case on timeout (#86)

  2018-03-29 Version 0.4.25
  +++++++++++++++++++++++++

  **Features**

  - MSIAuthentication now uses IMDS endpoint if available
  - MSIAuthentication can be used in any environment that defines MSI_ENDPOINT env variable

  2018-03-26 Version 0.4.24
  +++++++++++++++++++++++++

  **Bugfix**

  - Fix parse_resource_id() tool to be case-insensitive to keywords when matching #81
  - Add missing baseclass init call for AdalAuthentication #82

  2018-03-19 Version 0.4.23
  +++++++++++++++++++++++++

  **Bugfix**

  - Fix LRO result if POST uses AsyncOperation header (Autorest.Python 3.0 only) #79

  2018-02-27 Version 0.4.22
  +++++++++++++++++++++++++

  **Bugfix**

  - Remove a possible infinite loop with MSIAuthentication #77

  **Disclaimer**

  From this version, MSIAuthentication will fail instantly if you try to get MSI token
  from a VM where the extension is not installed, or not yet ready.
  You need to do your own retry mechanism if you think the extension is provisioning and
  the call might succeed later.
  This behavior is consistent with other Azure SDK implementation of MSI scenarios.

  2018-01-26 Version 0.4.21
  +++++++++++++++++++++++++

  - Update allowed ADAL dependency to 0.5.x

  2018-01-08 Version 0.4.20
  +++++++++++++++++++++++++

  **Features**

  - CloudError now includes the "innererror" attribute to match OData v4 #73
  - Introduces ARMPolling implementation of Azure Resource Management LRO. Requires msrest 0.4.25 (new dependency).
    This is used by code generated with Autorest.Python 3.0, and is not used by code generated by previous Autorest version.
  - Change msrest dependency to ">=0.4.25,<2.0.0" to allow (future) msrest 1.0.0 as compatible dependency.

  Thank you to demyanenko for his contribution.

  2017-12-14 Version 0.4.19
  +++++++++++++++++++++++++

  **Feature**

  * Improve MSIAuthentication to support User Assigned Identity #70

  **Bugfixes**

  * Fix session obj for cloudmetadata endpoint #67
  * Fix authentication resource node for AzureSatck #65
  * Better detection of AppService with MSIAuthentication #70

  2017-12-01 Version 0.4.18
  +++++++++++++++++++++++++

  **Bugfixes**

  - get_cloud_from_metadata_endpoint incorrect on AzureStack #62
  - get_cloud_from_metadata_endpoint certificate issue #61

  2017-11-22 Version 0.4.17
  +++++++++++++++++++++++++

  **Bugfixes**

  - Fix AttributeError if error JSON from ARM does not follow ODatav4 (as it should)

  2017-10-31 Version 0.4.16
  +++++++++++++++++++++++++

  **Bugfixes**

  - Fix AttributeError if input JSON is not a dict (#54)

  2017-10-13 Version 0.4.15
  +++++++++++++++++++++++++

  **Features**

  - Add support for WebApp/Functions in MSIAuthentication classes
  - Add parse_resource_id(), resource_id(), validate_resource_id() to parse ARM ids
  - Retry strategy now n reach 24 seconds (instead of 12 seconds)

  2017-09-11 Version 0.4.14
  +++++++++++++++++++++++++

  **Features**

  - Add Managed Service Integrated (MSI) authentication

  **Bug fix**

  - Fix AdalError handling in some scenarios (#44)

  Thank you to Hexadite-Omer for his contribution

  2017-08-24 Version 0.4.13
  +++++++++++++++++++++++++

  **Features**

  - "keyring" is now completely optional

  2017-08-23 Version 0.4.12
  +++++++++++++++++++++++++

  **Features**

  - add "timeout" to ServicePrincipalCredentials and UserPasswordCredentials
  - Threads created by AzureOperationPoller have now a name prefixed by "AzureOperationPoller" to help identify them

  **Bugfixes**

  - Do not fail if keyring is badly installed
  - Update Azure Gov login endpoint
  - Update metadata ARM endpoint parser

  **Breaking changes**

  - Remove InteractiveCredentials. This class was deprecated and unusable. Use ADAL device code instead.

  2017-06-29 Version 0.4.11
  +++++++++++++++++++++++++

  **Features**

  - Add cloud definitions for public Azure, German Azure, China Azure and Azure Gov
  - Add get_cloud_from_metadata_endpoint to automatically create a Cloud object from an ARM endpoint
  - Add `cloud_environment` to all Credentials objects (except AdalAuthentication)

  **Note**

  - This deprecates "china=True", to be replaced by "cloud_environment=AZURE_CHINA_CLOUD"

  Example:

  .. code:: python

    from msrestazure.azure_cloud import AZURE_CHINA_CLOUD
    from msrestazure.azure_active_directory import UserPassCredentials

    credentials = UserPassCredentials(
        login,
        password,
        cloud_environment=AZURE_CHINA_CLOUD
    )

  `base_url` of SDK client can be pointed to "cloud_environment.endpoints.resource_manager" for basic scenario:

  Example:

  .. code:: python

    from msrestazure.azure_cloud import AZURE_CHINA_CLOUD
    from msrestazure.azure_active_directory import UserPassCredentials
    from azure.mgmt.resource import ResourceManagementClient

    credentials = UserPassCredentials(
        login,
        password,
        cloud_environment=AZURE_CHINA_CLOUD
    )
    client = ResourceManagementClient(
        credentials,
        subscription_id,
        base_url=AZURE_CHINA_CLOUD.endpoints.resource_manager
    )

  Azure Stack connection can be done:

  .. code:: python

    from msrestazure.azure_cloud import get_cloud_from_metadata_endpoint
    from msrestazure.azure_active_directory import UserPassCredentials
    from azure.mgmt.resource import ResourceManagementClient

    mystack_cloud = get_cloud_from_metadata_endpoint("https://myazurestack-arm-endpoint.com")
    credentials = UserPassCredentials(
        login,
        password,
        cloud_environment=mystack_cloud
    )
    client = ResourceManagementClient(
        credentials,
        subscription_id,
        base_url=mystack_cloud.endpoints.resource_manager
    )


  2017-06-27 Version 0.4.10
  +++++++++++++++++++++++++

  **Bugfixes**

  - Accept PATCH/201 as LRO valid state
  - Close token session on exit (ServicePrincipal and UserPassword credentials)

  2017-06-19 Version 0.4.9
  ++++++++++++++++++++++++

  **Features**

  - Add proxies parameters to ServicePrincipal and UserPassword credentials class #29
  - Add automatic Azure provider registration if needed (requires msrest 0.4.10) #28

  Thank you to likel for his contribution

  2017-05-31 Version 0.4.8
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fix LRO if first call never returns 200, but ends on 201 (#26)
  - FiX LRO AttributeError if timeout is short (#21)

  **Features**

  - Expose a "status()" method in AzureOperationPoller (#18)

  2017-01-23 Version 0.4.7
  ++++++++++++++++++++++++

  **Bugfixes**

  - Adding `accept_language` and `generate_client_request_id` default values

  2016-12-12 Version 0.4.6
  ++++++++++++++++++++++++

  **Bugfixes**

  Refactor Long Running Operation algorithm.

  - There is no breaking changes, however you might need to record again your offline HTTP records
    if you use unittests with VCRpy.
  - Fix a couple of latent bugs

  2016-11-30 Version 0.4.5
  ++++++++++++++++++++++++

  **New features**

  - Add AdalAuthentification class to wrap ADAL library (https://github.com/Azure/msrestazure-for-python/pull/8)

  2016-10-17 Version 0.4.4
  ++++++++++++++++++++++++

  **Bugfixes**

  - More informative and well-formed CloudError exceptions (https://github.com/Azure/autorest/issues/1460)
  - Raise CustomException is defined in Swagger (https://github.com/Azure/autorest/issues/1404)

  2016-09-14 Version 0.4.3
  ++++++++++++++++++++++++

  **Bugfixes**

  - Make AzureOperationPoller thread as daemon (do not block anymore a Ctrl+C) (https://github.com/Azure/autorest/pull/1379)

  2016-09-01 Version 0.4.2
  ++++++++++++++++++++++++

  **Bugfixes**

  - Better exception message (https://github.com/Azure/autorest/pull/1300)

  This version needs msrest >= 0.4.3

  2016-06-08 Version 0.4.1
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fix for LRO PUT operation https://github.com/Azure/autorest/issues/1133

  2016-05-25 Version 0.4.0
  ++++++++++++++++++++++++

  Update msrest dependency to 0.4.0

  **Bugfixes**

  - Fix for several AAD issues https://github.com/Azure/autorest/issues/1055
  - Fix for LRO PATCH bug and refactor https://github.com/Azure/autorest/issues/993

  **Behaviour changes**

  - Needs Autorest > 0.17.0 Nightly 20160525


  2016-04-26 Version 0.3.0
  ++++++++++++++++++++++++

  Update msrest dependency to 0.3.0

  **Bugfixes**

  - Read only values are no longer in __init__ or sent to the server (https://github.com/Azure/autorest/pull/959)
  - Useless kwarg removed

  **Behaviour changes**

  - Needs Autorest > 0.16.0 Nightly 20160426


  2016-03-31 Version 0.2.1
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fix AzurePollerOperation if Swagger defines provisioning status as enum type (https://github.com/Azure/autorest/pull/892)


  2016-03-25 Version 0.2.0
  ++++++++++++++++++++++++

  Update msrest dependency to 0.2.0

  **Behaviour change**

  - async methods called with raw=True don't return anymore AzureOperationPoller but ClientRawResponse
  - Needs Autorest > 0.16.0 Nightly 20160324


  2016-03-21 Version 0.1.2
  ++++++++++++++++++++++++

  Update msrest dependency to 0.1.3

  **Bugfixes**

  - AzureOperationPoller.wait() failed to raise exception if query error (https://github.com/Azure/autorest/pull/856)


  2016-03-04 Version 0.1.1
  ++++++++++++++++++++++++

  **Bugfixes**

  - Source package corrupted in Pypi (https://github.com/Azure/autorest/issues/799)

  2016-03-04 Version 0.1.0
  ++++++++++++++++++++++++

  **Behaviour change**

  - Replaced _required attribute in CloudErrorData class with _validation dict.

  2016-02-29 Version 0.0.2
  ++++++++++++++++++++++++

  **Bugfixes**

  - Fixed AAD bug to include connection verification in UserPassCredentials. (https://github.com/Azure/autorest/pull/725)
  - Source package corrupted in Pypi (https://github.com/Azure/autorest/issues/718)

  2016-02-19 Version 0.0.1
  ++++++++++++++++++++++++

  - Initial release.


pkgId: 2e10073ea47ccc76b3287d8520ed1504bda0d39483d76940b2e90c395f46a1d0
name: rh-python36-multidict
arch: src
version: 4.7.5
epoch: 0
release: 1
summary: multidict implementation
url: https://github.com/aio-libs/multidict
rpm_license: Apache 2
rpm_vendor: Andrew Svetlov <andrew.svetlov@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: ca4f53394d6a49e5b8b9541707e916e2
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311575-rh-python36-multidict/rh-python36-multidict-4.7.5-1.src.rpm
checksum_type: sha256
description:
  =========
  multidict
  =========

  .. image:: https://dev.azure.com/aio-libs/multidict/_apis/build/status/CI?branchName=master
     :target: https://dev.azure.com/aio-libs/multidict/_build
     :alt: Azure Pipelines status for master branch

  .. image:: https://codecov.io/gh/aio-libs/multidict/branch/master/graph/badge.svg
     :target: https://codecov.io/gh/aio-libs/multidict
     :alt: Coverage metrics

  .. image:: https://img.shields.io/pypi/v/multidict.svg
     :target: https://pypi.org/project/multidict
     :alt: PyPI

  .. image:: https://readthedocs.org/projects/multidict/badge/?version=latest
     :target: http://multidict.readthedocs.org/en/latest/?badge=latest
     :alt: Documentationb

  .. image:: https://img.shields.io/pypi/pyversions/multidict.svg
     :target: https://pypi.org/project/multidict
     :alt: Python versions

  .. image:: https://badges.gitter.im/Join%20Chat.svg
     :target: https://gitter.im/aio-libs/Lobby
     :alt: Chat on Gitter

  Multidict is dict-like collection of *key-value pairs* where key
  might be occurred more than once in the container.

  Introduction
  ------------

  *HTTP Headers* and *URL query string* require specific data structure:
  *multidict*. It behaves mostly like a regular ``dict`` but it may have
  several *values* for the same *key* and *preserves insertion ordering*.

  The *key* is ``str`` (or ``istr`` for case-insensitive dictionaries).

  ``multidict`` has four multidict classes:
  ``MultiDict``, ``MultiDictProxy``, ``CIMultiDict``
  and ``CIMultiDictProxy``.

  Immutable proxies (``MultiDictProxy`` and
  ``CIMultiDictProxy``) provide a dynamic view for the
  proxied multidict, the view reflects underlying collection changes. They
  implement the ``collections.abc.Mapping`` interface.

  Regular mutable (``MultiDict`` and ``CIMultiDict``) classes
  implement ``collections.abc.MutableMapping`` and allows to change
  their own content.


  *Case insensitive* (``CIMultiDict`` and
  ``CIMultiDictProxy``) ones assume the *keys* are case
  insensitive, e.g.::

     >>> dct = CIMultiDict(key='val')
     >>> 'Key' in dct
     True
     >>> dct['Key']
     'val'

  *Keys* should be ``str`` or ``istr`` instances.

  The library has optional C Extensions for sake of speed.


  License
  -------

  Apache 2

  Library Installation
  --------------------

  .. code-block:: bash

     $ pip install multidict

  The library is Python 3 only!

  PyPI contains binary wheels for Linux, Windows and MacOS.  If you want to install
  ``multidict`` on another operation system (or *Alpine Linux* inside a Docker) the
  Tarball will be used to compile the library from sources.  It requires C compiler and
  Python headers installed.

  To skip the compilation please use `MULTIDICT_NO_EXTENSIONS` environment variable,
  e.g.:

  .. code-block:: bash

     $ MULTIDICT_NO_EXTENSIONS=1 pip install multidict

  Please note, Pure Python (uncompiled) version is about 20-50 times slower depending on
  the usage scenario!!!



  Changelog
  ---------
  See `RTD page <http://multidict.readthedocs.org/en/latest/changes.html>`_.


pkgId: 40e46f646ba1fc8272714770f94ff32e6a901607f84643c3cf74b52f4c419b01
name: rh-python36-multidict-debuginfo
arch: x86_64
version: 4.7.5
epoch: 0
release: 1
summary: Debug information for package rh-python36-multidict
url: https://github.com/aio-libs/multidict
rpm_license: Apache 2
rpm_vendor: Andrew Svetlov <andrew.svetlov@gmail.com>
rpm_group: Development/Debug
rpm_buildhost: 48e86e407fad47ae93359f2a211549d1
rpm_sourcerpm: rh-python36-multidict-4.7.5-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311575-rh-python36-multidict/rh-python36-multidict-debuginfo-4.7.5-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-multidict.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 0c6fbcdf68d19e35ebef4fed1ac362c4b9014d52eb36b0ec56815fb31745bd2b
name: rh-python36-ncclient
arch: noarch
version: 0.6.3
epoch: 0
release: 1
summary: Python library for NETCONF clients
url: https://github.com/ncclient/ncclient
rpm_license: Apache 2.0
rpm_group: Development/Libraries
rpm_buildhost: b7f7f25f9619412684e5b1cf468026c0
rpm_sourcerpm: rh-python36-ncclient-0.6.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850815-rh-python36-ncclient/rh-python36-ncclient-0.6.3-1.noarch.rpm
checksum_type: sha256
description:
  ncclient: Python library for NETCONF clients
  --------------------------------------------

  ncclient is a Python library that facilitates client-side scripting and
  application development around the NETCONF protocol. ``ncclient`` was
  developed by `Shikar Bhushan <http://schmizz.net>`_. It is now
  maintained by `Leonidas Poulopoulos (@leopoul) <http://ncclient.org>`_

  Docs:
  `http://ncclient.readthedocs.org <http://ncclient.readthedocs.org>`_

  Github:
  `https://github.com/ncclient/ncclient <https://github.com/ncclient/ncclient>`_

  Requirements:
  ^^^^^^^^^^^^^

  -  Python 2.7 or Python 3.4+
  -  setuptools 0.6+
  -  Paramiko 1.7+
  -  lxml 3.3.0+
  -  libxml2
  -  libxslt

  If you are on Debian/Ubuntu install the following libs (via aptitude or
  apt-get):

  -  libxml2-dev
  -  libxslt1-dev

  Installation:
  ^^^^^^^^^^^^^

  ::

      [ncclient] $ sudo python setup.py install

  or via pip:

  ::

      pip install ncclient

  Examples:
  ^^^^^^^^^

  ::

      [ncclient] $ python examples/juniper/*.py

  Usage
  ~~~~~

  Get device running config
  '''''''''''''''''''''''''

  Use either an interactive Python console (ipython) or integrate the
  following in your code:

  ::

      from ncclient import manager

      with manager.connect(host=host, port=830, username=user, hostkey_verify=False) as m:
          c = m.get_config(source='running').data_xml
          with open("%s.xml" % host, 'w') as f:
              f.write(c)

  As of 0.4.1 ncclient integrates Juniper's and Cisco's forks, lots of new concepts
  have been introduced that ease management of Juniper and Cisco devices respectively.
  The biggest change is the introduction of device handlers in connection paramms.
  For example to invoke Juniper's functions annd params one has to re-write the above with
  **device\_params={'name':'junos'}**:

  ::

      from ncclient import manager

      with manager.connect(host=host, port=830, username=user, hostkey_verify=False, device_params={'name':'junos'}) as m:
          c = m.get_config(source='running').data_xml
          with open("%s.xml" % host, 'w') as f:
              f.write(c)

  Device handlers are easy to implement and prove to be futureproof.

  Supported device handlers
  '''''''''''''''''''''''''

  * Juniper: device_params={'name':'junos'}
  * Cisco CSR: device_params={'name':'csr'}
  * Cisco Nexus: device_params={'name':'nexus'}
  * Huawei: device_params={'name':'huawei'}
  * Alcatel Lucent: device_params={'name':'alu'}
  * H3C: device_params={'name':'h3c'}
  * HP Comware: device_params={'name':'hpcomware'}

  Changes \| brief
  ~~~~~~~~~~~~~~~~

  **v0.6.0**

  - Fix use of new Python 3.7 keyword, async
  - Re-enable Python 3.7

  **v0.5.4**

  - Rollup of minor changes since 0.5.3
  - Disablement of Python 3.7 due to async keyword issue

  **v0.5.3**

  - Add notifications support
  - Add support for ecdsa keys
  - Various bug fixes

  **v0.5.2**

  - Add support for Python 3
  - Improve Junos ioproc performance
  - Performance improvements
  - Updated test cases
  - Many bug and performance fixes


  **v0.4.7**

  - Add support for netconf 1.1

  **v0.4.6**

  - Fix multiple RPC error generation
  - Add support for cancel-commit and persist param
  - Add more examples

  **v0.4.5**

  - Add Huawei device support
  - Add cli command support for hpcomware v7 devices
  - Add H3C support, Support H3C CLI,Action,Get_bulk,Save,Rollback,etc.
  - Add alcatel lucent support

  - Rewrite multiple error handling
  - Add coveralls support, with shield in README.md
  - Set severity level to higher when multiple
  - Simplify logging and multi-error reporting
  - Keep stacktrace of errors
  - Check for known hosts on hostkey_verify only
  - Add check for device sending back null error_text
  - Fix RPC.raise_mode
  - Specifying hostkey_verify=False should not load_known_hosts
  - Check the correct field on rpc-error element

  **v0.4.3**

  - Nexus exec_command operation
  - Allow specifying multiple cmd elements in Cisco Nexus
  - Update rpc for nested rpc-errors
  - Prevent race condition in threading
  - Prevent hanging in session close

  **v0.4.2**

  - Support for paramiko ProxyCommand via ~/.ssh/config parsing
  - Add Juniper-specific commit operations
  - Add Huawei devices support
  - Tests/Travis support
  - ioproc transport support for Juniper devices
  - Update Cisco CSR device handler
  - Many minor and major fixes

  **v0.4.1**

  -  Switch between replies if custom handler is found
  -  Add Juniper, Cisco and default device handlers
  -  Allow preferred SSH subsystem name in device params
  -  Allow iteration over multiple SSH subsystem names.




  Acknowledgements
  ~~~~~~~~~~~~~~~~

  -  v0.6.0: `Einar Nilsen-Nygaard`_
  -  v0.5.4: Various
  -  v0.5.3: `Justin Wilcox`_, `Stacy W. Smith`_, `Mircea Ulinic`_,
     `Ebben Aries`_, `Einar Nilsen-Nygaard`_, `QijunPan`_
  -  v0.5.2: `Nitin Kumar`_, `Kristian Larsson`_, `palashgupta`_,
     `Jonathan Provost`_, `Jainpriyal`_, `sharang`_, `pseguel`_,
     `nnakamot`_, `Алексей Пастухов`_, `Christian Giese`_, `Peipei Guo`_,
     `Time Warner Cable Openstack Team`_
  -  v0.4.7: `Einar Nilsen-Nygaard`_, `Vaibhav Bajpai`_, Norio Nakamoto
  -  v0.4.6: `Nitin Kumar`_, `Carl Moberg`_, `Stavros Kroustouris`_
  -  v0.4.5: `Sebastian Wiesinger`_, `Vincent Bernat`_, `Matthew Stone`_,
     `Nitin Kumar`_
  -  v0.4.3: `Jeremy Schulman`_, `Ray Solomon`_, `Rick Sherman`_,
     `subhak186`_
  -  v0.4.2: `katharh`_, `Francis Luong (Franco)`_, `Vincent Bernat`_,
     `Juergen Brendel`_, `Quentin Loos`_, `Ray Solomon`_, `Sebastian
     Wiesinger`_, `Ebben Aries`_
  -  v0.4.1: `Jeremy Schulman`_, `Ebben Aries`_, Juergen Brendel

  .. _Nitin Kumar: https://github.com/vnitinv
  .. _Kristian Larsson: https://github.com/plajjan
  .. _palashgupta: https://github.com/palashgupta
  .. _Jonathan Provost: https://github.com/JoProvost
  .. _Jainpriyal: https://github.com/Jainpriyal
  .. _sharang: https://github.com/sharang
  .. _pseguel: https://github.com/pseguel
  .. _nnakamot: https://github.com/nnakamot
  .. _Алексей Пастухов: https://github.com/p-alik
  .. _Christian Giese: https://github.com/GIC-de
  .. _Peipei Guo: https://github.com/peipeiguo
  .. _Time Warner Cable Openstack Team: https://github.com/twc-openstack
  .. _Einar Nilsen-Nygaard: https://github.com/einarnn
  .. _Vaibhav Bajpai: https://github.com/vbajpai
  .. _Carl Moberg: https://github.com/cmoberg
  .. _Stavros Kroustouris: https://github.com/kroustou
  .. _Sebastian Wiesinger: https://github.com/sebastianw
  .. _Vincent Bernat: https://github.com/vincentbernat
  .. _Matthew Stone: https://github.com/bigmstone
  .. _Jeremy Schulman: https://github.com/jeremyschulman
  .. _Ray Solomon: https://github.com/rsolomo
  .. _Rick Sherman: https://github.com/shermdog
  .. _subhak186: https://github.com/subhak186
  .. _katharh: https://github.com/katharh
  .. _Francis Luong (Franco): https://github.com/francisluong
  .. _Juergen Brendel: https://github.com/juergenbrendel
  .. _Quentin Loos: https://github.com/Kent1
  .. _Ebben Aries: https://github.com/earies
  .. _Justin Wilcox: https://github.com/jwwilcox
  .. _Stacy W. Smith: https://github.com/stacywsmith
  .. _Mircea Ulinic: https://github.com/mirceaulinic
  .. _QijunPan: https://github.com/QijunPan

rpm_vendor:
  Shikhar Bhushan, Leonidas Poulopoulos, Ebben Aries, Einar Nilsen-Nygaard <shikhar@schmizz.net, lpoulopoulos@verisign.com, earies@juniper.net, einarnn@gmail.com>


pkgId: adca19faa562a06ee607f779171cc79d0a6a40b3245d0875b43cc64ba7747edc
name: rh-python36-netaddr
arch: noarch
version: 0.7.19
epoch: 0
release: 1
summary: A network address manipulation library for Python
url: https://github.com/drkjam/netaddr/
rpm_license: BSD License
rpm_vendor: Stefan Nordhausen <stefan.nordhausen@immobilienscout24.de>
rpm_group: Development/Libraries
rpm_buildhost: d6e1c19b6b5a41e69c164d627f60dacb
rpm_sourcerpm: rh-python36-netaddr-0.7.19-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850333-rh-python36-netaddr/rh-python36-netaddr-0.7.19-1.noarch.rpm
checksum_type: sha256
description:
          Provides support for:

          Layer 3 addresses
          -----------------

          - IPv4 and IPv6 addresses, subnets, masks, prefixes
          - iterating, slicing, sorting, summarizing and classifying IP networks
          - dealing with various ranges formats (CIDR, arbitrary ranges and globs, nmap)
          - set based operations (unions, intersections etc) over IP addresses and subnets
          - parsing a large variety of different formats and notations
          - looking up IANA IP block information
          - generating DNS reverse lookups
          - supernetting and subnetting

          Layer 2 addresses
          -----------------

          - representation and manipulation MAC addresses and EUI-64 identifiers
          - looking up IEEE organisational information (OUI, IAB)
          - generating derived IPv6 addresses

          Changes
          -------

          For details on the latest changes and updates, see :-

          http://netaddr.readthedocs.io/en/latest/changes.html

          Requirements
          ------------

          Supports Python version 2.5 through 3.5

          Share and enjoy!


pkgId: 65c6168c24282333b52d01865bf774c549466e21105d074e81eee07d5baae9aa
name: rh-python36-netifaces
arch: src
version: 0.10.9
epoch: 0
release: 1
summary: Portable network interface information.
url: https://bitbucket.org/al45tair/netifaces
rpm_license: MIT License
rpm_vendor: Alastair Houghton <alastair@alastairs-place.net>
rpm_group: Development/Libraries
rpm_buildhost: af92ca7e68cb4d2c92ecd4e209dbf669
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887943-rh-python36-netifaces/rh-python36-netifaces-0.10.9-1.src.rpm
checksum_type: sha256
description:
  netifaces 0.10.6
  ================

  .. image:: https://drone.io/bitbucket.org/al45tair/netifaces/status.png
     :target: https://drone.io/bitbucket.org/al45tair/netifaces/latest
     :alt: Build Status

  1. What is this?
  ----------------

  It's been annoying me for some time that there's no easy way to get the
  address(es) of the machine's network interfaces from Python.  There is
  a good reason for this difficulty, which is that it is virtually impossible
  to do so in a portable manner.  However, it seems to me that there should
  be a package you can easy_install that will take care of working out the
  details of doing so on the machine you're using, then you can get on with
  writing Python code without concerning yourself with the nitty gritty of
  system-dependent low-level networking APIs.

  This package attempts to solve that problem.

  2. How do I use it?
  -------------------

  First you need to install it, which you can do by typing::

    tar xvzf netifaces-0.10.6.tar.gz
    cd netifaces-0.10.6
    python setup.py install

  **Note that you will need the relevant developer tools for your platform**,
  as netifaces is written in C and installing this way will compile the extension.

  Once that's done, you'll need to start Python and do something like the
  following::

  >>> import netifaces

  Then if you enter

  >>> netifaces.interfaces()
  ['lo0', 'gif0', 'stf0', 'en0', 'en1', 'fw0']

  you'll see the list of interface identifiers for your machine.

  You can ask for the addresses of a particular interface by doing

  >>> netifaces.ifaddresses('lo0')
  {18: [{'addr': ''}], 2: [{'peer': '127.0.0.1', 'netmask': '255.0.0.0', 'addr': '127.0.0.1'}], 30: [{'peer': '::1', 'netmask': 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', 'addr': '::1'}, {'peer': '', 'netmask': 'ffff:ffff:ffff:ffff::', 'addr': 'fe80::1%lo0'}]}

  Hmmmm.  That result looks a bit cryptic; let's break it apart and explain
  what each piece means.  It returned a dictionary, so let's look there first::

    { 18: [...], 2: [...], 30: [...] }

  Each of the numbers refers to a particular address family.  In this case, we
  have three address families listed; on my system, 18 is ``AF_LINK`` (which means
  the link layer interface, e.g. Ethernet), 2 is ``AF_INET`` (normal Internet
  addresses), and 30 is ``AF_INET6`` (IPv6).

  But wait!  Don't use these numbers in your code.  The numeric values here are
  system dependent; fortunately, I thought of that when writing netifaces, so
  the module declares a range of values that you might need.  e.g.

  >>> netifaces.AF_LINK
  18

  Again, on your system, the number may be different.

  So, what we've established is that the dictionary that's returned has one
  entry for each address family for which this interface has an address.  Let's
  take a look at the ``AF_INET`` addresses now:

  >>> addrs = netifaces.ifaddresses('lo0')
  >>> addrs[netifaces.AF_INET]
  [{'peer': '127.0.0.1', 'netmask': '255.0.0.0', 'addr': '127.0.0.1'}]

  You might be wondering why this value is a list.  The reason is that it's
  possible for an interface to have more than one address, even within the
  same family.  I'll say that again: *you can have more than one address of
  the same type associated with each interface*.

  *Asking for "the" address of a particular interface doesn't make sense.*

  Right, so, we can see that this particular interface only has one address,
  and, because it's a loopback interface, it's point-to-point and therefore
  has a *peer* address rather than a broadcast address.

  Let's look at a more interesting interface.

  >>> addrs = netifaces.ifaddresses('en0')
  >>> addrs[netifaces.AF_INET]
  [{'broadcast': '10.15.255.255', 'netmask': '255.240.0.0', 'addr': '10.0.1.4'}, {'broadcast': '192.168.0.255', 'addr': '192.168.0.47'}]

  This interface has two addresses (see, I told you...)  Both of them are
  regular IPv4 addresses, although in one case the netmask has been changed
  from its default.  The netmask *may not* appear on your system if it's set
  to the default for the address range.

  Because this interface isn't point-to-point, it also has broadcast addresses.

  Now, say we want, instead of the IP addresses, to get the MAC address; that
  is, the hardware address of the Ethernet adapter running this interface.  We
  can do

  >>> addrs[netifaces.AF_LINK]
  [{'addr': '00:12:34:56:78:9a'}]

  Note that this may not be available on platforms without getifaddrs(), unless
  they happen to implement ``SIOCGIFHWADDR``.  Note also that you just get the
  address; it's unlikely that you'll see anything else with an ``AF_LINK`` address.
  Oh, and don't assume that all ``AF_LINK`` addresses are Ethernet; you might, for
  instance, be on a Mac, in which case:

  >>> addrs = netifaces.ifaddresses('fw0')
  >>> addrs[netifaces.AF_LINK]
  [{'addr': '00:12:34:56:78:9a:bc:de'}]

  No, that isn't an exceptionally long Ethernet MAC address---it's a FireWire
  address.

  As of version 0.10.0, you can also obtain a list of gateways on your
  machine:

  >>> netifaces.gateways()
  {2: [('10.0.1.1', 'en0', True), ('10.2.1.1', 'en1', False)], 30: [('fe80::1', 'en0', True)], 'default': { 2: ('10.0.1.1', 'en0'), 30: ('fe80::1', 'en0') }}

  This dictionary is keyed on address family---in this case, ``AF_INET``---and
  each entry is a list of gateways as ``(address, interface, is_default)`` tuples.
  Notice that here we have two separate gateways for IPv4 (``AF_INET``); some
  operating systems support configurations like this and can either route packets
  based on their source, or based on administratively configured routing tables.

  For convenience, we also allow you to index the dictionary with the special
  value ``'default'``, which returns a dictionary mapping address families to the
  default gateway in each case.  Thus you can get the default IPv4 gateway with

  >>> gws = netifaces.gateways()
  >>> gws['default'][netifaces.AF_INET]
  ('10.0.1.1', 'en0')

  Do note that there may be no default gateway for any given address family;
  this is currently very common for IPv6 and much less common for IPv4 but it
  can happen even for ``AF_INET``.

  BTW, if you're trying to configure your machine to have multiple gateways for
  the same address family, it's a very good idea to check the documentation for
  your operating system *very* carefully, as some systems become extremely
  confused or route packets in a non-obvious manner.

  I'm very interested in hearing from anyone (on any platform) for whom the
  ``gateways()`` method doesn't produce the expected results.  It's quite
  complicated extracting this information from the operating system (whichever
  operating system we're talking about), and so I expect there's at least one
  system out there where this just won't work.

  3. This is great!  What platforms does it work on?
  --------------------------------------------------

  It gets regular testing on OS X, Linux and Windows.  It has also been used
  successfully on Solaris, and it's expected to work properly on other UNIX-like
  systems as well.  If you are running something that is not supported, and
  wish to contribute a patch, please use BitBucket to send a pull request.

  4. What license is this under?
  ------------------------------

  It's an MIT-style license.  Here goes:

  Copyright (c) 2007-2017 Alastair Houghton

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.

  5. Why the jump to 0.10.0?
  --------------------------

  Because someone released a fork of netifaces with the version 0.9.0.
  Hopefully skipping the version number should remove any confusion.  In
  addition starting with 0.10.0 Python 3 is now supported and other
  features/bugfixes have been included as well.  See the CHANGELOG for a
  more complete list of changes.


pkgId: def682d7499dd170d2f9bcd627592ae7aa40202bff996edc22bb661630ba7fc5
name: rh-python36-netifaces-debuginfo
arch: x86_64
version: 0.10.9
epoch: 0
release: 1
summary: Debug information for package rh-python36-netifaces
url: https://bitbucket.org/al45tair/netifaces
rpm_license: MIT License
rpm_vendor: Alastair Houghton <alastair@alastairs-place.net>
rpm_group: Development/Debug
rpm_buildhost: 0634f350be974f12b77e9dd0d15958ee
rpm_sourcerpm: rh-python36-netifaces-0.10.9-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887943-rh-python36-netifaces/rh-python36-netifaces-debuginfo-0.10.9-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-netifaces.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 7ca29fcf056d9d1ae2c9899156bc784f8f44bfb3dd054224d7083cce5ae39bdd
name: rh-python36-oauthlib
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: A generic, spec-compliant, thorough implementation of the OAuth request-signing logic
url: https://github.com/oauthlib/oauthlib
rpm_license: BSD
rpm_vendor: Ib Lundgren <ib.lundgren@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 76389ef8bb574aa58e400202fa2a0916
rpm_sourcerpm: rh-python36-oauthlib-3.1.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00995957-rh-python36-oauthlib/rh-python36-oauthlib-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  OAuthLib - Python Framework for OAuth1 & OAuth2
  ===============================================

  *A generic, spec-compliant, thorough implementation of the OAuth request-signing
  logic for Python 2.7 and 3.4+.*

  .. image:: https://travis-ci.org/oauthlib/oauthlib.svg?branch=master
    :target: https://travis-ci.org/oauthlib/oauthlib
    :alt: Travis
  .. image:: https://coveralls.io/repos/oauthlib/oauthlib/badge.svg?branch=master
    :target: https://coveralls.io/r/oauthlib/oauthlib
    :alt: Coveralls
  .. image:: https://img.shields.io/pypi/pyversions/oauthlib.svg
    :target: https://pypi.org/project/oauthlib/
    :alt: Download from PyPI
  .. image:: https://img.shields.io/pypi/l/oauthlib.svg
    :target: https://pypi.org/project/oauthlib/
    :alt: License
  .. image:: https://app.fossa.io/api/projects/git%2Bgithub.com%2Foauthlib%2Foauthlib.svg?type=shield
     :target: https://app.fossa.io/projects/git%2Bgithub.com%2Foauthlib%2Foauthlib?ref=badge_shield
     :alt: FOSSA Status
  .. image:: https://img.shields.io/readthedocs/oauthlib.svg
    :target: https://oauthlib.readthedocs.io/en/latest/index.html
    :alt: Read the Docs
  .. image:: https://badges.gitter.im/oauthlib/oauthlib.svg
    :target: https://gitter.im/oauthlib/Lobby
    :alt: Chat on Gitter

  OAuth often seems complicated and difficult-to-implement. There are several
  prominent libraries for handling OAuth requests, but they all suffer from one or
  both of the following:

  1. They predate the `OAuth 1.0 spec`_, AKA RFC 5849.
  2. They predate the `OAuth 2.0 spec`_, AKA RFC 6749.
  3. They assume the usage of a specific HTTP request library.

  .. _`OAuth 1.0 spec`: https://tools.ietf.org/html/rfc5849
  .. _`OAuth 2.0 spec`: https://tools.ietf.org/html/rfc6749

  OAuthLib is a framework which implements the logic of OAuth1 or OAuth2 without
  assuming a specific HTTP request object or web framework. Use it to graft OAuth
  client support onto your favorite HTTP library, or provide support onto your
  favourite web framework. If you're a maintainer of such a library, write a thin
  veneer on top of OAuthLib and get OAuth support for very little effort.


  Documentation
  --------------

  Full documentation is available on `Read the Docs`_. All contributions are very
  welcome! The documentation is still quite sparse, please open an issue for what
  you'd like to know, or discuss it in our `Gitter community`_, or even better, send a
  pull request!

  .. _`Gitter community`: https://gitter.im/oauthlib/Lobby
  .. _`Read the Docs`: https://oauthlib.readthedocs.io/en/latest/index.html

  Interested in making OAuth requests?
  ------------------------------------

  Then you might be more interested in using `requests`_ which has OAuthLib
  powered OAuth support provided by the `requests-oauthlib`_ library.

  .. _`requests`: https://github.com/requests/requests
  .. _`requests-oauthlib`: https://github.com/requests/requests-oauthlib

  Which web frameworks are supported?
  -----------------------------------

  The following packages provide OAuth support using OAuthLib.

  - For Django there is `django-oauth-toolkit`_, which includes `Django REST framework`_ support.
  - For Flask there is `flask-oauthlib`_ and `Flask-Dance`_.
  - For Pyramid there is `pyramid-oauthlib`_.
  - For Bottle there is `bottle-oauthlib`_.

  If you have written an OAuthLib package that supports your favorite framework,
  please open a Pull Request, updating the documentation.

  .. _`django-oauth-toolkit`: https://github.com/evonove/django-oauth-toolkit
  .. _`flask-oauthlib`: https://github.com/lepture/flask-oauthlib
  .. _`Django REST framework`: http://django-rest-framework.org
  .. _`Flask-Dance`: https://github.com/singingwolfboy/flask-dance
  .. _`pyramid-oauthlib`: https://github.com/tilgovi/pyramid-oauthlib
  .. _`bottle-oauthlib`: https://github.com/thomsonreuters/bottle-oauthlib

  Using OAuthLib? Please get in touch!
  ------------------------------------
  Patching OAuth support onto an http request framework? Creating an OAuth
  provider extension for a web framework? Simply using OAuthLib to Get Things Done
  or to learn?

  No matter which we'd love to hear from you in our `Gitter community`_ or if you have
  anything in particular you would like to have, change or comment on don't
  hesitate for a second to send a pull request or open an issue. We might be quite
  busy and therefore slow to reply but we love feedback!

  Chances are you have run into something annoying that you wish there was
  documentation for, if you wish to gain eternal fame and glory, and a drink if we
  have the pleasure to run into eachother, please send a docs pull request =)

  .. _`Gitter community`: https://gitter.im/oauthlib/Lobby

  License
  -------

  OAuthLib is yours to use and abuse according to the terms of the BSD license.
  Check the LICENSE file for full details.

  Credits
  -------

  OAuthLib has been started and maintained several years by Idan Gazit and other
  amazing `AUTHORS`_. Thanks to their wonderful work, the open-source `community`_
  creation has been possible and the project can stay active and reactive to users
  requests.


  .. _`AUTHORS`: https://github.com/oauthlib/oauthlib/blob/master/AUTHORS
  .. _`community`: https://github.com/oauthlib/

  Changelog
  ---------

  *OAuthLib is in active development, with the core of both OAuth1 and OAuth2
  completed, for providers as well as clients.* See `supported features`_ for
  details.

  .. _`supported features`: https://oauthlib.readthedocs.io/en/latest/feature_matrix.html

  For a full changelog see ``CHANGELOG.rst``.


pkgId: 02b601f4e89fb13056c90810296355acf580eec4cff7f52ed3aaa4c6562eab10
name: rh-python36-openstacksdk
arch: noarch
version: 0.37.0
epoch: 0
release: 1
summary: An SDK for building applications to work with OpenStack
url: http://developer.openstack.org/sdks/python/openstacksdk/
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-dev@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: 0c39a1841b884fb4b90209f7cebd579e
rpm_sourcerpm: rh-python36-openstacksdk-0.37.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01225010-rh-python36-openstacksdk/rh-python36-openstacksdk-0.37.0-1.noarch.rpm
checksum_type: sha256
description:
  openstacksdk
  ============

  openstacksdk is a client library for for building applications to work
  with OpenStack clouds. The project aims to provide a consistent and
  complete set of interactions with OpenStack's many services, along with
  complete documentation, examples, and tools.

  It also contains an abstraction interface layer. Clouds can do many things, but
  there are probably only about 10 of them that most people care about with any
  regularity. If you want to do complicated things, the per-service oriented
  portions of the SDK are for you. However, if what you want is to be able to
  write an application that talks to clouds no matter what crazy choices the
  deployer has made in an attempt to be more hipster than their self-entitled
  narcissist peers, then the Cloud Abstraction layer is for you.

  A Brief History
  ---------------

  .. TODO(shade) This history section should move to the docs. We can put a
     link to the published URL here in the README, but it's too long.

  openstacksdk started its life as three different libraries: shade,
  os-client-config and python-openstacksdk.

  ``shade`` started its life as some code inside of OpenStack Infra's `nodepool`_
  project, and as some code inside of the `Ansible OpenStack Modules`_.
  Ansible had a bunch of different OpenStack related modules, and there was a
  ton of duplicated code. Eventually, between refactoring that duplication into
  an internal library, and adding the logic and features that the OpenStack Infra
  team had developed to run client applications at scale, it turned out that we'd
  written nine-tenths of what we'd need to have a standalone library.

  Because of its background from nodepool, shade contained abstractions to
  work around deployment differences and is resource oriented rather than service
  oriented. This allows a user to think about Security Groups without having to
  know whether Security Groups are provided by Nova or Neutron on a given cloud.
  On the other hand, as an interface that provides an abstraction, it deviates
  from the published OpenStack REST API and adds its own opinions, which may not
  get in the way of more advanced users with specific needs.

  ``os-client-config`` was a library for collecting client configuration for
  using an OpenStack cloud in a consistent and comprehensive manner, which
  introduced the ``clouds.yaml`` file for expressing named cloud configurations.

  ``python-openstacksdk`` was a library that exposed the OpenStack APIs to
  developers in a consistent and predictable manner.

  After a while it became clear that there was value in both the high-level
  layer that contains additional business logic and the lower-level SDK that
  exposes services and their resources faithfully and consistently as Python
  objects.

  Even with both of those layers, it is still beneficial at times to be able to
  make direct REST calls and to do so with the same properly configured
  `Session`_ from `python-requests`_.

  This led to the merge of the three projects.

  The original contents of the shade library have been moved into
  ``openstack.cloud`` and os-client-config has been moved in to
  ``openstack.config``. Future releases of shade will provide a thin
  compatibility layer that subclasses the objects from ``openstack.cloud``
  and provides different argument defaults where needed for compatibility.
  Similarly future releases of os-client-config will provide a compatibility
  layer shim around ``openstack.config``.

  .. _nodepool: https://docs.openstack.org/infra/nodepool/
  .. _Ansible OpenStack Modules: http://docs.ansible.com/ansible/latest/list_of_cloud_modules.html#openstack
  .. _Session: http://docs.python-requests.org/en/master/user/advanced/#session-objects
  .. _python-requests: http://docs.python-requests.org/en/master/

  openstack
  =========

  List servers using objects configured with the ``clouds.yaml`` file:

  .. code-block:: python

      import openstack

      
      openstack.enable_logging(debug=True)

      
      conn = openstack.connect(cloud='mordred')

      for server in conn.compute.servers():
          print(server.to_dict())

  openstack.config
  ================

  ``openstack.config`` will find cloud configuration for as few as 1 clouds and
  as many as you want to put in a config file. It will read environment variables
  and config files, and it also contains some vendor specific default values so
  that you don't have to know extra info to use OpenStack

  * If you have a config file, you will get the clouds listed in it
  * If you have environment variables, you will get a cloud named `envvars`
  * If you have neither, you will get a cloud named `defaults` with base defaults

  Sometimes an example is nice.

  Create a ``clouds.yaml`` file:

  .. code-block:: yaml

       clouds:
        mordred:
          region_name: Dallas
          auth:
            username: 'mordred'
            password: XXXXXXX
            project_name: 'shade'
            auth_url: 'https://identity.example.com'

  Please note: ``openstack.config`` will look for a file called ``clouds.yaml``
  in the following locations:

  * Current Directory
  * ``~/.config/openstack``
  * ``/etc/openstack``

  More information at https://developer.openstack.org/sdks/python/openstacksdk/users/config

  openstack.cloud
  ===============

  Create a server using objects configured with the ``clouds.yaml`` file:

  .. code-block:: python

      import openstack.cloud

      
      openstack.enable_logging(debug=True)

      
      
      conn = openstack.connect(cloud='mordred')

      
      image = conn.create_image(
          'ubuntu-trusty', filename='ubuntu-trusty.qcow2', wait=True)

      
      flavor = conn.get_flavor_by_ram(512)

      
      
      conn.create_server(
          'my-server', image=image, flavor=flavor, wait=True, auto_ip=True)

  Links
  =====

  * `Issue Tracker <https://storyboard.openstack.org/#!/project/760>`_
  * `Code Review <https://review.openstack.org/#/q/status:open+project:openstack/python-openstacksdk,n,z>`_
  * `Documentation <https://developer.openstack.org/sdks/python/openstacksdk/>`_
  * `PyPI <https://pypi.python.org/pypi/python-openstacksdk/>`_
  * `Mailing list <http://lists.openstack.org/cgi-bin/mailman/listinfo/openstack-dev>`_
  * `Bugs <https://bugs.launchpad.net/python-openstacksdk>`_


pkgId: 3081bd63609332dc06e554a45281e3b4cc6ac006fdf266ea2cdb4420aae59b35
name: rh-python36-os-client-config
arch: noarch
version: 1.29.0
epoch: 0
release: 1
summary: OpenStack Client Configuation Library
url: https://docs.openstack.org/os-client-config/latest
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-dev@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: 053737d41918427c99c3af43db366cd2
rpm_sourcerpm: rh-python36-os-client-config-1.29.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850916-rh-python36-os-client-config/rh-python36-os-client-config-1.29.0-1.noarch.rpm
checksum_type: sha256
description:
  ================
  os-client-config
  ================

  .. image:: http://governance.openstack.org/badges/os-client-config.svg
      :target: http://governance.openstack.org/reference/tags/index.html

  `os-client-config` is a library for collecting client configuration for
  using an OpenStack cloud in a consistent and comprehensive manner. It
  will find cloud config for as few as 1 cloud and as many as you want to
  put in a config file. It will read environment variables and config files,
  and it also contains some vendor specific default values so that you don't
  have to know extra info to use OpenStack

  * If you have a config file, you will get the clouds listed in it
  * If you have environment variables, you will get a cloud named `envvars`
  * If you have neither, you will get a cloud named `defaults` with base defaults

  Source
  ------

  * Free software: Apache license
  * Documentation: http://docs.openstack.org/os-client-config/latest
  * Source: http://git.openstack.org/cgit/openstack/os-client-config
  * Bugs: http://bugs.launchpad.net/os-client-config


pkgId: d4b947c4c77256a6b20886a42cca02c1bd50b0a961a2bf8a2b178589b0f5a224
name: rh-python36-os-service-types
arch: noarch
version: 1.7.0
epoch: 0
release: 1
summary: Python library for consuming OpenStack sevice-types-authority data
url: http://www.openstack.org/
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-dev@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: 2af1ce157c1e4be6984d981359cbc5c2
rpm_sourcerpm: rh-python36-os-service-types-1.7.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00966913-rh-python36-os-service-types/rh-python36-os-service-types-1.7.0-1.noarch.rpm
checksum_type: sha256
description:
  ================
  os-service-types
  ================

  Python library for consuming OpenStack sevice-types-authority data

  The `OpenStack Service Types Authority`_ contains information about official
  OpenStack services and their historical ``service-type`` aliases.

  The data is in JSON and the latest data should always be used. This simple
  library exists to allow for easy consumption of the data, along with a built-in
  version of the data to use in case network access is for some reason not
  possible and local caching of the fetched data.

  * Free software: Apache license
  * Documentation: http://docs.openstack.org/developer/os-service-types
  * Source: http://git.openstack.org/cgit/openstack/os-service-types
  * Bugs: https://storyboard.openstack.org/#!/project/904

  .. _OpenStack Service Types Authority: https://service-types.openstack.org/


pkgId: 00eec0d47a39d2e91ab0849521a9c52735b9bd6daf7206e985d881cf4868f0dd
name: rh-python36-oslo.i18n
arch: noarch
version: 3.23.1
epoch: 0
release: 1
summary: Oslo i18n library
url: https://docs.openstack.org/oslo.i18n/latest
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-discuss@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: a98dba72067f40e0b6876c3e7a44d920
rpm_sourcerpm: rh-python36-oslo.i18n-3.23.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887942-rh-python36-oslo.i18n/rh-python36-oslo.i18n-3.23.1-1.noarch.rpm
checksum_type: sha256
description:
  ========================
  Team and repository tags
  ========================

  .. image:: https://governance.openstack.org/tc/badges/oslo.i18n.svg
      :target: https://governance.openstack.org/tc/reference/tags/index.html

  .. Change things from this point on

  ==================================================
   oslo.i18n -- Oslo Internationalization Utilities
  ==================================================

  .. image:: https://img.shields.io/pypi/v/oslo.i18n.svg
      :target: https://pypi.org/project/oslo.i18n/
      :alt: Latest Version

  .. image:: https://img.shields.io/pypi/dm/oslo.i18n.svg
      :target: https://pypi.org/project/oslo.i18n/
      :alt: Downloads

  The oslo.i18n library contain utilities for working with
  internationalization (i18n) features, especially translation for text
  strings in an application or library.

  * Free software: Apache license
  * Documentation: https://docs.openstack.org/oslo.i18n/latest
  * Source: https://git.openstack.org/cgit/openstack/oslo.i18n
  * Bugs: https://bugs.launchpad.net/oslo.i18n
  * Release notes:  https://docs.openstack.org/releasenotes/oslo.i18n/


pkgId: 691565aef9381a6768e006394a775988bf97de50117c53b25e9acc4228a949cf
name: rh-python36-oslo.serialization
arch: noarch
version: 2.29.1
epoch: 0
release: 1
summary: Oslo Serialization library
url: https://docs.openstack.org/oslo.serialization/latest/
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-discuss@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: d00a1a1eee994d4da3672bead7e63d33
rpm_sourcerpm: rh-python36-oslo.serialization-2.29.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00914615-rh-python36-oslo.serialization/rh-python36-oslo.serialization-2.29.1-1.noarch.rpm
checksum_type: sha256
description:
  ========================
  Team and repository tags
  ========================

  .. image:: https://governance.openstack.org/tc/badges/oslo.serialization.svg
      :target: https://governance.openstack.org/tc/ference/tags/index.html

  .. Change things from this point on

  ===================
   oslo.serialization
  ===================

  .. image:: https://img.shields.io/pypi/v/oslo.serialization.svg
      :target: https://pypi.org/project/oslo.serialization/
      :alt: Latest Version

  .. image:: https://img.shields.io/pypi/dm/oslo.serialization.svg
      :target: https://pypi.org/project/oslo.serialization/
      :alt: Downloads

  The oslo.serialization library provides support for representing objects
  in transmittable and storable formats, such as Base64, JSON and MessagePack.

  * Free software: Apache license
  * Documentation: https://docs.openstack.org/oslo.serialization/latest/
  * Source: https://git.openstack.org/cgit/openstack/oslo.serialization
  * Bugs: https://bugs.launchpad.net/oslo.serialization
  * Release notes: https://docs.openstack.org/releasenotes/oslo.serialization/


pkgId: 6c9578a51fcc6353e8a6562371014de1110d244405fc2bf6b75f56690236156f
name: rh-python36-oslo.utils
arch: noarch
version: 3.41.0
epoch: 0
release: 1
summary: Oslo Utility library
url: https://docs.openstack.org/oslo.utils/latest/
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-discuss@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: 34072d70c10148a08801a614e5a1ad7b
rpm_sourcerpm: rh-python36-oslo.utils-3.41.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00914616-rh-python36-oslo.utils/rh-python36-oslo.utils-3.41.0-1.noarch.rpm
checksum_type: sha256
description:
  ========================
  Team and repository tags
  ========================

  .. image:: https://governance.openstack.org/tc/badges/oslo.utils.svg
      :target: https://governance.openstack.org/tc/reference/tags/index.html

  .. Change things from this point on

  ==========
  oslo.utils
  ==========

  .. image:: https://img.shields.io/pypi/v/oslo.utils.svg
      :target: https://pypi.org/project/oslo.utils/
      :alt: Latest Version

  .. image:: https://img.shields.io/pypi/dm/oslo.utils.svg
      :target: https://pypi.org/project/oslo.utils/
      :alt: Downloads

  The oslo.utils library provides support for common utility type functions,
  such as encoding, exception handling, string manipulation, and time handling.

  * Free software: Apache license
  * Documentation: https://docs.openstack.org/oslo.utils/latest/
  * Source: https://git.openstack.org/cgit/openstack/oslo.utils
  * Bugs: https://bugs.launchpad.net/oslo.utils
  * Release notes: https://docs.openstack.org/releasenotes/oslo.utils/


pkgId: d9ca9897cdc8cedd8e5fe2536efff74f61b59d164619beec45f7157005813f3a
name: rh-python36-ovirt-engine-sdk-python
arch: src
version: 4.3.0
epoch: 0
release: 1
summary: Python SDK for oVirt Engine API
rpm_license: ASL2
rpm_group: Development/Libraries
rpm_buildhost: c9ef3652021646adbafa6f165893859d
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00944378-rh-python36-ovirt-engine-sdk-python/rh-python36-ovirt-engine-sdk-python-4.3.0-1.src.rpm
checksum_type: sha256
description:
  = oVirt Engine API Python SDK

  == Introduction

  This project contains the Python SDK for the oVirt Engine API.

  == Important

  Note that most of the code of this SDK is automatically generated. If
  you just installed the package then you will have everything already,
  but if you downloaded the source then you will need to generate it,
  follow the instructions in the `README.adoc` file of the parent
  directory.

  == Installation

  The SDK can be installed in Fedora 24 and CentOS 7 using the RPM packages
  provided by the oVirt project. To do so install the oVirt release package:

    

  Then install the SDK packages. For Python 2:

    

  For Python 3:

    

  For other operating systems (and also for Fedora and CentOS) you can
  install the SDK using the `pip` command, which will download the source
  from https://pypi.python.org/pypi[PyPI], build and install it.

  The SDK uses http://www.xmlsoft.org[libxml2] for parsing and rendering
  XML. The part of the SDK that interacts with that library is written in
  C. This means that before building you must make sure you have the C
  compiler and the required header and libraries files installed in your
  system. For example, if you are using distributions like Fedora, or
  CentOS:

    
    gcc \
    libxml2-devel \
    python-devel

  For Python 3:

    
    gcc \
    libxml2-devel \
    python3-devel

  If you are using distributions like Debian, or Ubuntu:

    
    gcc \
    libxml2-dev \
    python-dev

  For Python 3:

    
    gcc \
    libxml2-dev \
    python3-dev

  NOTE: The examples above use the `dnf` command, which is the default in
  Fedora 24. In CentOS 7 you may need to use the `yum` command, as `dnf`
  is optional.

  == Usage

  === Packages

  The following are the Python modules that are most frequently needed in
  order to use the SDK:

  ovirtsdk4::

  This is the top level module. It most important element is the
  `Connection` class, as is the mechanism to connect to the server and to
  get the reference to the root of the services tree.
  +
  The `Error` class, is the base exception class that the
  SDK will raise when it needs to report any error.

  For certain kinds of errors there are specific error classes, extending
  the base error class:

  * `AuthError` - Raised when authentication or authorization fail.

  * `ConnectionError` - Raised when the name of the server can't be resolved,
  and when the server is down or unreachable.

  * `NotFoundError` - Raised when the requested object doesn't exist.

  * `TimeoutError` - Raised when an operation times out.

  ovirtsdk4.types::

  This module contains the classes that implement the _types_ used in the
  API. For example, the `ovirtsdk4.types.Vm` Python class is the
  implementation of the virtual machine type. These classes are just
  containers of data, they don't contain any logic.
  +
  Instances of these classes are used as parameters and return values of
  _service methods_. The conversion to/from the underlying representation
  is handled transparently by the SDK.

  ovirtsdk4.services::

  This module contains the classes that implement the _services_ supported
  by the API. For example, the `ovirtsdk4.services.VmsService` Python
  class is the implementation of the service that manages the collection
  of virtual machines of the system.
  +
  Instances of these classes are automatically created by the SDK when a
  service is located. For example, a new instance of the `VmsService`
  class will be automatically created by the SDK when doing the following:
  +
  [source,python]
  ----
  vms_service = connection.system_service().vms_service()
  ----
  +
  Avoid creating instances of these classes manually, as the parameters of
  the constructors, and in general all the methods except the _service
  locators_ and _service methods_ (described later) may change in the
  future.

  There are other modules, like `ovirtsdk4.http`, `ovirtsdk4.readers` and
  `ovirtsdk4.writers`. These are used to implement the HTTP communication,
  and to for XML parsing and rendering. Refrain from using them, as they
  are internal implementation details that may change in the future:
  backwards compatibility isn't guaranteed.

  === Connecting to the server

  To connect to the server import the `ovirtsdk4` module. That will give
  to the `Connection` class. This is the entry point of the SDK, and gives
  you access to the root of the tree of services of the API:

  [source,python]
  ----
  import ovirtsdk4 as sdk


  connection = sdk.Connection(
    url='https://engine.example.com/ovirt-engine/api',
    username='admin@internal',
    password='...',
    ca_file='ca.pem',
  )
  ----

  The connection holds expensive resources, including a pool of HTTP
  connections to the server and an authentication token. It is very
  important to free these resources when they are no longer in use:

  [source,python]
  ----

  connection.close()
  ----

  Once a connection is closed it can't be reused.

  The `ca.pem` file is required when connecting to a server protected
  with TLS. In an usual oVirt installation it will be in
  `/etc/pki/ovirt-engine/ca.pem`. If you don't specify `ca_file`, then
  system wide CA certificate store will be used.

  If something fails when trying to create the connection (authentication
  failure, communication failure, etc) the SDK will raise a
  `ovirtsdk4.Error` exception containing the details.

  === Using _types_

  The classes in the `ovirtsdk4.types` module are pure data containers,
  they don't have any logic or operations. Instances can be created and
  modified at will.

  Creating or modifying one of this instances does *not* have any effect
  in the server side, unless one they are explicitly passed to a call to
  one of the service methods described below. Changes in the server side
  are *not* automatically reflected in the instances that already exist in
  memory.

  The constructors of these classes have multiple optional arguments, one
  for each attribute of the type. This is intended to simplify creation of
  objects using nested calls to multiple constructors. For example, to
  create an instance of a virtual machine, with an specification of the
  cluster and template that it should use, and the memory it should have:

  [source,python]
  ----
  from ovirtsdk4 import types

  vm = types.Vm(
      name='myvm',
      cluster=types.Cluster(
          name='mycluster'
      ),
      template=types.Template(
          name='mytemplate'
      ),
      memory=1073741824
  )
  ----

  Using the constructors in this way is recommended, but not mandatory.
  You can also create the instance with no arguments in the call to the
  constructor, and then populate the object step by step, using the
  setters, or using a mix of both approaches:

  [source,python]
  ----
  vm = types.Vm()
  vm.name = 'myvm'
  vm.cluster = types.Cluster(name='mycluster')
  vm.template = types.Template(name='mytemplate')
  vm.memory=1073741824
  ----

  Attributes that are defined as lists of objects in the specification of
  the API are implemented as Python lists. For example, the
  `custom_properties` attributes of the
  http://ovirt.github.io/ovirt-engine-api-model/master/#types/vm[Vm]
  type is defined as a list of objects of type `CustomProperty`, so when
  using it in the SDK it will be a Python list:

  [source,python]
  ----
  vm = types.Vm(
      name='myvm',
      custom_properties=[
          types.CustomProperty(...),
          types.CustomProperty(...),
          ...
      ]
  )
  ----

  Attributes that are defined as enumerated values in the specification of
  the API are implemented as `enum` in Python, using the native support
  for enums in Python 3, and using the
  https://pypi.python.org/pypi/enum34[enum34] package in Python 2.7. For
  example, the `status` attribute of the `Vm` type is defined using the
  http://ovirt.github.io/ovirt-engine-api-model/master/#types/vm_status[VmStatus]
  enum:

  [source,python]
  ----
  if vm.status == types.VmStatus.DOWN:
      ...
  elif vm.status == types.VmStatus.IMAGE_LOCKED:
      ....
  ----

  NOTE: In the specification of the API the values of enum types appear in
  lower case, because that is what is used in the XML or JSON documents.
  But in Python it is common practice to use upper case for this kind of
  constants, so that is how they are defined in the Python SDK: all upper
  case.

  Reading the attributes of instances of types is done using the
  corresponding properties:

  [source,python]
  ----
  print("vm.name: %s" % vm.name)
  print("vm.memory: %s" % vm.memory)
  for custom_property in vm.custom_properties:
      ...
  ----

  === Using _links_

  Some of the attributes of types are defined as _links_ in the
  specification of the API. This is done to indicate that their value
  won't usually be populated when retrieving the representation of that
  object, only a link will be returned instead. For example, when
  retrieving a virtual machine, the XML returned by the server will look
  like this:

  [source,python]
  ----
  <vm id="123" href="/ovirt-engine/api/vms/123">
    <name>myvm</name>
    <link rel="diskattachments" href="/ovirt-engine/api/vms/123/diskattachments/>
    ...
  </vm>
  ----

  That link is available as `vm.diskattachments`, but it doesn't contain
  the actual disk attachments. To get the actual data the `Connection`
  class provides a `follow_link` method that uses the value of the `href`
  XML attribute to retrieve the actual data. For example, to retrieve the
  details of the disks of the virtual machine, you can first follow the
  link to the disk attachments, and then follow the link to each of the
  disks:

  [source,python]
  ----

  vm = vm_service.get()


  attachments = connection.follow_link(vm.disk_attachments)
  for attachment in attachments:
      disk = connection.follow_link(attachment.disk)
      print("disk.alias: " % disk.alias)
  ----

  === Locating services

  The API provides a set of _services_, each associated to a particular
  path within the URL space of the server. For example, the service that
  manages the collection of virtual machines of the system lives in
  `/vms`, and the service that manages the virtual machine with identifier
  `123` lives in `/vms/123`.

  In the SDK the root of that tree of services is implemented by the
  _system service_. It is obtained calling the `system_service` method
  of the connection:

  [source,python]
  ----
  system_service = connection.system_service()
  ----

  Once you have the reference to this system service you can use it to get
  references to other services, calling the `+*_service+` methods (called
  _service locators_) of the previous service. For example, to get a
  reference to the service that manages the collection of virtual machines
  of the system use the `vms_service` service locator:

  [source,python]
  ----
  vms_service = system_service.vms_service()
  ----

  To get a reference to the service that manages the virtual machine with
  identifier `123`, use the `vm_service` service locator of the service
  that manages the collection of virtual machines. It receives as a
  parameter the identifier of the virtual machine:

  [source,python]
  ----
  vm_service = vms_service.vms_service('123')
  ----

  IMPORTANT: Calling the service locators doesn't send any request to the
  server. The Python objects that they return are pure services, they
  don't contain any data. For example, the `vm_service` Python object
  obtained in the previous example is *not* the representation of a
  virtual machine. It is the service that can be used to retrieve, update,
  delete, start and stop that virtual machine.

  === Using services

  Once you have located the service you are interested on, you can start
  calling its _service methods_, the methods that send requests to the
  server and do the real work.

  The services that manage collections of object usually have the
  following `list` and `add` methods.

  The services that manage a single object usually have the `get`,
  `update` and `remove` methods.

  Both kind of services can also have additional _action methods_, which
  perform actions other than retrieving, creating, updating or removing.
  Most frequently they available in services that manage a single object.

  ==== Using the _get_ methods

  These service methods are used to retrieve the representation of a
  single object. For example, to retrieve the representation of the
  virtual machine with identifier `123`:

  [source,python]
  ----

  vms_service = system_service.vms_service()
  vm_service = vms_service.vm_service('123')


  vm = vm_service.get()
  ----

  The result will be an instance of the corresponding type. For example,
  in this case, the result will be an instance of the Python class
  `ovirtsdk4.types.Vm`.

  The `get` methods of some services support additional parameters that
  control how to retrieve the representation of the object, or what
  representation to retrieve in case there are multiple representations.
  For example, for virtual machines you may want to retrieve its current
  state, or the state that will be used the next time it is started, as
  they may be different. To do so the `get` method of the service that
  manages a virtual machine supports a
  http://ovirt.github.io/ovirt-engine-api-model/master/#services/vm/methods/get/parameters/next_run[next_run]
  boolean parameter:

  [source,python]
  ----



  vm = vm_service.get(next_run=True)
  ----

  Check the http://ovirt.github.io/ovirt-engine-sdk/master[reference]
  documentation of the SDK to find out the details.

  If the object can't be retrieved, for whatever the reason, the SDK will
  raise a `ovirtsdk4.Error` exception, containing the details of the
  failure. This includes the situation when the object doesn't actually
  exist. Note that the exception will be raised when calling the `get`
  service method, the call to the service locator method never fails, even
  if the object doesn't exist, because it doesn't send any request to the
  server. For example:

  [source,python]
  ----


  vm_service = vms_service.vm_service('junk')


  vm = vm_service.get()
  ----

  ==== Using the _list_ methods

  These service methods are used to retrieve the representations of the
  objects of the collection. For example, to retrieve the complete
  collection of virtual machines of the system:

  [source,python]
  ----


  vms_service = system_service.vms_service()
  vms = vms_service.list()
  ----

  The result will be a Python list containing the instances of
  corresponding types. For example, in this case, the result will be a
  list of instances of the Python class `ovirtsdk4.types.Vm`.

  The `list` methods of some services support additional parameters. For
  example, almost all the top level collections support a `search`
  parameter that can be used ask the server to filter the results, and a
  `max` parameter that can be used to limit the number of results returned
  by the server. For example, to get the list of virtual machines whose
  name starts with `my`, and to get at most 10 results:

  [source,python]
  ----
  vms = vms_service.list(search='name=my*', max=10)
  ----

  NOTE: Not all the `list` methods support these parameters, and some
  `list` methods may support other additional parameters. Check the
  http://ovirt.github.io/ovirt-engine-sdk/master[reference] documentation
  of the SDK to find out the details.

  If list of results is empty, for whatever the reason, the returned value
  will be an empty Python list, it will never be `None`.

  If there is an error while trying to retrieve the result, then the SDK
  will raise an `ovirtsdk4.Error` exception containing the details of the
  failure.

  ==== Using the _add_ methods

  These service methods add new elements to the collection. They receive
  an instance of the relevant type describing the object to add, send the
  request to add it, and return an instance of the type describing the
  added object.

  For example, to add a new virtual machine named `myvm`:

  [source,python]
  ----
  from ovirtsdk4 import types


  vm = vms_service.add(
      vm=types.Vm(
          name='myvm',
          cluster=types.Cluster(
              name='mycluster'
          ),
          template=types.Template(
              name='mytemplate'
          )
      )
  )
  ----

  If the object can't be created, for whatever the reason, the SDK will
  raise an `ovirtsdk4.Error` exception containing the details of the
  failure. It will never return `None`.

  It is very important to understand that the Python object returned by
  this `add` method is an instance of the relevant type, it isn't a
  service, just a container of data. In this particular example the
  returned object will be an instance of the `ovirtsdk4.types.Vm` class.
  If once the virtual machine is created you need to perform some
  operation on it, like retrieving it again, or starting it, you will
  first need to find the service that manages it, calling the
  corresponding service locator:

  [source,python]
  ----

  vm = vms_service.add(
    ...
  )


  vm_service = vms_service.vm_service(vm.id)



  vm_service.start()
  ----

  Note that the creation of most objects is an asynchronous task. That
  means, for example, that when creating a new virtual machine the `add`
  method will return *before* the virtual machine is completely created
  and ready to be used. It is good practice to poll the status of the
  object till it is completely created. For a virtual machine that means
  checking till the status is _down_. So the recommended approach to create
  a virtual machine is the following:

  [source,python]
  ----

  vm = vms_service.add(
    ...
  )


  vm_service = vms_service.vm_service(vm.id)



  while True:
      time.sleep(5)
      vm = vm_service.get()
      if vm.status == types.VmStatus.DOWN:
          break
  ----

  In the above loop it is very important to retrieve the object each time,
  using the `get` method, otherwise the `status` attribute won't be
  updated.

  ==== Using the _update_ methods

  These service methods update existing objects. They receive
  an instance of the relevant type describing the update to perform, send
  the request to update it, and return an instance of the type describing
  the updated object.

  For example, to update the name of a virtual machine from `myvm` to
  `newvm`:

  [source,python]
  ----
  from ovirtsdk4 import types



  vm = vms_service.list(search='name=myvm')[0]
  vm_service = vms_service.vm_service(vm.id)


  updated_vm = vms_service.update(
      vm=types.Vm(
          name='newvm'
      )
  )
  ----

  When performing updates, try to avoid sending the complete
  representation of the object, send only the attributes that you want to
  update. For example, try to *avoid* this:

  [source,python]
  ----

  vm = vm_service.get()



  vm.name = 'newvm'


  vms_service.update(vm)
  ----

  The problem with that is double. First you are sending much more
  information than what the server needs, thus wasting resources. Second,
  and more important, the server will try to update all the attributes of
  the object, even those that you didn't need to change. Usually that
  isn't a problem, but has caused many unexpected bugs in the server side
  in the past.

  The `update` methods of some services support additional parameters that
  control how or what to update. For example, for virtual machines you may
  want to update its current state, or the state that will be used the
  next time it is started. To do so the `update` method of the service
  that manages a virtual machine supports a
  http://ovirt.github.io/ovirt-engine-api-model/master/#services/vm/methods/update/parameters/next_run[next_run]
  boolean parameter:

  [source,python]
  ----


  vm = vm_service.update(
      vm=types.Vm(
          memory=1073741824
      ),
      next_run=True
  )
  ----

  If the update can't be performed, for whatever the reason, the SDK will
  raise an `ovirtsdk4.Error` exception containing the details of the
  failure. It will never return `None`.

  The Python object returned by this `update` method is an instance of the
  relevant type, it isn't a service, just a container of data. In this
  particular example the returned object will be an instance of the
  `ovirtsdk4.types.Vm` class.

  ==== Using the _remove_ methods

  These service methods remove existing objects. They usually don't
  receive any parameters, as they are methods of the services that manage
  single objects, therefore the service already knows what object to
  remove.

  For example, to remove the virtual machine with identifier `123`:

  [source,python]
  ----

  vm_service = vms_service.vm_service('123')


  vms_service.remove()
  ----

  The `remove` methods of some services support additional parameters that
  control how or what to remove. For example, for virtual machines it is
  possible to remove the virtual machine while preserving the disks.
  To do so the `remove` method of the service that manages a virtual machine supports a
  http://ovirt.github.io/ovirt-engine-api-model/master/#services/vm/methods/remove[detach_only]
  boolean parameter:

  [source,python]
  ----

  vm_service.remove(detach_only=True)
  ----

  The `remove` methods return `None` if the object is removed
  successfully. It does *not* return the removed object. If the object
  can't removed, for whatever the reason, the SDK will raise an
  `ovirtsdk4.Error` exception containing the details of the failure.

  ==== Using _action_ methods

  These service methods perform miscellaneous operations. For example, the
  service that manages a virtual machine has methods to start and stop it:

  [source,python]
  ----

  vm_service.start()
  ----

  Many of these methods include parameters that modify the operation. For
  example, the method that starts a virtual machine supports a
  http://ovirt.github.io/ovirt-engine-api-model/master/#services/vm/methods/start/parameters/use_cloud_init[use_cloud_init]
  parameter that indicates if you want to start it using
  https://cloudinit.readthedocs.io/cloud-init[cloud-init]:

  [source,python]
  ----

  vm_service.start(cloud_init=True)
  ----

  Most action methods return `None` when they succeed, and raise a
  `ovirtsdk4.Error` when they fail. But a few action methods return
  values. For example, the service that manages a storage domains has an
  http://ovirt.github.io/ovirt-engine-api-model/master/#services/storage_domain/methods/is_attachedd[is_attached]
  action method that checks if the storage domain is already attached to a
  data center. That method returns a boolean:

  [source,python]
  ----

  sds_service = system_service.storage_domains_service()
  sd_service = sds_service.storage_domain_service('123')
  if sd_service.is_attached():
      ...
  ----

  Check the http://ovirt.github.io/ovirt-engine-sdk[reference]
  documentation of the SDK to see the action methods supported by each
  service, the parameters that they support, and the values that they
  return.

  == More information

  The reference documentation of the API is available
  http://ovirt.github.io/ovirt-engine-api-model[here].

  The reference documentation of the SDK is available
  http://ovirt.github.io/ovirt-engine-sdk[here].

  There is a collection of examples that show how to use the SDK
  https://github.com/oVirt/ovirt-engine-sdk/tree/master/sdk/examples[here].

rpm_vendor:
  Michael Pasternak, Juan Hernandez, Ondra Machacek <mishka8520@yahoo.com, juan.hernandez@redhat.com, omachace@redhat.com>


pkgId: 7c80e1a419ff4d8793e55cd28f9d8dc549bbcc7547dc9c932ebce8813bbc51e7
name: rh-python36-ovirt-engine-sdk-python-debuginfo
arch: x86_64
version: 4.3.0
epoch: 0
release: 1
summary: Debug information for package rh-python36-ovirt-engine-sdk-python
rpm_license: ASL2
rpm_group: Development/Debug
rpm_buildhost: 2eee4dee3c844fb996093afbe6b3be33
rpm_sourcerpm: rh-python36-ovirt-engine-sdk-python-4.3.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-ovirt-engine-sdk-python.
  Debug information is useful when developing applications that use this
  package or when debugging this package.

rpm_vendor:
  Michael Pasternak, Juan Hernandez, Ondra Machacek <mishka8520@yahoo.com, juan.hernandez@redhat.com, omachace@redhat.com>

location_href:
  00944378-rh-python36-ovirt-engine-sdk-python/rh-python36-ovirt-engine-sdk-python-debuginfo-4.3.0-1.x86_64.rpm


pkgId: c86e54ad0f7e5a1704b4bd36bb0cbabeb3ba9d529a2cf9592a1e039f745c91c1
name: rh-python36-packaging
arch: noarch
version: 19.2
epoch: 0
release: 1
summary: Core utilities for Python packages
url: https://github.com/pypa/packaging
rpm_license: BSD or Apache License, Version 2.0
rpm_vendor: Donald Stufft and individual contributors <donald@stufft.io>
rpm_group: Development/Libraries
rpm_buildhost: 5e2771010a324eb992301e3b7ed687ff
rpm_sourcerpm: rh-python36-packaging-19.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143881-rh-python36-packaging/rh-python36-packaging-19.2-1.noarch.rpm
checksum_type: sha256
description:
  packaging
  =========

  Core utilities for Python packages


  Documentation
  -------------

  `documentation`_


  Discussion
  ----------

  If you run into bugs, you can file them in our `issue tracker`_.

  You can also join ``#pypa`` on Freenode to ask questions or get involved.


  .. _`documentation`: https://packaging.pypa.io/
  .. _`issue tracker`: https://github.com/pypa/packaging/issues


  Code of Conduct
  ---------------

  Everyone interacting in the packaging project's codebases, issue trackers, chat
  rooms, and mailing lists is expected to follow the `PyPA Code of Conduct`_.

  .. _PyPA Code of Conduct: https://www.pypa.io/en/latest/code-of-conduct/

  Changelog
  ---------

  17.1 - 2017-02-28
  ~~~~~~~~~~~~~~~~~

  * Fix ``utils.canonicalize_version`` when supplying non PEP 440 versions.


  17.0 - 2017-02-28
  ~~~~~~~~~~~~~~~~~

  * Drop support for python 2.6, 3.2, and 3.3.

  * Define minimal pyparsing version to 2.0.2 (`#91 <https://github.com/pypa/packaging/issues/91>`__).

  * Add ``epoch``, ``release``, ``pre``, ``dev``, and ``post`` attributes to
    ``Version`` and ``LegacyVersion`` (`#34 <https://github.com/pypa/packaging/issues/34>`__).

  * Add ``Version().is_devrelease`` and ``LegacyVersion().is_devrelease`` to
    make it easy to determine if a release is a development release.

  * Add ``utils.canonicalize_version`` to canonicalize version strings or
    ``Version`` instances (`#121 <https://github.com/pypa/packaging/issues/121>`__).


  16.8 - 2016-10-29
  ~~~~~~~~~~~~~~~~~

  * Fix markers that utilize ``in`` so that they render correctly.

  * Fix an erroneous test on Python RC releases.


  16.7 - 2016-04-23
  ~~~~~~~~~~~~~~~~~

  * Add support for the deprecated ``python_implementation`` marker which was
    an undocumented setuptools marker in addition to the newer markers.


  16.6 - 2016-03-29
  ~~~~~~~~~~~~~~~~~

  * Add support for the deprecated, PEP 345 environment markers in addition to
    the newer markers.


  16.5 - 2016-02-26
  ~~~~~~~~~~~~~~~~~

  * Fix a regression in parsing requirements with whitespaces between the comma
    separators.


  16.4 - 2016-02-22
  ~~~~~~~~~~~~~~~~~

  * Fix a regression in parsing requirements like ``foo (==4)``.


  16.3 - 2016-02-21
  ~~~~~~~~~~~~~~~~~

  * Fix a bug where ``packaging.requirements:Requirement`` was overly strict when
    matching legacy requirements.


  16.2 - 2016-02-09
  ~~~~~~~~~~~~~~~~~

  * Add a function that implements the name canonicalization from PEP 503.


  16.1 - 2016-02-07
  ~~~~~~~~~~~~~~~~~

  * Implement requirement specifiers from PEP 508.


  16.0 - 2016-01-19
  ~~~~~~~~~~~~~~~~~

  * Relicense so that packaging is available under *either* the Apache License,
    Version 2.0 or a 2 Clause BSD license.

  * Support installation of packaging when only distutils is available.

  * Fix ``==`` comparison when there is a prefix and a local version in play.
    (`#41 <https://github.com/pypa/packaging/issues/41>`__).

  * Implement environment markers from PEP 508.


  15.3 - 2015-08-01
  ~~~~~~~~~~~~~~~~~

  * Normalize post-release spellings for rev/r prefixes. `#35 <https://github.com/pypa/packaging/issues/35>`__


  15.2 - 2015-05-13
  ~~~~~~~~~~~~~~~~~

  * Fix an error where the arbitary specifier (``===``) was not correctly
    allowing pre-releases when it was being used.

  * Expose the specifier and version parts through properties on the
    ``Specifier`` classes.

  * Allow iterating over the ``SpecifierSet`` to get access to all of the
    ``Specifier`` instances.

  * Allow testing if a version is contained within a specifier via the ``in``
    operator.


  15.1 - 2015-04-13
  ~~~~~~~~~~~~~~~~~

  * Fix a logic error that was causing inconsistent answers about whether or not
    a pre-release was contained within a ``SpecifierSet`` or not.


  15.0 - 2015-01-02
  ~~~~~~~~~~~~~~~~~

  * Add ``Version().is_postrelease`` and ``LegacyVersion().is_postrelease`` to
    make it easy to determine if a release is a post release.

  * Add ``Version().base_version`` and ``LegacyVersion().base_version`` to make
    it easy to get the public version without any pre or post release markers.

  * Support the update to PEP 440 which removed the implied ``!=V.*`` when using
    either ``>V`` or ``<V`` and which instead special cased the handling of
    pre-releases, post-releases, and local versions when using ``>V`` or ``<V``.


  14.5 - 2014-12-17
  ~~~~~~~~~~~~~~~~~

  * Normalize release candidates as ``rc`` instead of ``c``.

  * Expose the ``VERSION_PATTERN`` constant, a regular expression matching
    a valid version.


  14.4 - 2014-12-15
  ~~~~~~~~~~~~~~~~~

  * Ensure that versions are normalized before comparison when used in a
    specifier with a less than (``<``) or greater than (``>``) operator.


  14.3 - 2014-11-19
  ~~~~~~~~~~~~~~~~~

  * **BACKWARDS INCOMPATIBLE** Refactor specifier support so that it can sanely
    handle legacy specifiers as well as PEP 440 specifiers.

  * **BACKWARDS INCOMPATIBLE** Move the specifier support out of
    ``packaging.version`` into ``packaging.specifiers``.


  14.2 - 2014-09-10
  ~~~~~~~~~~~~~~~~~

  * Add prerelease support to ``Specifier``.
  * Remove the ability to do ``item in Specifier()`` and replace it with
    ``Specifier().contains(item)`` in order to allow flags that signal if a
    prerelease should be accepted or not.
  * Add a method ``Specifier().filter()`` which will take an iterable and returns
    an iterable with items that do not match the specifier filtered out.


  14.1 - 2014-09-08
  ~~~~~~~~~~~~~~~~~

  * Allow ``LegacyVersion`` and ``Version`` to be sorted together.
  * Add ``packaging.version.parse()`` to enable easily parsing a version string
    as either a ``Version`` or a ``LegacyVersion`` depending on it's PEP 440
    validity.


  14.0 - 2014-09-05
  ~~~~~~~~~~~~~~~~~

  * Initial release.


pkgId: 4fe683e4e55260d4c11e91c904a552562dc3fd67b48e39a36b06b0d1fb7b852e
name: rh-python36-paramiko
arch: noarch
version: 2.7.1
epoch: 0
release: 1
summary: SSH2 protocol library
url: https://github.com/paramiko/paramiko/
rpm_license: LGPL
rpm_vendor: Jeff Forcier <jeff@bitprophet.org>
rpm_group: Development/Libraries
rpm_buildhost: 66100aa9a7c3434c80c6ccdc5a18c3a7
rpm_sourcerpm: rh-python36-paramiko-2.7.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143882-rh-python36-paramiko/rh-python36-paramiko-2.7.1-1.noarch.rpm
checksum_type: sha256
description:
  This is a library for making SSH2 connections (client or server).
  Emphasis is on using SSH2 as an alternative to SSL for making secure
  connections between python scripts.  All major ciphers and hash methods
  are supported.  SFTP client and server mode are both supported too.

  Required packages:
      Cryptography

  To install the development version, ``pip install -e
  git+https://github.com/paramiko/paramiko/#egg=paramiko``.


pkgId: 45c132623881c4f1c6d06f1ca60456444cdb25afe3dd27e36da76490af5edf8b
name: rh-python36-pbr
arch: noarch
version: 5.4.4
epoch: 0
release: 1
summary: Python Build Reasonableness
url: https://docs.openstack.org/pbr/latest/
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-dev@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: a1b5f9e41e2242e5a94fbf184fd18955
rpm_sourcerpm: rh-python36-pbr-5.4.4-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01123458-rh-python36-pbr/rh-python36-pbr-5.4.4-1.noarch.rpm
checksum_type: sha256
description:
  Introduction
  ============

  .. image:: https://img.shields.io/pypi/v/pbr.svg
      :target: https://pypi.python.org/pypi/pbr/
      :alt: Latest Version

  .. image:: https://img.shields.io/pypi/dm/pbr.svg
      :target: https://pypi.python.org/pypi/pbr/
      :alt: Downloads

  PBR is a library that injects some useful and sensible default behaviors
  into your setuptools run. It started off life as the chunks of code that
  were copied between all of the `OpenStack`_ projects. Around the time that
  OpenStack hit 18 different projects each with at least 3 active branches,
  it seemed like a good time to make that code into a proper reusable library.

  PBR is only mildly configurable. The basic idea is that there's a decent
  way to run things and if you do, you should reap the rewards, because then
  it's simple and repeatable. If you want to do things differently, cool! But
  you've already got the power of Python at your fingertips, so you don't
  really need PBR.

  PBR builds on top of the work that `d2to1`_ started to provide for declarative
  configuration. `d2to1`_ is itself an implementation of the ideas behind
  `distutils2`_. Although `distutils2`_ is now abandoned in favor of work towards
  `PEP 426`_ and Metadata 2.0, declarative config is still a great idea and
  specifically important in trying to distribute setup code as a library
  when that library itself will alter how the setup is processed. As Metadata
  2.0 and other modern Python packaging PEPs come out, PBR aims to support
  them as quickly as possible.

  * License: Apache License, Version 2.0
  * Documentation: https://docs.openstack.org/pbr/latest/
  * Source: https://git.openstack.org/cgit/openstack-dev/pbr
  * Bugs: https://bugs.launchpad.net/pbr
  * Change Log: https://docs.openstack.org/pbr/latest/user/history.html

  .. _d2to1: https://pypi.python.org/pypi/d2to1
  .. _distutils2: https://pypi.python.org/pypi/Distutils2
  .. _PEP 426: http://legacy.python.org/dev/peps/pep-0426/
  .. _OpenStack: https://www.openstack.org/


pkgId: 885b4b39117d120fa5543339380bec251e6f4421ea8b09fad88d74285610074b
name: rh-python36-pexpect
arch: noarch
version: 4.7.0
epoch: 0
release: 1
summary: Pexpect allows easy control of interactive console applications.
url: https://pexpect.readthedocs.io/
rpm_license: ISC license
rpm_group: Development/Libraries
rpm_buildhost: f38833316149439983d12c28a5ad10cc
rpm_sourcerpm: rh-python36-pexpect-4.7.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00890997-rh-python36-pexpect/rh-python36-pexpect-4.7.0-1.noarch.rpm
checksum_type: sha256
description:
  Pexpect is a pure Python module for spawning child applications; controlling
  them; and responding to expected patterns in their output. Pexpect works like
  Don Libes' Expect. Pexpect allows your script to spawn a child application and
  control it as if a human were typing commands.

  Pexpect can be used for automating interactive applications such as ssh, ftp,
  passwd, telnet, etc. It can be used to a automate setup scripts for duplicating
  software package installations on different servers. It can be used for
  automated software testing. Pexpect is in the spirit of Don Libes' Expect, but
  Pexpect is pure Python.

  The main features of Pexpect require the pty module in the Python standard
  library, which is only available on Unix-like systems. Some features—waiting
  for patterns from file descriptors or subprocesses—are also available on
  Windows.

rpm_vendor:
  Noah Spurrier; Thomas Kluyver; Jeff Quast <noah@noah.org, thomas@kluyver.me.uk, contact@jeffquast.com>


pkgId: 8ecb744e1c13128ba2284ad702a57effdc18a2e81f3d6d5f60007f767bc72760
name: rh-python36-pkgconfig
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Interface Python with pkg-config
url: http://github.com/matze/pkgconfig
rpm_license: MIT
rpm_vendor: Matthias Vogelgesang <matthias.vogelgesang@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 6eb0baf17c3c46979f9744d06735baec
rpm_sourcerpm: rh-python36-pkgconfig-1.4.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850337-rh-python36-pkgconfig/rh-python36-pkgconfig-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  pkgconfig
  =========

  .. image:: https://travis-ci.org/matze/pkgconfig.png?branch=master
      :target: https://travis-ci.org/matze/pkgconfig

  ``pkgconfig`` is a Python module to interface with the ``pkg-config``
  command line tool and supports Python 2.6+.

  It can be used to

  -  find all pkg-config packages ::

         >>> packages = pkgconfig.list_all()

  -  check if a package exists ::

         >>> pkgconfig.exists('glib-2.0')
         True

  -  check if a package meets certain version requirements ::

         >>> pkgconfig.installed('glib-2.0', '< 2.26')
         False

  -  query CFLAGS and LDFLAGS ::

         >>> pkgconfig.cflags('glib-2.0')
         '-I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include'

         >>> pkgconfig.libs('glib-2.0')
         '-lglib-2.0'

  -  get all variables defined for a package::

          >>> pkgconfig.variables('glib-2.0')
          {u'exec_prefix': u'/usr'}

  -  parse the output to build extensions with setup.py ::

         >>> d = pkgconfig.parse('glib-2.0 gtk+-2.0')
         >>> d['libraries']
         [u'gtk+-2.0', u'glib-2.0']

     The ``pkgconfig.parse`` function return a dictonary of list.
     The lists returned are an accurate representations of the equivalent
     ``pkg-config`` call, both in content and order.

  If ``pkg-config`` is not on the path, raises ``EnvironmentError``.

  The ``pkgconfig`` module is licensed under the MIT license.


  Changelog
  ---------

  Version 1.4.0
  ~~~~~~~~~~~~~

  - Add boolean ``static`` keyword to output private libraries as well
  - Raise original ``OSError`` as well

  Version 1.3.1
  ~~~~~~~~~~~~~

  - Fix compatibility problems with Python 2.6

  Version 1.3.0
  ~~~~~~~~~~~~~

  - Add variables() API to query defined variables
  - Disable Python 3.2 and enable Python 3.5 and 3.6 tests
  - Fix #16: handle spaces of values in .pc files correctly

  Version 1.2.1 and 1.2.2
  ~~~~~~~~~~~~~~~~~~~~~~~

  Bug fix releases released on December 1st and 2nd 2016.

  - Include the ``data`` folder in the distribution in order to run tests
  - Improve the tests


  Version 1.2.0
  ~~~~~~~~~~~~~

  Released on November 30th 2016.

  - Potential break: switch from result set to list
  - Expose --list-all query
  - Added support for PKG_CONFIG environment variable


  Version 1.1.0
  ~~~~~~~~~~~~~

  Released on November 6th 2013.

  - Multiple packages can now be parsed with a single call to ``.parse``.


  Version 1.0.0
  ~~~~~~~~~~~~~

  First release on September 8th 2013.


pkgId: 703acbbffb79a4f97bbc0da5e3da62903b8877a514b7cb5e43d0db426873629c
name: rh-python36-prettytable
arch: noarch
version: 0.7.2
epoch: 0
release: 1
description: UNKNOWN
url: http://code.google.com/p/prettytable
rpm_license: BSD (3 clause)
rpm_vendor: Luke Maurits <luke@maurits.id.au>
rpm_group: Development/Libraries
rpm_buildhost: 1c55112393a7421a94b67da3c9818f90
rpm_sourcerpm: rh-python36-prettytable-0.7.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887909-rh-python36-prettytable/rh-python36-prettytable-0.7.2-1.noarch.rpm
checksum_type: sha256
summary:
  A simple Python library for easily displaying tabular data in a visually appealing ASCII table format


pkgId: c0309aed08f338b2e7ff205ae540ed2f374f4842a4f2adbb9274d3ec2868fec9
name: rh-python36-psutil
arch: src
version: 5.7.0
epoch: 0
release: 1
summary: Cross-platform lib for process and system monitoring in Python.
url: https://github.com/giampaolo/psutil
rpm_license: BSD
rpm_vendor: Giampaolo Rodola <g.rodola@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: e7eac4be23154862a367040a5396ea12
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01314010-rh-python36-psutil/rh-python36-psutil-5.7.0-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/travis/giampaolo/psutil/master.svg?maxAge=3600&label=Linux%20/%20OSX
      :target: https://travis-ci.org/giampaolo/psutil
      :alt: Linux tests (Travis)

  .. image:: https://img.shields.io/appveyor/ci/giampaolo/psutil/master.svg?maxAge=3600&label=Windows
      :target: https://ci.appveyor.com/project/giampaolo/psutil
      :alt: Windows tests (Appveyor)

  .. image:: https://coveralls.io/repos/github/giampaolo/psutil/badge.svg?branch=master
      :target: https://coveralls.io/github/giampaolo/psutil?branch=master
      :alt: Test coverage (coverall.io)

  .. image:: https://readthedocs.org/projects/psutil/badge/?version=latest
      :target: http://psutil.readthedocs.io/en/latest/?badge=latest
      :alt: Documentation Status

  .. image:: https://img.shields.io/pypi/v/psutil.svg?label=pypi
      :target: https://pypi.python.org/pypi/psutil/
      :alt: Latest version

  .. image:: https://img.shields.io/github/stars/giampaolo/psutil.svg
      :target: https://github.com/giampaolo/psutil/
      :alt: Github stars

  .. image:: https://img.shields.io/pypi/l/psutil.svg
      :target: https://pypi.python.org/pypi/psutil/
      :alt: License

  ===========
  Quick links
  ===========

  - `Home page <https://github.com/giampaolo/psutil>`_
  - `Install <https://github.com/giampaolo/psutil/blob/master/INSTALL.rst>`_
  - `Documentation <http://psutil.readthedocs.io>`_
  - `Download <https://pypi.python.org/pypi?:action=display&name=psutil#downloads>`_
  - `Forum <http://groups.google.com/group/psutil/topics>`_
  - `Blog <http://grodola.blogspot.com/search/label/psutil>`_
  - `Development guide <https://github.com/giampaolo/psutil/blob/master/DEVGUIDE.rst>`_
  - `What's new <https://github.com/giampaolo/psutil/blob/master/HISTORY.rst>`_

  =======
  Summary
  =======

  psutil (process and system utilities) is a cross-platform library for
  retrieving information on **running processes** and **system utilization**
  (CPU, memory, disks, network, sensors) in Python.
  It is useful mainly for **system monitoring**, **profiling and limiting process
  resources** and **management of running processes**.
  It implements many functionalities offered by UNIX command line tools such as:
  ps, top, lsof, netstat, ifconfig, who, df, kill, free, nice, ionice, iostat,
  iotop, uptime, pidof, tty, taskset, pmap.
  psutil currently supports the following platforms:

  - **Linux**
  - **Windows**
  - **OSX**,
  - **FreeBSD, OpenBSD**, **NetBSD**
  - **Sun Solaris**
  - **AIX**

  ...both **32-bit** and **64-bit** architectures, with Python
  versions from **2.6 to 3.6**.
  `PyPy <http://pypy.org/>`__ is also known to work.

  ====================
  Example applications
  ====================

  +------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------+
  | .. image:: https://github.com/giampaolo/psutil/blob/master/docs/_static/procinfo-small.png     | .. image:: https://github.com/giampaolo/psutil/blob/master/docs/_static/top-small.png      |
  |    :target: https://github.com/giampaolo/psutil/blob/master/docs/_static/procinfo.png          |     :target: https://github.com/giampaolo/psutil/blob/master/docs/_static/top.png          |
  +------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------+
  | .. image:: https://github.com/giampaolo/psutil/blob/master/docs/_static/procsmem-small.png     | .. image:: https://github.com/giampaolo/psutil/blob/master/docs/_static/pmap-small.png     |
  |     :target: https://github.com/giampaolo/psutil/blob/master/docs/_static/procsmem.png         |     :target: https://github.com/giampaolo/psutil/blob/master/docs/_static/pmap.png         |
  +------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------+

  Also see `scripts directory <https://github.com/giampaolo/psutil/tree/master/scripts>`__
  and `doc recipes <http://psutil.readthedocs.io/#recipes/>`__.

  =====================
  Projects using psutil
  =====================

  At the time of writing psutil has roughly
  `2.9 milion downloads <https://github.com/giampaolo/psutil/issues/1053#issuecomment-340166262>`__
  per month and there are over
  `6000 open source projects <https://libraries.io/pypi/psutil/dependent_repositories?page=1>`__
  on github which depend from psutil.
  Here's some I find particularly interesting:

  - https://github.com/facebook/osquery/
  - https://github.com/nicolargo/glances
  - https://github.com/google/grr
  - https://github.com/Jahaja/psdash
  - https://github.com/ajenti/ajenti
  - https://github.com/home-assistant/home-assistant/

  ========
  Portings
  ========

  - Go: https://github.com/shirou/gopsutil
  - C: https://github.com/hamon-in/cpslib
  - Node: https://github.com/christkv/node-psutil
  - Rust: https://github.com/borntyping/rust-psutil
  - Ruby: https://github.com/spacewander/posixpsutil
  - Nim: https://github.com/johnscillieri/psutil-nim

  ==============
  Example usages
  ==============

  CPU
  ===

  .. code-block:: python

      >>> import psutil
      >>> psutil.cpu_times()
      scputimes(user=3961.46, nice=169.729, system=2150.659, idle=16900.540, iowait=629.59, irq=0.0, softirq=19.42, steal=0.0, guest=0, nice=0.0)
      >>>
      >>> for x in range(3):
      ...     psutil.cpu_percent(interval=1)
      ...
      4.0
      5.9
      3.8
      >>>
      >>> for x in range(3):
      ...     psutil.cpu_percent(interval=1, percpu=True)
      ...
      [4.0, 6.9, 3.7, 9.2]
      [7.0, 8.5, 2.4, 2.1]
      [1.2, 9.0, 9.9, 7.2]
      >>>
      >>> for x in range(3):
      ...     psutil.cpu_times_percent(interval=1, percpu=False)
      ...
      scputimes(user=1.5, nice=0.0, system=0.5, idle=96.5, iowait=1.5, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
      scputimes(user=1.0, nice=0.0, system=0.0, idle=99.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
      scputimes(user=2.0, nice=0.0, system=0.0, idle=98.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
      >>>
      >>> psutil.cpu_count()
      4
      >>> psutil.cpu_count(logical=False)
      2
      >>>
      >>> psutil.cpu_stats()
      scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)
      >>>
      >>> psutil.cpu_freq()
      scpufreq(current=931.42925, min=800.0, max=3500.0)
      >>>

  Memory
  ======

  .. code-block:: python

      >>> import psutil
      >>> psutil.virtual_memory()
      svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, active=4748992512, inactive=2758115328, buffers=790724608, cached=3500347392, shared=787554304)
      >>> psutil.swap_memory()
      sswap(total=2097147904, used=296128512, free=1801019392, percent=14.1, sin=304193536, sout=677842944)
      >>>

  Disks
  =====

  .. code-block:: python

      >>> import psutil
      >>> psutil.disk_partitions()
      [sdiskpart(device='/dev/sda1', mountpoint='/', fstype='ext4', opts='rw,nosuid'),
       sdiskpart(device='/dev/sda2', mountpoint='/home', fstype='ext, opts='rw')]
      >>>
      >>> psutil.disk_usage('/')
      sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
      >>>
      >>> psutil.disk_io_counters(perdisk=False)
      sdiskio(read_count=719566, write_count=1082197, read_bytes=18626220032, write_bytes=24081764352, read_time=5023392, write_time=63199568, read_merged_count=619166, write_merged_count=812396, busy_time=4523412)
      >>>

  Network
  =======

  .. code-block:: python

      >>> import psutil
      >>> psutil.net_io_counters(pernic=True)
      {'eth0': netio(bytes_sent=485291293, bytes_recv=6004858642, packets_sent=3251564, packets_recv=4787798, errin=0, errout=0, dropin=0, dropout=0),
       'lo': netio(bytes_sent=2838627, bytes_recv=2838627, packets_sent=30567, packets_recv=30567, errin=0, errout=0, dropin=0, dropout=0)}
      >>>
      >>> psutil.net_connections()
      [sconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status='ESTABLISHED', pid=1254),
       sconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status='CLOSING', pid=2987),
       sconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=60759), raddr=addr(ip='72.14.234.104', port=80), status='ESTABLISHED', pid=None),
       sconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=51314), raddr=addr(ip='72.14.234.83', port=443), status='SYN_SENT', pid=None)
       ...]
      >>>
      >>> psutil.net_if_addrs()
      {'lo': [snic(family=<AddressFamily.AF_INET: 2>, address='127.0.0.1', netmask='255.0.0.0', broadcast='127.0.0.1', ptp=None),
              snic(family=<AddressFamily.AF_INET6: 10>, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None),
              snic(family=<AddressFamily.AF_LINK: 17>, address='00:00:00:00:00:00', netmask=None, broadcast='00:00:00:00:00:00', ptp=None)],
       'wlan0': [snic(family=<AddressFamily.AF_INET: 2>, address='192.168.1.3', netmask='255.255.255.0', broadcast='192.168.1.255', ptp=None),
                 snic(family=<AddressFamily.AF_INET6: 10>, address='fe80::c685:8ff:fe45:641%wlan0', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None),
                 snic(family=<AddressFamily.AF_LINK: 17>, address='c4:85:08:45:06:41', netmask=None, broadcast='ff:ff:ff:ff:ff:ff', ptp=None)]}
      >>>
      >>> psutil.net_if_stats()
      {'eth0': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=100, mtu=1500),
       'lo': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>, speed=0, mtu=65536)}
      >>>

  Sensors
  =======

  .. code-block:: python

      >>> import psutil
      >>> psutil.sensors_temperatures()
      {'acpitz': [shwtemp(label='', current=47.0, high=103.0, critical=103.0)],
       'asus': [shwtemp(label='', current=47.0, high=None, critical=None)],
       'coretemp': [shwtemp(label='Physical id 0', current=52.0, high=100.0, critical=100.0),
                    shwtemp(label='Core 0', current=45.0, high=100.0, critical=100.0),
                    shwtemp(label='Core 1', current=52.0, high=100.0, critical=100.0),
                    shwtemp(label='Core 2', current=45.0, high=100.0, critical=100.0),
                    shwtemp(label='Core 3', current=47.0, high=100.0, critical=100.0)]}
      >>>
      >>> psutil.sensors_fans()
      {'asus': [sfan(label='cpu_fan', current=3200)]}
      >>>
      >>> psutil.sensors_battery()
      sbattery(percent=93, secsleft=16628, power_plugged=False)
      >>>

  Other system info
  =================

  .. code-block:: python

      >>> import psutil
      >>> psutil.users()
      [suser(name='giampaolo', terminal='pts/2', host='localhost', started=1340737536.0, pid=1352),
       suser(name='giampaolo', terminal='pts/3', host='localhost', started=1340737792.0, pid=1788)]
      >>>
      >>> psutil.boot_time()
      1365519115.0
      >>>

  Process management
  ==================

  .. code-block:: python

      >>> import psutil
      >>> psutil.pids()
      [1, 2, 3, 4, 5, 6, 7, 46, 48, 50, 51, 178, 182, 222, 223, 224, 268, 1215, 1216, 1220, 1221, 1243, 1244,
       1301, 1601, 2237, 2355, 2637, 2774, 3932, 4176, 4177, 4185, 4187, 4189, 4225, 4243, 4245, 4263, 4282,
       4306, 4311, 4312, 4313, 4314, 4337, 4339, 4357, 4358, 4363, 4383, 4395, 4408, 4433, 4443, 4445, 4446,
       5167, 5234, 5235, 5252, 5318, 5424, 5644, 6987, 7054, 7055, 7071]
      >>>
      >>> p = psutil.Process(7055)
      >>> p.name()
      'python'
      >>> p.exe()
      '/usr/bin/python'
      >>> p.cwd()
      '/home/giampaolo'
      >>> p.cmdline()
      ['/usr/bin/python', 'main.py']
      >>>
      >>> p.pid
      7055
      >>> p.ppid()
      7054
      >>> p.parent()
      <psutil.Process(pid=7054, name='bash') at 140008329539408>
      >>> p.children()
      [<psutil.Process(pid=8031, name='python') at 14020832451977>,
       <psutil.Process(pid=8044, name='python') at 19229444921932>]
      >>>
      >>> p.status()
      'running'
      >>> p.username()
      'giampaolo'
      >>> p.create_time()
      1267551141.5019531
      >>> p.terminal()
      '/dev/pts/0'
      >>>
      >>> p.uids()
      puids(real=1000, effective=1000, saved=1000)
      >>> p.gids()
      pgids(real=1000, effective=1000, saved=1000)
      >>>
      >>> p.cpu_times()
      pcputimes(user=1.02, system=0.31, children_user=0.32, children_system=0.1)
      >>> p.cpu_percent(interval=1.0)
      12.1
      >>> p.cpu_affinity()
      [0, 1, 2, 3]
      >>> p.cpu_affinity([0, 1])  # set
      >>> p.cpu_num()
      1
      >>>
      >>> p.memory_info()
      pmem(rss=10915840, vms=67608576, shared=3313664, text=2310144, lib=0, data=7262208, dirty=0)
      >>> p.memory_full_info()  # "real" USS memory usage (Linux, OSX, Win only)
      pfullmem(rss=10199040, vms=52133888, shared=3887104, text=2867200, lib=0, data=5967872, dirty=0, uss=6545408, pss=6872064, swap=0)
      >>> p.memory_percent()
      0.7823
      >>> p.memory_maps()
      [pmmap_grouped(path='/lib/x8664-linux-gnu/libutil-2.15.so', rss=32768, size=2125824, pss=32768, shared_clean=0, shared_dirty=0, private_clean=20480, private_dirty=12288, referenced=32768, anonymous=12288, swap=0),
       pmmap_grouped(path='/lib/x8664-linux-gnu/libc-2.15.so', rss=3821568, size=3842048, pss=3821568, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=3821568, referenced=3575808, anonymous=3821568, swap=0),
       pmmap_grouped(path='/lib/x8664-linux-gnu/libcrypto.so.0.1', rss=34124, rss=32768, size=2134016, pss=15360, shared_clean=24576, shared_dirty=0, private_clean=0, private_dirty=8192, referenced=24576, anonymous=8192, swap=0),
       pmmap_grouped(path='[heap]',  rss=32768, size=139264, pss=32768, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=32768, referenced=32768, anonymous=32768, swap=0),
       pmmap_grouped(path='[stack]', rss=2465792, size=2494464, pss=2465792, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=2465792, referenced=2277376, anonymous=2465792, swap=0),
       ...]
      >>>
      >>> p.io_counters()
      pio(read_count=478001, write_count=59371, read_bytes=700416, write_bytes=69632, read_chars=456232, write_chars=517543)
      >>>
      >>> p.open_files()
      [popenfile(path='/home/giampaolo/svn/psutil/setup.py', fd=3, position=0, mode='r', flags=32768),
       popenfile(path='/var/log/monitd', fd=4, position=235542, mode='a', flags=33793)]
      >>>
      >>> p.connections()
      [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status='ESTABLISHED'),
       pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status='CLOSING'),
       pconn(fd=119, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=60759), raddr=addr(ip='72.14.234.104', port=80), status='ESTABLISHED'),
       pconn(fd=123, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=51314), raddr=addr(ip='72.14.234.83', port=443), status='SYN_SENT')]
      >>>
      >>> p.num_threads()
      4
      >>> p.num_fds()
      8
      >>> p.threads()
      [pthread(id=5234, user_time=22.5, system_time=9.2891),
       pthread(id=5235, user_time=0.0, system_time=0.0),
       pthread(id=5236, user_time=0.0, system_time=0.0),
       pthread(id=5237, user_time=0.0707, system_time=1.1)]
      >>>
      >>> p.num_ctx_switches()
      pctxsw(voluntary=78, involuntary=19)
      >>>
      >>> p.nice()
      0
      >>> p.nice(10)  # set
      >>>
      >>> p.ionice(psutil.IOPRIO_CLASS_IDLE)  # IO priority (Win and Linux only)
      >>> p.ionice()
      pionice(ioclass=<IOPriority.IOPRIO_CLASS_IDLE: 3>, value=0)
      >>>
      >>> p.rlimit(psutil.RLIMIT_NOFILE, (5, 5))  # set resource limits (Linux only)
      >>> p.rlimit(psutil.RLIMIT_NOFILE)
      (5, 5)
      >>>
      >>> p.environ()
      {'LC_PAPER': 'it_IT.UTF-8', 'SHELL': '/bin/bash', 'GREP_OPTIONS': '--color=auto',
      'XDG_CONFIG_DIRS': '/etc/xdg/xdg-ubuntu:/usr/share/upstart/xdg:/etc/xdg', 'COLORTERM': 'gnome-terminal',
       ...}
      >>>
      >>> p.as_dict()
      {'status': 'running', 'num_ctx_switches': pctxsw(voluntary=63, involuntary=1), 'pid': 5457, ...}
      >>> p.is_running()
      True
      >>> p.suspend()
      >>> p.resume()
      >>>
      >>> p.terminate()
      >>> p.wait(timeout=3)
      0
      >>>
      >>> psutil.test()
      USER         PID %CPU %MEM     VSZ     RSS TTY        START    TIME  COMMAND
      root           1  0.0  0.0   24584    2240            Jun17   00:00  init
      root           2  0.0  0.0       0       0            Jun17   00:00  kthreadd
      root           3  0.0  0.0       0       0            Jun17   00:05  ksoftirqd/0
      ...
      giampaolo  31475  0.0  0.0   20760    3024 /dev/pts/0 Jun19   00:00  python2.4
      giampaolo  31721  0.0  2.2  773060  181896            00:04   10:30  chrome
      root       31763  0.0  0.0       0       0            00:05   00:00  kworker/0:1
      >>>

  Further process APIs
  ====================

  .. code-block:: python

      >>> import psutil
      >>> for proc in psutil.process_iter(attrs=['pid', 'name']):
      ...     print(proc.info)
      ...
      {'pid': 1, 'name': 'systemd'}
      {'pid': 2, 'name': 'kthreadd'}
      {'pid': 3, 'name': 'ksoftirqd/0'}
      ...
      >>>
      >>> psutil.pid_exists(3)
      True
      >>>
      >>> def on_terminate(proc):
      ...     print("process {} terminated".format(proc))
      ...
      >>> # waits for multiple processes to terminate
      >>> gone, alive = psutil.wait_procs(procs_list, timeout=3, callback=on_terminate)
      >>>

  Popen wrapper:

  .. code-block:: python

      >>> import psutil
      >>> from subprocess import PIPE
      >>> p = psutil.Popen(["/usr/bin/python", "-c", "print('hello')"], stdout=PIPE)
      >>> p.name()
      'python'
      >>> p.username()
      'giampaolo'
      >>> p.communicate()
      ('hello\n', None)
      >>> p.wait(timeout=2)
      0
      >>>

  Windows services
  ================

  .. code-block:: python

      >>> list(psutil.win_service_iter())
      [<WindowsService(name='AeLookupSvc', display_name='Application Experience') at 38850096>,
       <WindowsService(name='ALG', display_name='Application Layer Gateway Service') at 38850128>,
       <WindowsService(name='APNMCP', display_name='Ask Update Service') at 38850160>,
       <WindowsService(name='AppIDSvc', display_name='Application Identity') at 38850192>,
       ...]
      >>> s = psutil.win_service_get('alg')
      >>> s.as_dict()
      {'binpath': 'C:\\Windows\\System32\\alg.exe',
       'description': 'Provides support for 3rd party protocol plug-ins for Internet Connection Sharing',
       'display_name': 'Application Layer Gateway Service',
       'name': 'alg',
       'pid': None,
       'start_type': 'manual',
       'status': 'stopped',
       'username': 'NT AUTHORITY\\LocalService'}

  Other samples
  =============

  See `doc recipes <http://psutil.readthedocs.io/#recipes>`__.

  ======
  Author
  ======

  psutil was created and is maintained by
  `Giampaolo Rodola' <http://grodola.blogspot.com/p/about.html>`__.
  A lot of time and effort went into making psutil as it is right now.
  If you feel psutil is useful to you or your business and want to support its
  future development please consider donating me
  (`Giampaolo <http://grodola.blogspot.com/p/about.html>`__) some money.

  .. image:: http://www.paypal.com/en_US/i/btn/x-click-but04.gif
      :target: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=A9ZS7PKKRM3S8
      :alt: Donate via PayPal

  Don't want to donate money? Then maybe you could `write me a recommendation on Linkedin <https://www.linkedin.com/in/grodola>`_.


pkgId: 75b7a15d193bbc7e3f6837e27282c78791264562e276f4da4c7bafc16e2b3eca
name: rh-python36-psutil-debuginfo
arch: x86_64
version: 5.7.0
epoch: 0
release: 1
summary: Debug information for package rh-python36-psutil
url: https://github.com/giampaolo/psutil
rpm_license: BSD
rpm_vendor: Giampaolo Rodola <g.rodola@gmail.com>
rpm_group: Development/Debug
rpm_buildhost: a4dc5bd71bdb43a2ac11c81580139cc9
rpm_sourcerpm: rh-python36-psutil-5.7.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01314010-rh-python36-psutil/rh-python36-psutil-debuginfo-5.7.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-psutil.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: cb8bf900cdf9ca0e1fead9c368556bfd8381f9379f14fe6d13de4a28b4d53559
name: rh-python36-psycopg2
arch: src
version: 2.8.4
epoch: 0
release: 1
summary: psycopg2 - Python-PostgreSQL Database Adapter
url: http://initd.org/psycopg/
rpm_license: LGPL with exceptions or ZPL
rpm_vendor: Federico Di Gregorio <fog@initd.org>
rpm_group: Development/Libraries
rpm_buildhost: 8b91c5f40b714a2ca14497b2b3d740c3
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143817-rh-python36-psycopg2/rh-python36-psycopg2-2.8.4-1.src.rpm
checksum_type: sha256
description:
  Psycopg is the most popular PostgreSQL database adapter for the Python
  programming language.  Its main features are the complete implementation of
  the Python DB API 2.0 specification and the thread safety (several threads can
  share the same connection).  It was designed for heavily multi-threaded
  applications that create and destroy lots of cursors and make a large number
  of concurrent "INSERT"s or "UPDATE"s.

  Psycopg 2 is mostly implemented in C as a libpq wrapper, resulting in being
  both efficient and secure.  It features client-side and server-side cursors,
  asynchronous communication and notifications, "COPY TO/COPY FROM" support.
  Many Python types are supported out-of-the-box and adapted to matching
  PostgreSQL data types; adaptation can be extended and customized thanks to a
  flexible objects adaptation system.

  Psycopg 2 is both Unicode and Python 3 friendly.


  Documentation
  -------------

  Documentation is included in the ``doc`` directory and is `available online`__.

  .. __: http://initd.org/psycopg/docs/


  Installation
  ------------

  If your ``pip`` version supports wheel_ packages it should be possible to
  install a binary version of Psycopg including all the dependencies from PyPI_.
  Just run::

      $ pip install -U pip      # make sure your pip is up-to-date
      $ pip install psycopg2

  If you want to build Psycopg from source you will need some prerequisites (a C
  compiler, development packages): please check the install_ and the faq_
  documents in the ``doc`` dir for the details.

  .. _wheel: http://pythonwheels.com/
  .. _PyPI: https://pypi.python.org/pypi/psycopg2
  .. _install: http://initd.org/psycopg/docs/install.html#install-from-source
  .. _faq: http://initd.org/psycopg/docs/faq.html#faq-compile

  For any other resource (source code repository, bug tracker, mailing list)
  please check the `project homepage`__.

  .. __: http://initd.org/psycopg/


  :Linux/OSX: |travis|
  :Windows: |appveyor|

  .. |travis| image:: https://travis-ci.org/psycopg/psycopg2.svg?branch=master
      :target: https://travis-ci.org/psycopg/psycopg2
      :alt: Linux and OSX build status

  .. |appveyor| image:: https://ci.appveyor.com/api/projects/status/github/psycopg/psycopg2?branch=master&svg=true
      :target: https://ci.appveyor.com/project/psycopg/psycopg2/branch/master
      :alt: Windows build status


pkgId: fa0170df3c850166ba037526c5a5af6f15b48cdd611d1ddd04ac00ff5bf95afa
name: rh-python36-psycopg2-debuginfo
arch: x86_64
version: 2.8.4
epoch: 0
release: 1
summary: Debug information for package rh-python36-psycopg2
url: http://initd.org/psycopg/
rpm_license: LGPL with exceptions or ZPL
rpm_vendor: Federico Di Gregorio <fog@initd.org>
rpm_group: Development/Debug
rpm_buildhost: f0c348402b104fb19149b9902c5a5fc1
rpm_sourcerpm: rh-python36-psycopg2-2.8.4-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143817-rh-python36-psycopg2/rh-python36-psycopg2-debuginfo-2.8.4-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-psycopg2.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: febf43000d1ea0a5194a17e3659aa412be61ecd408deefc605106b0e692b6b3f
name: rh-python36-pyOpenSSL
arch: noarch
version: 19.0.0
epoch: 0
release: 1
summary: Python wrapper module around the OpenSSL library
url: https://pyopenssl.org/
rpm_license: Apache License, Version 2.0
rpm_vendor: Hynek Schlawack <hs@ox.cx>
rpm_group: Development/Libraries
rpm_buildhost: 2f9944564f0a46a4973aecf76c8dc9c8
rpm_sourcerpm: rh-python36-pyOpenSSL-19.0.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850452-rh-python36-pyOpenSSL/rh-python36-pyOpenSSL-19.0.0-1.noarch.rpm
checksum_type: sha256
description:
  ========================================================
  pyOpenSSL -- A Python wrapper around the OpenSSL library
  ========================================================

  .. image:: https://readthedocs.org/projects/pyopenssl/badge/?version=stable
     :target: https://pyopenssl.org/en/stable/
     :alt: Stable Docs

  .. image:: https://travis-ci.org/pyca/pyopenssl.svg?branch=master
     :target: https://travis-ci.org/pyca/pyopenssl
     :alt: Build status

  .. image:: https://codecov.io/github/pyca/pyopenssl/branch/master/graph/badge.svg
     :target: https://codecov.io/github/pyca/pyopenssl
     :alt: Test coverage

  **Note:** The Python Cryptographic Authority **strongly suggests** the use of `pyca/cryptography`_
  where possible. If you are using pyOpenSSL for anything other than making a TLS connection
  **you should move to cryptography and drop your pyOpenSSL dependency**.

  High-level wrapper around a subset of the OpenSSL library. Includes

  * ``SSL.Connection`` objects, wrapping the methods of Python's portable sockets
  * Callbacks written in Python
  * Extensive error-handling mechanism, mirroring OpenSSL's error codes

  ... and much more.

  You can find more information in the documentation_.
  Development takes place on GitHub_.


  Discussion
  ==========

  If you run into bugs, you can file them in our `issue tracker`_.

  We maintain a cryptography-dev_ mailing list for both user and development discussions.

  You can also join ``#cryptography-dev`` on Freenode to ask questions or get involved.


  .. _documentation: https://pyopenssl.org/
  .. _`issue tracker`: https://github.com/pyca/pyopenssl/issues
  .. _cryptography-dev: https://mail.python.org/mailman/listinfo/cryptography-dev
  .. _GitHub: https://github.com/pyca/pyopenssl
  .. _`pyca/cryptography`: https://github.com/pyca/cryptography


  Release Information
  ===================

  19.0.0 (2019-01-21)
  -------------------


  Backward-incompatible changes:
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  - ``X509Store.add_cert`` no longer raises an error if you add a duplicate cert.
    `#787 <https://github.com/pyca/pyopenssl/pull/787>`_


  Deprecations:
  ^^^^^^^^^^^^^

  *none*


  Changes:
  ^^^^^^^^

  - pyOpenSSL now works with OpenSSL 1.1.1.
    `#805 <https://github.com/pyca/pyopenssl/pull/805>`_
  - pyOpenSSL now handles NUL bytes in ``X509Name.get_components()``
    `#804 <https://github.com/pyca/pyopenssl/pull/804>`_


  `Full changelog <https://pyopenssl.org/en/stable/changelog.html>`_.


pkgId: eb7d352a8e2806213ab5bce2e8a33fa6987cd9f11820438e7cafa9d7044c1bcb
name: rh-python36-pyasn1-modules
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: A collection of ASN.1-based protocols modules.
url: https://github.com/etingof/pyasn1-modules
rpm_license: BSD
rpm_vendor: Ilya Etingof <etingof@gmail.com> <etingof@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: e32445ab6ee8419dad0e3219efc2e6dc
rpm_sourcerpm: rh-python36-pyasn1-modules-0.2.8-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311576-rh-python36-pyasn1-modules/rh-python36-pyasn1-modules-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
  A collection of ASN.1 modules expressed in form of pyasn1 classes. Includes protocols PDUs definition (SNMP, LDAP etc.) and various data structures (X.509, PKCS etc.).


pkgId: 3a2ba0c2d0e8533c744b31493b3e14a1c1170741e45b315b2932012a10d5b645
name: rh-python36-pycparser
arch: noarch
version: 2.20
epoch: 0
release: 1
summary: C parser in Python
url: https://github.com/eliben/pycparser
rpm_license: BSD
rpm_vendor: Eli Bendersky <eliben@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: c67dc34ff9cc49c284dd775fa65a28b4
rpm_sourcerpm: rh-python36-pycparser-2.20-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01284788-rh-python36-pycparser/rh-python36-pycparser-2.20-1.noarch.rpm
checksum_type: sha256
description:
          pycparser is a complete parser of the C language, written in
          pure Python using the PLY parsing library.
          It parses C code into an AST and can serve as a front-end for
          C compilers or analysis tools.


pkgId: b68f48ac64694997a6a8a41545b3956e86d18da14c833b1f706fd35bd77fcc74
name: rh-python36-pycurl
arch: src
version: 7.43.0.3
epoch: 0
release: 1
summary: PycURL -- A Python Interface To The cURL library
url: http://pycurl.io/
rpm_license: LGPL/MIT
rpm_vendor: Oleg Pudeyev <oleg@bsdpower.com>
rpm_group: Development/Libraries
rpm_buildhost: 77c29029128843ea9256cd143be2ab43
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00944384-rh-python36-pycurl/rh-python36-pycurl-7.43.0.3-1.src.rpm
checksum_type: sha256
description:
  PycURL -- A Python Interface To The cURL library
  ================================================

  PycURL is a Python interface to `libcurl`_, the multiprotocol file
  transfer library. Similarly to the urllib_ Python module,
  PycURL can be used to fetch objects identified by a URL from a Python program.
  Beyond simple fetches however PycURL exposes most of the functionality of
  libcurl, including:

  - Speed - libcurl is very fast and PycURL, being a thin wrapper above
    libcurl, is very fast as well. PycURL `was benchmarked`_ to be several
    times faster than requests_.
  - Features including multiple protocol support, SSL, authentication and
    proxy options. PycURL supports most of libcurl's callbacks.
  - Multi_ and share_ interfaces.
  - Sockets used for network operations, permitting integration of PycURL
    into the application's I/O loop (e.g., using Tornado_).

  .. _was benchmarked: http://stackoverflow.com/questions/15461995/python-requests-vs-pycurl-performance
  .. _requests: http://python-requests.org/
  .. _Multi: https://curl.haxx.se/libcurl/c/libcurl-multi.html
  .. _share: https://curl.haxx.se/libcurl/c/libcurl-share.html
  .. _Tornado: http://www.tornadoweb.org/


  Requirements
  ------------

  - Python 2.6, 2.7 or 3.1 through 3.6.
  - libcurl 7.19.0 or better.


  Installation
  ------------

  Download source and binary distributions from `PyPI`_ or `Bintray`_.
  Binary wheels are now available for 32 and 64 bit Windows versions.

  Please see `the installation documentation`_ for installation instructions.

  .. _PyPI: https://pypi.python.org/pypi/pycurl
  .. _Bintray: https://dl.bintray.com/pycurl/pycurl/
  .. _the installation documentation: http://pycurl.io/docs/latest/install.html


  Documentation
  -------------

  Documentation for the most recent PycURL release is available on
  `PycURL website <http://pycurl.io/docs/latest/>`_.


  Support
  -------

  For support questions please use `curl-and-python mailing list`_.
  `Mailing list archives`_ are available for your perusal as well.

  Although not an official support venue, `Stack Overflow`_ has been
  popular with some PycURL users.

  Bugs can be reported `via GitHub`_. Please use GitHub only for bug
  reports and direct questions to our mailing list instead.

  .. _curl-and-python mailing list: http://cool.haxx.se/mailman/listinfo/curl-and-python
  .. _Stack Overflow: http://stackoverflow.com/questions/tagged/pycurl
  .. _Mailing list archives: https://curl.haxx.se/mail/list.cgi?list=curl-and-python
  .. _via GitHub: https://github.com/pycurl/pycurl/issues


  License
  -------

  PycURL is dual licensed under the LGPL and an MIT/X derivative license
  based on the libcurl license. The complete text of the licenses is available
  in COPYING-LGPL_ and COPYING-MIT_ files in the source distribution.

  .. _libcurl: https://curl.haxx.se/libcurl/
  .. _urllib: http://docs.python.org/library/urllib.html
  .. _COPYING-LGPL: https://raw.githubusercontent.com/pycurl/pycurl/master/COPYING-LGPL
  .. _COPYING-MIT: https://raw.githubusercontent.com/pycurl/pycurl/master/COPYING-MIT


pkgId: c375c458f17dd7dc6d918404f399c27ba08d0bd2e76937dfb131676403065b25
name: rh-python36-pycurl-debuginfo
arch: x86_64
version: 7.43.0.3
epoch: 0
release: 1
summary: Debug information for package rh-python36-pycurl
url: http://pycurl.io/
rpm_license: LGPL/MIT
rpm_vendor: Oleg Pudeyev <oleg@bsdpower.com>
rpm_group: Development/Debug
rpm_buildhost: f2be916dee3b4e1fbbef756edbfaf55b
rpm_sourcerpm: rh-python36-pycurl-7.43.0.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00944384-rh-python36-pycurl/rh-python36-pycurl-debuginfo-7.43.0.3-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-pycurl.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1bb49f85f7f0a3950c2504c88d73a013d8fab3907b0b26972999014191f26e3a
name: rh-python36-pyfakefs
arch: noarch
version: 3.5.8
epoch: 0
release: 1
summary: pyfakefs implements a fake file system that mocks the Python file system modules.
url: http://pyfakefs.org
rpm_license: UNKNOWN
rpm_vendor: John McGehee <pyfakefs@johnnado.com>
rpm_group: Development/Libraries
rpm_buildhost: 03f9bb2a755448b39d712001acf613fa
rpm_sourcerpm: rh-python36-pyfakefs-3.5.8-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887794-rh-python36-pyfakefs/rh-python36-pyfakefs-3.5.8-1.noarch.rpm
checksum_type: sha256
description:
  pyfakefs implements a fake file system that mocks the Python file system modules.
  Using pyfakefs, your tests operate on a fake file system in memory without
  touching the real disk.  The software under test requires no modification to
  work with pyfakefs.

  pyfakefs works with Linux, Windows and MacOS.



  This file provides general usage instructions for pyfakefs.  There is more:

  * The documentation at [GitHub Pages:](http://jmcgeheeiv.github.io/pyfakefs)
    * The [Release documentation](http://jmcgeheeiv.github.io/pyfakefs/release)
      contains usage documentation for pyfakefs and a description of the
      most relevent classes, methods and functions for the last version
      released on PyPi
    * The [Development documentation](http://jmcgeheeiv.github.io/pyfakefs/master)
      contains the same documentation for the current master branch
    * The [Release 3.3 documentation](http://jmcgeheeiv.github.io/pyfakefs/release33)
      contains usage documentation for the last version of pyfakefs
      supporting Python 2.6, and for the old-style API (which is still
      supported but not documented in the current release)
  * The [Release Notes](https://github.com/jmcgeheeiv/pyfakefs/blob/master/CHANGES.md)
    show a list of changes in the latest versions



  In your own documentation, please link to pyfakefs using the canonical URL <http://pyfakefs.org>.
  This URL always points to the most relevant top page for pyfakefs.



  pyfakefs has support for `unittest` and `pytest`, but can also be used
  directly using `fake_filesystem_unittest.Patcher`. Refer to the
  [usage documentation](http://jmcgeheeiv.github.io/pyfakefs/master/usage.html)
  for more information on test scenarios, test customization and
  using convenience functions.




  pyfakefs works with CPython 2.7, 3.4 and above, on Linux, Windows and OSX
  (MacOS), and with PyPy2 and PyPy3.

  pyfakefs works with [PyTest](http://doc.pytest.org) version 2.8.6 or above.

  pyfakefs will not work with Python libraries that use C libraries to access the
  file system.  This is because pyfakefs cannot patch the underlying C libraries'
  file access functions--the C libraries will always access the real file system.
  For example, pyfakefs will not work with [`lxml`](http://lxml.de/).  In this case
  `lxml` must be replaced with a pure Python alternative such as
  [`xml.etree.ElementTree`](https://docs.python.org/3/library/xml.etree.elementtree.html).


  [pyfakefs is available on PyPi](https://pypi.python.org/pypi/pyfakefs/).





  pyfakefs is currently automatically tested:
  * [![Build Status](https://travis-ci.org/jmcgeheeiv/pyfakefs.svg)](https://travis-ci.org/jmcgeheeiv/pyfakefs)
    on Linux, with Python 2.7, and 3.4 to 3.7, using [Travis](https://travis-ci.org/jmcgeheeiv/pyfakefs)
  * [![Build Status](https://travis-ci.org/jmcgeheeiv/pyfakefs.svg)](https://travis-ci.org/jmcgeheeiv/pyfakefs)
    on MacOS, with Python 2.7, 3.6 and 3.7, using [Travis](https://travis-ci.org/jmcgeheeiv/pyfakefs)
  * [![Build status](https://ci.appveyor.com/api/projects/status/4o8j21ufuo056873/branch/master?svg=true)](https://ci.appveyor.com/project/jmcgeheeiv/pyfakefs/branch/master)
    on Windows, with Python 2.7, and 3.4 to 3.7 using [Appveyor](https://ci.appveyor.com/project/jmcgeheeiv/pyfakefs)




  pyfakefs unit tests can be run using `unittest` or `pytest`:

  ```bash
  $ cd pyfakefs/
  $ export PYTHONPATH=$PWD

  $ python -m pyfakefs.tests.all_tests
  $ python -m pyfakefs.tests.all_tests_without_extra_packages
  $ python -m pytest pyfakefs/pytest_tests/pytest_plugin_test.py
  ```

  These scripts are called by `tox` and Travis-CI. `tox` can be used to run tests
  locally against supported python versions:

  ```bash
  $ tox
  ```



  The `Dockerfile` at the top of the repository will run the tests on the latest
  Ubuntu version.  Build the container:
  ```bash
  cd pyfakefs/
  docker build -t pyfakefs .
  ```
  Run the unit tests in the container:
  ```bash
  docker run -t pyfakefs
  ```



  We always welcome contributions to the library. Check out the [Contributing
  Guide](https://github.com/jmcgeheeiv/pyfakefs/blob/master/CONTRIBUTING.md)
  for more information.


  pyfakefs.py was initially developed at Google by Mike Bland as a modest fake
  implementation of core Python modules.  It was introduced to all of Google
  in September 2006. Since then, it has been enhanced to extend its
  functionality and usefulness.  At last count, pyfakefs is used in over 2,000
  Python tests at Google.

  Google released pyfakefs to the public in 2011 as Google Code project
  [pyfakefs](http://code.google.com/p/pyfakefs/):
  * Fork
    [jmcgeheeiv-pyfakefs](http://code.google.com/p/jmcgeheeiv-pyfakefs/) added
    [direct support for unittest and doctest](../../wiki/Automatically-find-and-patch-file-functions-and-modules)
  * Fork
    [shiffdane-jmcgeheeiv-pyfakefs](http://code.google.com/p/shiffdane-jmcgeheeiv-pyfakefs/)
    added further corrections

  After the [shutdown of Google Code](http://google-opensource.blogspot.com/2015/03/farewell-to-google-code.html)
  was announced, [John McGehee](https://github.com/jmcgeheeiv) merged all three Google Code projects together
  [here on GitHub](https://github.com/jmcgeheeiv/pyfakefs) where an enthusiastic community actively supports, maintains
  and extends pyfakefs.


pkgId: f90bfa7f5cc6eb2cd032916cd8f731b757c8fb6cc228b8f08963710b2269a72d
name: rh-python36-pykerberos
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: High-level interface to Kerberos
rpm_license: ASL 2.0
rpm_vendor: UNKNOWN <UNKNOWN>
rpm_group: Development/Libraries
rpm_buildhost: 231163037c794baea8e9a86b81545753
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850827-rh-python36-pykerberos/rh-python36-pykerberos-1.2.1-1.src.rpm
checksum_type: sha256
description:
  This Python package is a high-level wrapper for Kerberos (GSSAPI) operations.
  The goal is to avoid having to build a module that wraps the entire Kerberos.framework,
  and instead offer a limited set of functions that do what is needed for client/server
  Kerberos authentication based on <http://www.ietf.org/rfc/rfc4559.txt>.


pkgId: 7e0a7d0ca6f115f05436b5d8b0031c352a795c2b7a3a22dddf9fe9774d51bb08
name: rh-python36-pykerberos-debuginfo
arch: x86_64
version: 1.2.1
epoch: 0
release: 1
summary: Debug information for package rh-python36-pykerberos
rpm_license: ASL 2.0
rpm_vendor: UNKNOWN <UNKNOWN>
rpm_group: Development/Debug
rpm_buildhost: 092f6f49b9614783ab52450b56f258b9
rpm_sourcerpm: rh-python36-pykerberos-1.2.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850827-rh-python36-pykerberos/rh-python36-pykerberos-debuginfo-1.2.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-pykerberos.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 6b5fe99b59b2cba592d577555bca737ddeda8e6d1e06385da92db6d9d5f0fc3d
name: rh-python36-pyperclip
arch: noarch
version: 1.7.0
epoch: 0
release: 1
summary: A cross-platform clipboard module for Python. (Only handles plain text for now.)
url: https://github.com/asweigart/pyperclip
rpm_license: BSD
rpm_vendor: Al Sweigart <al@inventwithpython.com>
rpm_group: Development/Libraries
rpm_buildhost: 0cb38accc98247c48cc389d9fe047e11
rpm_sourcerpm: rh-python36-pyperclip-1.7.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887951-rh-python36-pyperclip/rh-python36-pyperclip-1.7.0-1.noarch.rpm
checksum_type: sha256
description:
  Pyperclip is a cross-platform Python module for copy and paste clipboard functions. It works with Python 2 and 3.

  `pip install pyperclip`

  Al Sweigart al@inventwithpython.com
  BSD License

  Example Usage
  =============

      >>> import pyperclip
      >>> pyperclip.copy('The text to be copied to the clipboard.')
      >>> pyperclip.paste()
      'The text to be copied to the clipboard.'


  Currently only handles plaintext.

  On Windows, no additional modules are needed.

  On Mac, this module makes use of the pbcopy and pbpaste commands, which should come with the os.

  On Linux, this module makes use of the xclip or xsel commands, which should come with the os. Otherwise run "sudo apt-get install xclip" or "sudo apt-get install xsel" (Note: xsel does not always seem to work.)

  Otherwise on Linux, you will need the gtk or PyQt4 modules installed.


pkgId: 9c56cfd80291867a2065a18831d2a9846c531d02c8efb5b32e23eef71ff022d6
name: rh-python36-pyrad
arch: noarch
version: 2.3
epoch: 0
release: 1
summary: RADIUS tools
url: https://github.com/wichert/pyrad
rpm_license: BSD
rpm_vendor: Wichert Akkerman <wichert@wiggy.net>
rpm_group: Development/Libraries
rpm_buildhost: d4fb297417d5413983bd327ca4f7afb9
rpm_sourcerpm: rh-python36-pyrad-2.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01314011-rh-python36-pyrad/rh-python36-pyrad-2.3-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://travis-ci.org/wichert/pyrad.svg?branch=master
      :target: https://travis-ci.org/wichert/pyrad
  .. image:: https://img.shields.io/pypi/v/pyrad.svg
      :target: https://pypi.python.org/pypi/pyrad
  .. image:: https://img.shields.io/pypi/dm/pyrad.svg
      :target: https://pypi.python.org/pypi/pyrad

  Introduction
  ============

  pyrad is an implementation of a RADIUS client/server as described in RFC2865.
  It takes care of all the details like building RADIUS packets, sending
  them and decoding responses.

  Here is an example of doing a authentication request::

      from __future__ import print_function
      from pyrad.client import Client
      from pyrad.dictionary import Dictionary
      import pyrad.packet

      srv = Client(server="localhost", secret=b"Kah3choteereethiejeimaeziecumi",
                   dict=Dictionary("dictionary"))

      
      req = srv.CreateAuthPacket(code=pyrad.packet.AccessRequest,
                                 User_Name="wichert", NAS_Identifier="localhost")
      req["User-Password"] = req.PwCrypt("password")

      
      reply = srv.SendPacket(req)

      if reply.code == pyrad.packet.AccessAccept:
          print("access accepted")
      else:
          print("access denied")

      print("Attributes returned by server:")
      for i in reply.keys():
          print("%s: %s" % (i, reply[i]))



  Requirements & Installation
  ===========================

  pyrad requires Python 2.6 or later, or Python 3.2 or later

  Installing is simple; pyrad uses the standard distutils system for installing
  Python modules::

    python setup.py install


  Author, Copyright, Availability
  ===============================

  pyrad was written by Wichert Akkerman <wichert@wiggy.net> and is licensed
  under a BSD license.

  Copyright and license information can be found in the LICENSE.txt file.

  The current version and documentation can be found on pypi:
  http://pypi.python.org/pypi/pyrad

  Bugs and wishes can be submitted in the pyrad issue tracker on github:
  https://github.com/wichert/pyrad/issues


pkgId: d043d214b1a4b2fceb9bb7852c8919f3a6e81ba08b30e351ea52308e225b1c0e
name: rh-python36-pyrsistent
arch: src
version: 0.15.7
epoch: 0
release: 1
summary: Persistent/Functional/Immutable data structures
url: http://github.com/tobgu/pyrsistent/
rpm_license: MIT
rpm_vendor: Tobias Gustafsson <tobias.l.gustafsson@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 9558dcc1b3e14bc5ad5745d67d609da8
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311577-rh-python36-pyrsistent/rh-python36-pyrsistent-0.15.7-1.src.rpm
checksum_type: sha256
description:
  Pyrsistent
  ==========
  .. image:: https://travis-ci.org/tobgu/pyrsistent.png?branch=master
      :target: https://travis-ci.org/tobgu/pyrsistent

  .. image:: https://badge.fury.io/py/pyrsistent.svg
      :target: https://badge.fury.io/py/pyrsistent

  .. image:: https://coveralls.io/repos/tobgu/pyrsistent/badge.svg?branch=master&service=github
      :target: https://coveralls.io/github/tobgu/pyrsistent?branch=master


  .. _Pyrthon: https://www.github.com/tobgu/pyrthon/

  Pyrsistent is a number of persistent collections (by some referred to as functional data structures). Persistent in
  the sense that they are immutable.

  All methods on a data structure that would normally mutate it instead return a new copy of the structure containing the
  requested updates. The original structure is left untouched.

  This will simplify the reasoning about what a program does since no hidden side effects ever can take place to these
  data structures. You can rest assured that the object you hold a reference to will remain the same throughout its
  lifetime and need not worry that somewhere five stack levels below you in the darkest corner of your application
  someone has decided to remove that element that you expected to be there.

  Pyrsistent is influenced by persistent data structures such as those found in the standard library of Clojure. The
  data structures are designed to share common elements through path copying.
  It aims at taking these concepts and make them as pythonic as possible so that they can be easily integrated into any python
  program without hassle.

  If you want to go all in on persistent data structures and use literal syntax to define them in your code rather
  than function calls check out Pyrthon_.

  Examples
  --------
  .. _Sequence: collections_
  .. _Hashable: collections_
  .. _Mapping: collections_
  .. _Mappings: collections_
  .. _Set: collections_
  .. _collections: https://docs.python.org/3/library/collections.abc.html
  .. _documentation: http://pyrsistent.readthedocs.org/

  The collection types and key features currently implemented are:

  * PVector_, similar to a python list
  * PMap_, similar to dict
  * PSet_, similar to set
  * PRecord_, a PMap on steroids with fixed fields, optional type and invariant checking and much more
  * PClass_, a Python class fixed fields, optional type and invariant checking and much more
  * `Checked collections`_, PVector, PMap and PSet with optional type and invariance checks and more
  * PBag, similar to collections.Counter
  * PList, a classic singly linked list
  * PDeque, similar to collections.deque
  * Immutable object type (immutable) built on the named tuple
  * freeze_ and thaw_ functions to convert between pythons standard collections and pyrsistent collections.
  * Flexible transformations_ of arbitrarily complex structures built from PMaps and PVectors.

  Below are examples of common usage patterns for some of the structures and features. More information and
  full documentation for all data structures is available in the documentation_.

  .. _PVector:

  PVector
  ~~~~~~~
  With full support for the Sequence_ protocol PVector is meant as a drop in replacement to the built in list from a readers
  point of view. Write operations of course differ since no in place mutation is done but naming should be in line
  with corresponding operations on the built in list.

  Support for the Hashable_ protocol also means that it can be used as key in Mappings_.

  Appends are amortized O(1). Random access and insert is log32(n) where n is the size of the vector.

  .. code:: python

      >>> from pyrsistent import v, pvector

      
      
      >>> v1 = v(1, 2, 3)
      >>> v2 = v1.append(4)
      >>> v3 = v2.set(1, 5)
      >>> v1
      pvector([1, 2, 3])
      >>> v2
      pvector([1, 2, 3, 4])
      >>> v3
      pvector([1, 5, 3, 4])

      
      >>> v3[1]
      5
      >>> v3[1:3]
      pvector([5, 3])

      
      >>> list(x + 1 for x in v3)
      [2, 6, 4, 5]
      >>> pvector(2 * x for x in range(3))
      pvector([0, 2, 4])

  .. _PMap:

  PMap
  ~~~~
  With full support for the Mapping_ protocol PMap is meant as a drop in replacement to the built in dict from a readers point
  of view. Support for the Hashable_ protocol also means that it can be used as key in other Mappings_.

  Random access and insert is log32(n) where n is the size of the map.

  .. code:: python

      >>> from pyrsistent import m, pmap, v

      
      
      >>> m1 = m(a=1, b=2)
      >>> m2 = m1.set('c', 3)
      >>> m3 = m2.set('a', 5)
      >>> m1
      pmap({'a': 1, 'b': 2})
      >>> m2
      pmap({'a': 1, 'c': 3, 'b': 2})
      >>> m3
      pmap({'a': 5, 'c': 3, 'b': 2})
      >>> m3['a']
      5

      
      >>> m4 = m(a=5, b=6, c=v(1, 2))
      >>> m4.transform(('c', 1), 17)
      pmap({'a': 5, 'c': pvector([1, 17]), 'b': 6})
      >>> m5 = m(a=1, b=2)

      
      >>> m5.update(m(a=2, c=3), {'a': 17, 'd': 35})
      pmap({'a': 17, 'c': 3, 'b': 2, 'd': 35})
      >>> pmap({'x': 1, 'y': 2}) + pmap({'y': 3, 'z': 4})
      pmap({'y': 3, 'x': 1, 'z': 4})

      
      >>> m3.items()
      pvector([('a', 5), ('c', 3), ('b', 2)])
      >>> list(m3)
      ['a', 'c', 'b']

  .. _PSet:

  PSet
  ~~~~
  With full support for the Set_ protocol PSet is meant as a drop in replacement to the built in set from a readers point
  of view. Support for the Hashable_ protocol also means that it can be used as key in Mappings_.

  Random access and insert is log32(n) where n is the size of the set.

  .. code:: python

      >>> from pyrsistent import s

      
      >>> s1 = s(1, 2, 3, 2)
      >>> s2 = s1.add(4)
      >>> s3 = s1.remove(1)
      >>> s1
      pset([1, 2, 3])
      >>> s2
      pset([1, 2, 3, 4])
      >>> s3
      pset([2, 3])

      
      >>> s1 | s(3, 4, 5)
      pset([1, 2, 3, 4, 5])
      >>> s1 & s(3, 4, 5)
      pset([3])
      >>> s1 < s2
      True
      >>> s1 < s(3, 4, 5)
      False

  .. _PRecord:

  PRecord
  ~~~~~~~
  A PRecord is a PMap with a fixed set of specified fields. Records are declared as python classes inheriting
  from PRecord. Because it is a PMap it has full support for all Mapping methods such as iteration and element
  access using subscript notation.

  .. code:: python

      >>> from pyrsistent import PRecord, field
      >>> class ARecord(PRecord):
      ...     x = field()
      ...
      >>> r = ARecord(x=3)
      >>> r
      ARecord(x=3)
      >>> r.x
      3
      >>> r.set(x=2)
      ARecord(x=2)
      >>> r.set(y=2)
      Traceback (most recent call last):
      AttributeError: 'y' is not among the specified fields for ARecord

  Type information
  ****************
  It is possible to add type information to the record to enforce type checks. Multiple allowed types can be specified
  by providing an iterable of types.

  .. code:: python

      >>> class BRecord(PRecord):
      ...     x = field(type=int)
      ...     y = field(type=(int, type(None)))
      ...
      >>> BRecord(x=3, y=None)
      BRecord(y=None, x=3)
      >>> BRecord(x=3.0)
      Traceback (most recent call last):
      PTypeError: Invalid type for field BRecord.x, was float


  Custom types (classes) that are iterable should be wrapped in a tuple to prevent their
  members being added to the set of valid types.  Although Enums in particular are now
  supported without wrapping, see #83 for more information.

  Mandatory fields
  ****************
  Fields are not mandatory by default but can be specified as such. If fields are missing an
  *InvariantException* will be thrown which contains information about the missing fields.

  .. code:: python

      >>> from pyrsistent import InvariantException
      >>> class CRecord(PRecord):
      ...     x = field(mandatory=True)
      ...
      >>> r = CRecord(x=3)
      >>> try:
      ...    r.discard('x')
      ... except InvariantException as e:
      ...    print(e.missing_fields)
      ...
      ('CRecord.x',)

  Invariants
  **********
  It is possible to add invariants that must hold when evolving the record. Invariants can be
  specified on both field and record level. If invariants fail an *InvariantException* will be
  thrown which contains information about the failing invariants. An invariant function should
  return a tuple consisting of a boolean that tells if the invariant holds or not and an object
  describing the invariant. This object can later be used to identify which invariant that failed.

  The global invariant function is only executed if all field invariants hold.

  Global invariants are inherited to subclasses.

  .. code:: python

      >>> class RestrictedVector(PRecord):
      ...     __invariant__ = lambda r: (r.y >= r.x, 'x larger than y')
      ...     x = field(invariant=lambda x: (x > 0, 'x negative'))
      ...     y = field(invariant=lambda y: (y > 0, 'y negative'))
      ...
      >>> r = RestrictedVector(y=3, x=2)
      >>> try:
      ...    r.set(x=-1, y=-2)
      ... except InvariantException as e:
      ...    print(e.invariant_errors)
      ...
      ('y negative', 'x negative')
      >>> try:
      ...    r.set(x=2, y=1)
      ... except InvariantException as e:
      ...    print(e.invariant_errors)
      ...
      ('x larger than y',)

  Invariants may also contain multiple assertions. For those cases the invariant function should
  return a tuple of invariant tuples as described above. This structure is reflected in the
  invariant_errors attribute of the exception which will contain tuples with data from all failed
  invariants. Eg:

  .. code:: python

      >>> class EvenX(PRecord):
      ...     x = field(invariant=lambda x: ((x > 0, 'x negative'), (x % 2 == 0, 'x odd')))
      ...
      >>> try:
      ...    EvenX(x=-1)
      ... except InvariantException as e:
      ...    print(e.invariant_errors)
      ...
      (('x negative', 'x odd'),)


  Factories
  *********
  It's possible to specify factory functions for fields. The factory function receives whatever
  is supplied as field value and the actual returned by the factory is assigned to the field
  given that any type and invariant checks hold.
  PRecords have a default factory specified as a static function on the class, create(). It takes
  a *Mapping* as argument and returns an instance of the specific record.
  If a record has fields of type PRecord the create() method of that record will
  be called to create the "sub record" if no factory has explicitly been specified to override
  this behaviour.

  .. code:: python

      >>> class DRecord(PRecord):
      ...     x = field(factory=int)
      ...
      >>> class ERecord(PRecord):
      ...     d = field(type=DRecord)
      ...
      >>> ERecord.create({'d': {'x': '1'}})
      ERecord(d=DRecord(x=1))

  Collection fields
  *****************
  It is also possible to have fields with ``pyrsistent`` collections.

  .. code:: python

     >>> from pyrsistent import pset_field, pmap_field, pvector_field
     >>> class MultiRecord(PRecord):
     ...     set_of_ints = pset_field(int)
     ...     map_int_to_str = pmap_field(int, str)
     ...     vector_of_strs = pvector_field(str)
     ...

  Serialization
  *************
  PRecords support serialization back to dicts. Default serialization will take keys and values
  "as is" and output them into a dict. It is possible to specify custom serialization functions
  to take care of fields that require special treatment.

  .. code:: python

      >>> from datetime import date
      >>> class Person(PRecord):
      ...     name = field(type=unicode)
      ...     birth_date = field(type=date,
      ...                        serializer=lambda format, d: d.strftime(format['date']))
      ...
      >>> john = Person(name=u'John', birth_date=date(1985, 10, 21))
      >>> john.serialize({'date': '%Y-%m-%d'})
      {'birth_date': '1985-10-21', 'name': u'John'}


  .. _instar: https://github.com/boxed/instar/

  .. _PClass:

  PClass
  ~~~~~~
  A PClass is a python class with a fixed set of specified fields. PClasses are declared as python classes inheriting
  from PClass. It is defined the same way that PRecords are and behaves like a PRecord in all aspects except that it
  is not a PMap and hence not a collection but rather a plain Python object.

  .. code:: python

      >>> from pyrsistent import PClass, field
      >>> class AClass(PClass):
      ...     x = field()
      ...
      >>> a = AClass(x=3)
      >>> a
      AClass(x=3)
      >>> a.x
      3


  Checked collections
  ~~~~~~~~~~~~~~~~~~~
  Checked collections currently come in three flavors: CheckedPVector, CheckedPMap and CheckedPSet.

  .. code:: python

      >>> from pyrsistent import CheckedPVector, CheckedPMap, CheckedPSet, thaw
      >>> class Positives(CheckedPSet):
      ...     __type__ = (long, int)
      ...     __invariant__ = lambda n: (n >= 0, 'Negative')
      ...
      >>> class Lottery(PRecord):
      ...     name = field(type=str)
      ...     numbers = field(type=Positives, invariant=lambda p: (len(p) > 0, 'No numbers'))
      ...
      >>> class Lotteries(CheckedPVector):
      ...     __type__ = Lottery
      ...
      >>> class LotteriesByDate(CheckedPMap):
      ...     __key_type__ = date
      ...     __value_type__ = Lotteries
      ...
      >>> lotteries = LotteriesByDate.create({date(2015, 2, 15): [{'name': 'SuperLotto', 'numbers': {1, 2, 3}},
      ...                                                         {'name': 'MegaLotto',  'numbers': {4, 5, 6}}],
      ...                                     date(2015, 2, 16): [{'name': 'SuperLotto', 'numbers': {3, 2, 1}},
      ...                                                         {'name': 'MegaLotto',  'numbers': {6, 5, 4}}]})
      >>> lotteries
      LotteriesByDate({datetime.date(2015, 2, 15): Lotteries([Lottery(numbers=Positives([1, 2, 3]), name='SuperLotto'), Lottery(numbers=Positives([4, 5, 6]), name='MegaLotto')]), datetime.date(2015, 2, 16): Lotteries([Lottery(numbers=Positives([1, 2, 3]), name='SuperLotto'), Lottery(numbers=Positives([4, 5, 6]), name='MegaLotto')])})

      
      
      >>> lottery_0215 = lotteries[date(2015, 2, 15)]
      >>> lottery_0215.transform([0, 'name'], 'SuperDuperLotto')
      Lotteries([Lottery(numbers=Positives([1, 2, 3]), name='SuperDuperLotto'), Lottery(numbers=Positives([4, 5, 6]), name='MegaLotto')])

      
      >>> lottery_0215.transform([0, 'name'], 999)
      Traceback (most recent call last):
      PTypeError: Invalid type for field Lottery.name, was int

      >>> lottery_0215.transform([0, 'numbers'], set())
      Traceback (most recent call last):
      InvariantException: Field invariant failed

      
      
      >>> thaw(lottery_0215)
      [{'numbers': set([1, 2, 3]), 'name': 'SuperLotto'}, {'numbers': set([4, 5, 6]), 'name': 'MegaLotto'}]
      >>> lottery_0215.serialize()
      [{'numbers': set([1, 2, 3]), 'name': 'SuperLotto'}, {'numbers': set([4, 5, 6]), 'name': 'MegaLotto'}]

  .. _transformations:

  Transformations
  ~~~~~~~~~~~~~~~
  Transformations are inspired by the cool library instar_ for Clojure. They let you evolve PMaps and PVectors
  with arbitrarily deep/complex nesting using simple syntax and flexible matching syntax.

  The first argument to transformation is the path that points out the value to transform. The
  second is the transformation to perform. If the transformation is callable it will be applied
  to the value(s) matching the path. The path may also contain callables. In that case they are
  treated as matchers. If the matcher returns True for a specific key it is considered for transformation.

  .. code:: python

      
      >>> from pyrsistent import inc, freeze, thaw, rex, ny, discard
      >>> v1 = freeze([1, 2, 3, 4, 5])
      >>> v1.transform([2], inc)
      pvector([1, 2, 4, 4, 5])
      >>> v1.transform([lambda ix: 0 < ix < 4], 8)
      pvector([1, 8, 8, 8, 5])
      >>> v1.transform([lambda ix, v: ix == 0 or v == 5], 0)
      pvector([0, 2, 3, 4, 0])

      
      >>> v1.transform([ny], 8)
      pvector([8, 8, 8, 8, 8])

      
      >>> scores = freeze({'John': 12, 'Joseph': 34, 'Sara': 23})
      >>> scores.transform([rex('^Jo')], 0)
      pmap({'Joseph': 0, 'Sara': 23, 'John': 0})

      
      >>> news_paper = freeze({'articles': [{'author': 'Sara', 'content': 'A short article'},
      ...                                   {'author': 'Steve', 'content': 'A slightly longer article'}],
      ...                      'weather': {'temperature': '11C', 'wind': '5m/s'}})
      >>> short_news = news_paper.transform(['articles', ny, 'content'], lambda c: c[:25] + '...' if len(c) > 25 else c)
      >>> very_short_news = news_paper.transform(['articles', ny, 'content'], lambda c: c[:15] + '...' if len(c) > 15 else c)
      >>> very_short_news.articles[0].content
      'A short article'
      >>> very_short_news.articles[1].content
      'A slightly long...'

      
      >>> short_news is news_paper
      True
      >>> very_short_news is news_paper
      False
      >>> very_short_news.articles[0] is news_paper.articles[0]
      True

      
      
      >>> thaw(news_paper.transform(['weather'], discard, ['articles', ny, 'content'], discard))
      {'articles': [{'author': 'Sara'}, {'author': 'Steve'}]}

  Evolvers
  ~~~~~~~~
  PVector, PMap and PSet all have support for a concept dubbed *evolvers*. An evolver acts like a mutable
  view of the underlying persistent data structure with "transaction like" semantics. No updates of the original
  data structure is ever performed, it is still fully immutable.

  The evolvers have a very limited API by design to discourage excessive, and inappropriate, usage as that would
  take us down the mutable road. In principle only basic mutation and element access functions are supported.
  Check out the documentation_ of each data structure for specific examples.

  Examples of when you may want to use an evolver instead of working directly with the data structure include:

  * Multiple updates are done to the same data structure and the intermediate results are of no
    interest. In this case using an evolver may be a more efficient and easier to work with.
  * You need to pass a vector into a legacy function or a function that you have no control
    over which performs in place mutations. In this case pass an evolver instance
    instead and then create a new pvector from the evolver once the function returns.

  .. code:: python

      >>> from pyrsistent import v

      
      >>> v1 = v(1, 2, 3)
      >>> e = v1.evolver()
      >>> e[1] = 22
      >>> e = e.append(4)
      >>> e = e.extend([5, 6])
      >>> e[5] += 1
      >>> len(e)
      6

      
      >>> e.is_dirty()
      True

      
      >>> v1
      pvector([1, 2, 3])

      
      
      
      >>> v2 = e.persistent()
      >>> v2
      pvector([1, 22, 3, 4, 5, 7])

      
      
      >>> e.is_dirty()
      False

      
      >>> e[0] = 11

      
      
      >>> e2 = v2.evolver()
      >>> e2[0] = 1111
      >>> e.persistent()
      pvector([11, 22, 3, 4, 5, 7])
      >>> e2.persistent()
      pvector([1111, 22, 3, 4, 5, 7])

  .. _freeze:
  .. _thaw:

  freeze and thaw
  ~~~~~~~~~~~~~~~
  These functions are great when your cozy immutable world has to interact with the evil mutable world outside.

  .. code:: python

      >>> from pyrsistent import freeze, thaw, v, m
      >>> freeze([1, {'a': 3}])
      pvector([1, pmap({'a': 3})])
      >>> thaw(v(1, m(a=3)))
      [1, {'a': 3}]

  Compatibility
  -------------

  Pyrsistent is developed and tested on Python 2.7, 3.5, 3.6, 3.7 and PyPy (Python 2 and 3 compatible). It will most
  likely work on all other versions >= 3.4 but no guarantees are given. :)

  Compatibility issues
  ~~~~~~~~~~~~~~~~~~~~

  .. _27: https://github.com/tobgu/pyrsistent/issues/27

  There is currently one known compatibility issue when comparing built in sets and frozensets to PSets as discussed in 27_.
  It affects python 2 versions < 2.7.8 and python 3 versions < 3.4.0 and is due to a bug described in
  http://bugs.python.org/issue8743.

  Comparisons will fail or be incorrect when using the set/frozenset as left hand side of the comparison. As a workaround
  you need to either upgrade Python to a more recent version, avoid comparing sets/frozensets with PSets or always make
  sure to convert both sides of the comparison to the same type before performing the comparison.

  Performance
  -----------

  Pyrsistent is developed with performance in mind. Still, while some operations are nearly on par with their built in,
  mutable, counterparts in terms of speed, other operations are slower. In the cases where attempts at
  optimizations have been done, speed has generally been valued over space.

  Pyrsistent comes with two API compatible flavors of PVector (on which PMap and PSet are based), one pure Python
  implementation and one implemented as a C extension. The latter generally being 2 - 20 times faster than the former.
  The C extension will be used automatically when possible.

  The pure python implementation is fully PyPy compatible. Running it under PyPy speeds operations up considerably if
  the structures are used heavily (if JITed), for some cases the performance is almost on par with the built in counterparts.

  Type hints
  ----------

  PEP 561 style type hints for use with mypy and various editors are available for most types and functions in pyrsistent.

  Type classes for annotating your own code with pyrsistent types are also available under pyrsistent.typing.

  Installation
  ------------

  pip install pyrsistent

  Documentation
  -------------

  Available at http://pyrsistent.readthedocs.org/

  Brief presentation available at http://slides.com/tobiasgustafsson/immutability-and-python/

  Contributors
  ------------

  Tobias Gustafsson https://github.com/tobgu

  Christopher Armstrong https://github.com/radix

  Anders Hovmöller https://github.com/boxed

  Itamar Turner-Trauring https://github.com/itamarst

  Jonathan Lange https://github.com/jml

  Richard Futrell https://github.com/Futrell

  Jakob Hollenstein https://github.com/jkbjh

  David Honour https://github.com/foolswood

  David R. MacIver https://github.com/DRMacIver

  Marcus Ewert https://github.com/sarum90

  Jean-Paul Calderone https://github.com/exarkun

  Douglas Treadwell https://github.com/douglas-treadwell

  Travis Parker https://github.com/teepark

  Julian Berman https://github.com/Julian

  Dennis Tomas https://github.com/dtomas

  Neil Vyas https://github.com/neilvyas

  doozr https://github.com/doozr

  Kamil Galuszka https://github.com/galuszkak

  Tsuyoshi Hombashi https://github.com/thombashi

  nattofriends https://github.com/nattofriends

  agberk https://github.com/agberk

  Waleed Khan https://github.com/arxanas

  Jean-Louis Fuchs https://github.com/ganwell

  Carlos Corbacho https://github.com/ccorbacho

  Felix Yan https://github.com/felixonmars

  benrg https://github.com/benrg

  Jere Lahelma https://github.com/je-l

  Max Taggart https://github.com/MaxTaggart

  Vincent Philippon https://github.com/vphilippon

  Semen Zhydenko https://github.com/ss18

  Till Varoquaux  https://github.com/till-varoquaux

  Contributing
  ------------

  Want to contribute? That's great! If you experience problems please log them on GitHub. If you want to contribute code,
  please fork the repository and submit a pull request.

  Run tests
  ~~~~~~~~~
  .. _tox: https://tox.readthedocs.io/en/latest/

  Tests can be executed using tox_.

  Install tox: ``pip install tox``

  Run test for Python 2.7: ``tox -epy27``

  Release
  ~~~~~~~
  * Update CHANGES.txt
  * Update README with any new contributors and potential info needed.
  * Update _pyrsistent_version.py
  * python setup.py sdist upload
  * Commit and tag with new version: git add -u . && git commit -m 'Prepare version vX.Y.Z' && git tag -a vX.Y.Z -m 'vX.Y.Z'
  * Push commit and tags: git push && git push --tags

  Project status
  --------------
  Pyrsistent can be considered stable and mature (who knows, there may even be a 1.0 some day :-)). The project is
  maintained, bugs fixed, PRs reviewed and merged and new releases made. I currently do not have time for development
  of new features or functionality which I don't have use for myself. I'm more than happy to take PRs for new
  functionality though!

  There are a bunch of issues marked with ``enhancement`` and ``help wanted`` that contain requests for new functionality
  that would be nice to include. The level of difficulty and extend of the issues varies, please reach out to me if you're
  interested in working on any of them.

  If you feel that you have a grand master plan for where you would like Pyrsistent to go and have the time to put into
  it please don't hesitate to discuss this with me and submit PRs for it. If all goes well I'd be more than happy to add
  additional maintainers to the project!


pkgId: b0d0eb9c6ac78c76f25360cc94d5561f8bc48d645ecb362a81b7100eb37e4ed7
name: rh-python36-pyrsistent-debuginfo
arch: x86_64
version: 0.15.7
epoch: 0
release: 1
summary: Debug information for package rh-python36-pyrsistent
url: http://github.com/tobgu/pyrsistent/
rpm_license: MIT
rpm_vendor: Tobias Gustafsson <tobias.l.gustafsson@gmail.com>
rpm_group: Development/Debug
rpm_buildhost: 7ea2604bd4a24986b2a6425a433709ad
rpm_sourcerpm: rh-python36-pyrsistent-0.15.7-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311577-rh-python36-pyrsistent/rh-python36-pyrsistent-debuginfo-0.15.7-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-pyrsistent.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 940e33ae5f8b2bf4ea3113fe60e5fff0372147a74bfde8a80a93f9b618d5460b
name: rh-python36-pytest-runner
arch: noarch
version: 4.2
epoch: 0
release: 1
summary: Invoke py.test as distutils command with dependency resolution
url: https://github.com/pytest-dev/pytest-runner
rpm_license: UNKNOWN
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: 16f660d375954606bb3a57a397733e8e
rpm_sourcerpm: rh-python36-pytest-runner-4.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850468-rh-python36-pytest-runner/rh-python36-pytest-runner-4.2-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/pytest-runner.svg
     :target: https://pypi.org/project/pytest-runner

  .. image:: https://img.shields.io/pypi/pyversions/pytest-runner.svg

  .. image:: https://img.shields.io/travis/pytest-dev/pytest-runner/master.svg
     :target: https://travis-ci.org/pytest-dev/pytest-runner

  .. .. image:: https://img.shields.io/appveyor/ci/pytest-dev/pytest-runner/master.svg
  ..    :target: https://ci.appveyor.com/project/pytest-dev/pytest-runner/branch/master

  .. .. image:: https://readthedocs.org/projects/pytest-runner/badge/?version=latest
  ..    :target: https://pytest-runner.readthedocs.io/en/latest/?badge=latest

  Setup scripts can use pytest-runner to add setup.py test support for pytest
  runner.

  Usage
  =====

  - Add 'pytest-runner' to your 'setup_requires'. Pin to '>=2.0,<3dev' (or
    similar) to avoid pulling in incompatible versions.
  - Include 'pytest' and any other testing requirements to 'tests_require'.
  - Invoke tests with ``setup.py pytest``.
  - Pass ``--index-url`` to have test requirements downloaded from an alternate
    index URL (unnecessary if specified for easy_install in setup.cfg).
  - Pass additional py.test command-line options using ``--addopts``.
  - Set permanent options for the ``python setup.py pytest`` command (like ``index-url``)
    in the ``[pytest]`` section of ``setup.cfg``.
  - Set permanent options for the ``py.test`` run (like ``addopts`` or ``pep8ignore``) in the ``[pytest]``
    section of ``pytest.ini`` or ``tox.ini`` or put them in the ``[tool:pytest]``
    section of ``setup.cfg``. See `pytest issue 567
    <https://github.com/pytest-dev/pytest/issues/567>`_.
  - Optionally, set ``test=pytest`` in the ``[aliases]`` section of ``setup.cfg``
    to cause ``python setup.py test`` to invoke pytest.

  Example
  =======

  The most simple usage looks like this in setup.py::

      setup(
          setup_requires=[
              'pytest-runner',
          ],
          tests_require=[
              'pytest',
          ],
      )

  Additional dependencies require to run the tests (e.g. mock or pytest
  plugins) may be added to tests_require and will be downloaded and
  required by the session before invoking pytest.

  Follow `this search on github
  <https://github.com/search?utf8=%E2%9C%93&q=filename%3Asetup.py+pytest-runner&type=Code&ref=searchresults>`_
  for examples of real-world usage.

  Standalone Example
  ==================

  This technique is deprecated - if you have standalone scripts
  you wish to invoke with dependencies, `use rwt
  <https://pypi.org/project/rwt>`_.

  Although ``pytest-runner`` is typically used to add pytest test
  runner support to maintained packages, ``pytest-runner`` may
  also be used to create standalone tests. Consider `this example
  failure <https://gist.github.com/jaraco/d979a558bc0bf2194c23>`_,
  reported in `jsonpickle #117
  <https://github.com/jsonpickle/jsonpickle/issues/117>`_
  or `this MongoDB test
  <https://gist.github.com/jaraco/0b9e482f5c0a1300dc9a>`_
  demonstrating a technique that works even when dependencies
  are required in the test.

  Either example file may be cloned or downloaded and simply run on
  any system with Python and Setuptools. It will download the
  specified dependencies and run the tests. Afterward, the the
  cloned directory can be removed and with it all trace of
  invoking the test. No other dependencies are needed and no
  system configuration is altered.

  Then, anyone trying to replicate the failure can do so easily
  and with all the power of pytest (rewritten assertions,
  rich comparisons, interactive debugging, extensibility through
  plugins, etc).

  As a result, the communication barrier for describing and
  replicating failures is made almost trivially low.

  Considerations
  ==============

  Conditional Requirement
  -----------------------

  Because it uses Setuptools setup_requires, pytest-runner will install itself
  on every invocation of setup.py. In some cases, this causes delays for
  invocations of setup.py that will never invoke pytest-runner. To help avoid
  this contingency, consider requiring pytest-runner only when pytest
  is invoked::

      needs_pytest = {'pytest', 'test', 'ptr'}.intersection(sys.argv)
      pytest_runner = ['pytest-runner'] if needs_pytest else []

      

      setup(
          
          setup_requires=[
              
          ] + pytest_runner,
      )


pkgId: 8bbab0de9004523da27d20450722103cf67384646c18cf2b647d71b7ea804545
name: rh-python36-python-daemon
arch: noarch
version: 2.2.3
epoch: 0
release: 1
summary: Library to implement a well-behaved Unix daemon process.
url: https://pagure.io/python-daemon/
rpm_license: Apache-2
rpm_vendor: Ben Finney <ben+python@benfinney.id.au>
rpm_group: Development/Libraries
rpm_buildhost: af0eaa6dc6934f66a9576d09ce758d64
rpm_sourcerpm: rh-python36-python-daemon-2.2.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00890998-rh-python36-python-daemon/rh-python36-python-daemon-2.2.3-1.noarch.rpm
checksum_type: sha256
description:
  This library implements the well-behaved daemon specification of
  :pep:`3143`, “Standard daemon process library”.

  A well-behaved Unix daemon process is tricky to get right, but the
  required steps are much the same for every daemon program. A
  `DaemonContext` instance holds the behaviour and configured
  process environment for the program; use the instance as a context
  manager to enter a daemon state.

  Simple example of usage::

      import daemon

      from spam import do_main_program

      with daemon.DaemonContext():
          do_main_program()

  Customisation of the steps to become a daemon is available by
  setting options on the `DaemonContext` instance; see the
  documentation for that class for each option.


pkgId: 2d8b52fb201b15cfb38374ffadd0825530289a3da47d6db8eecc8e64aeb61d5c
name: rh-python36-python-dateutil
arch: noarch
version: 2.8.1
epoch: 0
release: 1
summary: Extensions to the standard Python datetime module
url: https://dateutil.readthedocs.io
rpm_license: Simplified BSD
rpm_vendor: Paul Ganssle <dateutil@python.org>
rpm_group: Development/Libraries
rpm_buildhost: 4b9e825487124594b68a9a9d3e735fea
rpm_sourcerpm: rh-python36-python-dateutil-2.8.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01085530-rh-python36-python-dateutil/rh-python36-python-dateutil-2.8.1-1.noarch.rpm
checksum_type: sha256
description:
  The dateutil module provides powerful extensions to the
  datetime module available in the Python standard library.


pkgId: a7bffdbda9a834cc24bdbbea205327548e6cb7438525c833cdc90d5b99112b29
name: rh-python36-python-django-oauth-toolkit
arch: noarch
version: 1.1.3
epoch: 0
release: 1.el7
summary: OAuth2 Provider for Django
url: https://github.com/jazzband/django-oauth-toolkit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: e54d3488c01d4d80943c1d0f2e763e5c
rpm_sourcerpm: rh-python36-python-django-oauth-toolkit-1.1.3-1.el7.src.rpm
checksum_type: sha256
location_href:
  00877381-rh-python36-python-django-oauth-toolkit/rh-python36-python-django-oauth-toolkit-1.1.3-1.el7.noarch.rpm


pkgId: 2599b331da4883ae78ecf149dd13da0a34ef9cfdd0cc3b1d29d2c0ff1f67d3a5
name: rh-python36-python-django-oauth-toolkit
arch: src
version: 1.1.3
epoch: 0
release: 1.el7
summary: OAuth2 Provider for Django
url: https://github.com/jazzband/django-oauth-toolkit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: c1ffb2dc6eca4a27bc06bc6bc3aa3cc9
checksum_type: sha256
location_href:
  00877381-rh-python36-python-django-oauth-toolkit/rh-python36-python-django-oauth-toolkit-1.1.3-1.el7.src.rpm


pkgId: 24018f5b52fa540759e018a6150645f87205a9840041319ba3eaafac56373a01
name: rh-python36-python-django-solo
arch: noarch
version: 1.1.3
epoch: 0
release: 1.el7
url: http://github.com/lazybird/django-solo/
rpm_license: Creative Commons Attribution 3.0 Unported
rpm_group: Unspecified
rpm_buildhost: 26455c72152c439595f9c09f058a77f3
rpm_sourcerpm: rh-python36-python-django-solo-1.1.3-1.el7.src.rpm
location_href: 00877383-rh-python36-python-django-solo/rh-python36-python-django-solo-1.1.3-1.el7.noarch.rpm
checksum_type: sha256
summary:
  django-solo helps working with singletons: things like global settings that you want to edit from the admin site

description:
  Django Solo ++ | | | | | \ | Django Solo helps working with singletons: | /\ |
  database tables that only have one row. | >)'> | Singletons are useful for
  things like global | \/ | settings that you want to edit from the admin | / |
  instead of having them in Django settings.py. | | | | ++--


pkgId: 99f0ef270dfaed2e8fc78467fff0ac83a9fafa129afa78c31a882c0d4b5fe204
name: rh-python36-python-editor
arch: noarch
version: 1.0.4
epoch: 0
release: 1
summary: Programmatically open an editor, capture the result.
url: https://github.com/fmoo/python-editor
rpm_license: Apache
rpm_vendor: Peter Ruibal <ruibalp@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 5d98ec99177e4e87b035a181145b1bfc
rpm_sourcerpm: rh-python36-python-editor-1.0.4-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887950-rh-python36-python-editor/rh-python36-python-editor-1.0.4-1.noarch.rpm
checksum_type: sha256
description:
  `python-editor` is a library that provides the `editor` module for programmatically
  interfacing with your system's $EDITOR.

  Examples
  --------

  ```python
  import editor
  commit_msg = editor.edit(contents=b"# Enter commit message here")
  ```

  Opens an editor, prefilled with the contents, `# Enter commit message here`.
  When the editor is closed, returns the contents (bytes) in variable `commit_msg`.
  Note that the argument to `contents` needs to be a bytes object on Python 3.


  ```python
  editor.edit(file="README.txt")
  ```

  Opens README.txt in an editor.  Changes are saved in place.  If there is
  a `contents` argument then the file contents will be overwritten.

  ```python
  editor.edit(..., use_tty=True)
  ```

  Opens the editor in a TTY.  This is usually done in programs which output is
  piped to other programs.  In this case the TTY is used as the editor's stdout,
  allowing interactive usage.


  How it Works
  ------------

  `editor` first looks for the ${EDITOR} environment variable.  If set, it uses
  the value as-is, without fallbacks.

  If no $EDITOR is set, editor will search through a list of known editors, and
  use the first one that exists on the system.

  For example, on Linux, `editor` will look for the following editors in order:

  * vim
  * emacs
  * nano

  When calling `editor.edit`, an editor will be opened in a subprocess, inheriting
  the parent process's stdin, stdout.


pkgId: 4cb1ec581bac384c0cc437ad2d5acfbc8a700ca7ed041c2cc2673e9104c8848a
name: rh-python36-python-jinja2
arch: noarch
version: 2.11.1
epoch: 0
release: 1
summary: A small but fast and easy to use stand-alone template engine written in pure python.
url: http://jinja.pocoo.org/
rpm_license: BSD
rpm_vendor: Armin Ronacher <armin.ronacher@active-4.com>
rpm_group: Development/Libraries
rpm_buildhost: 75ec56b6bcf64ecc8a773300aab1ec0c
rpm_sourcerpm: rh-python36-python-jinja2-2.11.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01212954-rh-python36-python-jinja2/rh-python36-python-jinja2-2.11.1-1.noarch.rpm
checksum_type: sha256
description:
  Jinja2
  ~~~~~~

  Jinja2 is a template engine written in pure Python.  It provides a
  `Django`_ inspired non-XML syntax but supports inline expressions and
  an optional `sandboxed`_ environment.

  Nutshell
  --------

  Here a small example of a Jinja template::

      {% extends 'base.html' %}
      {% block title %}Memberlist{% endblock %}
      {% block content %}
        <ul>
        {% for user in users %}
          <li><a href="{{ user.url }}">{{ user.username }}</a></li>
        {% endfor %}
        </ul>
      {% endblock %}

  Philosophy
  ----------

  Application logic is for the controller but don't try to make the life
  for the template designer too hard by giving him too few functionality.

  For more informations visit the new `Jinja2 webpage`_ and `documentation`_.

  .. _sandboxed: https://en.wikipedia.org/wiki/Sandbox_(computer_security)
  .. _Django: https://www.djangoproject.com/
  .. _Jinja2 webpage: http://jinja.pocoo.org/
  .. _documentation: http://jinja.pocoo.org/2/documentation/


pkgId: 2c0edb6aa4fcc72338b6a08d5f1e6c7a8d50048aa468dd98e15599512a0891b9
name: rh-python36-python-ldap
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Python modules for implementing LDAP clients
url: https://www.python-ldap.org/
rpm_license: Python style
rpm_vendor: python-ldap project
rpm_group: Development/Libraries
rpm_buildhost: 179a2eece39d4bae8970104026d1a903
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00920168-rh-python36-python-ldap/rh-python36-python-ldap-3.2.0-1.src.rpm
checksum_type: sha256
description:
  python-ldap:
    python-ldap provides an object-oriented API to access LDAP directory servers
    from Python programs. Mainly it wraps the OpenLDAP 2.x libs for that purpose.
    Additionally the package contains modules for other LDAP-related stuff
    (e.g. processing LDIF, LDAPURLs, LDAPv3 schema, LDAPv3 extended operations
    and controls, etc.).


pkgId: 3f5cd3268c04280aae7171fe8138a8d18e9435c6d2e0586184a1955b15b7c29b
name: rh-python36-python-ldap-debuginfo
arch: x86_64
version: 3.2.0
epoch: 0
release: 1
summary: Debug information for package rh-python36-python-ldap
url: https://www.python-ldap.org/
rpm_license: Python style
rpm_vendor: python-ldap project
rpm_group: Development/Debug
rpm_buildhost: 288134be68fb41ac8b800405e68ace11
rpm_sourcerpm: rh-python36-python-ldap-3.2.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00920168-rh-python36-python-ldap/rh-python36-python-ldap-debuginfo-3.2.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-python-ldap.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 4b24ba3d706c611a728d75ba12fddde204645f2538f97710c29aa30ad503b475
name: rh-python36-python-logstash
arch: noarch
version: 0.4.6
epoch: 0
release: 1
summary: Python logging handler for Logstash.
url: https://github.com/vklochan/python-logstash
rpm_license: UNKNOWN
rpm_vendor: Volodymyr Klochan <vklochan@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 59eb875caa91440d848e326d96004d86
rpm_sourcerpm: rh-python36-python-logstash-0.4.6-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850362-rh-python36-python-logstash/rh-python36-python-logstash-0.4.6-1.noarch.rpm
checksum_type: sha256
description:
  python-logstash
  ===============

  Python logging handler for Logstash.
  http://logstash.net/

  Changelog
  =========
  0.4.6
    - Updated field names to match java counterparts supported by logstash crew
  0.4.5
    - Allow passing exchange's routing key to AMQP handler
  0.4.4
    - Fixed urllib import python3 compatibility.
    - Added long type to easy_types.
  0.4.3
    - Added AMQP handler.
  0.4.2
    - Updated README
    - Added ``tags`` parameter to handler
  0.4.1
    - Added TCP handler.
  0.3.1
    - Added support for Python 3
  0.2.2
    - Split Handler into Handler and Formatter classes
  0.2.1
    - Added support for the new JSON schema in Logstash 1.2.x. See details in
      http://tobrunet.ch/2013/09/logstash-1-2-0-upgrade-notes-included/ and
      https://logstash.jira.com/browse/LOGSTASH-675

      - Added ``version`` parameter. Available values: 1 (Logstash 1.2.x version format), 0 - default (previous version).


  Installation
  ============

  Using pip::

    pip install python-logstash

  Usage
  =====

  ``LogstashHandler`` is a custom logging handler which sends Logstash messages using UDP.

  For example::

    import logging
    import logstash
    import sys

    host = 'localhost'

    test_logger = logging.getLogger('python-logstash-logger')
    test_logger.setLevel(logging.INFO)
    test_logger.addHandler(logstash.LogstashHandler(host, 5959, version=1))
    

    test_logger.error('python-logstash: test logstash error message.')
    test_logger.info('python-logstash: test logstash info message.')
    test_logger.warning('python-logstash: test logstash warning message.')

    
    extra = {
        'test_string': 'python version: ' + repr(sys.version_info),
        'test_boolean': True,
        'test_dict': {'a': 1, 'b': 'c'},
        'test_float': 1.23,
        'test_integer': 123,
        'test_list': [1, 2, '3'],
    }
    test_logger.info('python-logstash: test extra fields', extra=extra)

  When using ``extra`` field make sure you don't use reserved names. From `Python documentation <https://docs.python.org/2/library/logging.html>`_.
       | "The keys in the dictionary passed in extra should not clash with the keys used by the logging system. (See the `Formatter <https://docs.python.org/2/library/logging.html#logging.Formatter>`_ documentation for more information on which keys are used by the logging system.)"

  To use the AMQPLogstashHandler you will need to install pika first.

     pip install pika

  For example::

    import logging
    import logstash

    test_logger = logging.getLogger('python-logstash-logger')
    test_logger.setLevel(logging.INFO)
    test_logger.addHandler(logstash.AMQPLogstashHandler(host='localhost', version=1))

    test_logger.info('python-logstash: test logstash info message.')
    try:
        1/0
    except:
        test_logger.exception('python-logstash-logger: Exception with stack trace!')



  Using with Django
  =================

  Modify your ``settings.py`` to integrate ``python-logstash`` with Django's logging::

    LOGGING = {
      ...
      'handlers': {
          'logstash': {
              'level': 'DEBUG',
              'class': 'logstash.LogstashHandler',
              'host': 'localhost',
              'port': 5959, # Default value: 5959
              'version': 1, # Version of logstash event schema. Default value: 0 (for backward compatibility of the library)
              'message_type': 'logstash',  # 'type' field in logstash message. Default value: 'logstash'.
              'fqdn': False, # Fully qualified domain name. Default value: false.
              'tags': ['tag1', 'tag2'], # list of tags. Default: None.
          },
      },
      'loggers': {
          'django.request': {
              'handlers': ['logstash'],
              'level': 'DEBUG',
              'propagate': True,
          },
      },
      ...
    }

  Note
  ====

  Example Logstash Configuration (``logstash.conf``) for Receiving Events from python-logstash is::

    input {
      tcp {
        port => 5000
        codec => json
      }
    }
    output {
      stdout {
        codec => rubydebug
      }
    }


pkgId: 1379557cbde27847197e93ace75bf1ec97250e690b31f768e9bdffb34774170a
name: rh-python36-python-markupsafe
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Safely add untrusted strings to HTML/XML markup.
url: https://palletsprojects.com/p/markupsafe/
rpm_license: BSD-3-Clause
rpm_vendor: The Pallets Team <contact@palletsprojects.com>
rpm_group: Development/Libraries
rpm_buildhost: 0a7eb32d01e5472f8b19f9339b4d9895
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00891000-rh-python36-python-markupsafe/rh-python36-python-markupsafe-1.1.1-1.src.rpm
checksum_type: sha256
description:
  MarkupSafe
  ==========

  MarkupSafe implements a text object that escapes characters so it is
  safe to use in HTML and XML. Characters that have special meanings are
  replaced so that they display as the actual characters. This mitigates
  injection attacks, meaning untrusted user input can safely be displayed
  on a page.


  Installing
  ----------

  Install and update using `pip`_:

  .. code-block:: text

      pip install -U MarkupSafe

  .. _pip: https://pip.pypa.io/en/stable/quickstart/


  Examples
  --------

  .. code-block:: pycon

      >>> from markupsafe import Markup, escape
      >>> # escape replaces special characters and wraps in Markup
      >>> escape('<script>alert(document.cookie);</script>')
      Markup(u'&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
      >>> # wrap in Markup to mark text "safe" and prevent escaping
      >>> Markup('<strong>Hello</strong>')
      Markup('<strong>hello</strong>')
      >>> escape(Markup('<strong>Hello</strong>'))
      Markup('<strong>hello</strong>')
      >>> # Markup is a text subclass (str on Python 3, unicode on Python 2)
      >>> # methods and operators escape their arguments
      >>> template = Markup("Hello <em>%s</em>")
      >>> template % '"World"'
      Markup('Hello <em>&#34;World&#34;</em>')


  Donate
  ------

  The Pallets organization develops and supports MarkupSafe and other
  libraries that use it. In order to grow the community of contributors
  and users, and allow the maintainers to devote more time to the
  projects, `please donate today`_.

  .. _please donate today: https://palletsprojects.com/donate


  Links
  -----

  *   Website: https://palletsprojects.com/p/markupsafe/
  *   Documentation: https://markupsafe.palletsprojects.com/
  *   License: `BSD-3-Clause <https://github.com/pallets/markupsafe/blob/master/LICENSE.rst>`_
  *   Releases: https://pypi.org/project/MarkupSafe/
  *   Code: https://github.com/pallets/markupsafe
  *   Issue tracker: https://github.com/pallets/markupsafe/issues
  *   Test status:

      *   Linux, Mac: https://travis-ci.org/pallets/markupsafe
      *   Windows: https://ci.appveyor.com/project/pallets/markupsafe

  *   Test coverage: https://codecov.io/gh/pallets/markupsafe


pkgId: c5332e91c466fd6110e8f443fb955698eae8ff0208f0d18c3fe84fe68232c0d7
name: rh-python36-python-markupsafe-debuginfo
arch: x86_64
version: 1.1.1
epoch: 0
release: 1
summary: Debug information for package rh-python36-python-markupsafe
url: https://palletsprojects.com/p/markupsafe/
rpm_license: BSD-3-Clause
rpm_vendor: The Pallets Team <contact@palletsprojects.com>
rpm_group: Development/Debug
rpm_buildhost: a5f585da85584f3c97a7c61af4cc6f27
rpm_sourcerpm: rh-python36-python-markupsafe-1.1.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00891000-rh-python36-python-markupsafe/rh-python36-python-markupsafe-debuginfo-1.1.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-python-markupsafe.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 9f7e4acaa7aee062761cd153565ab922a822f6484eb7e024dd8977715f9cca92
name: rh-python36-python-memcached
arch: noarch
version: 1.59
epoch: 0
release: 1
summary: Pure python memcached client
url: https://github.com/linsomniac/python-memcached
rpm_license: UNKNOWN
rpm_vendor: Sean Reifschneider <jafo@tummy.com>
rpm_group: Development/Libraries
rpm_buildhost: d5ddf74a78e545c389bb88c3cdfebffa
rpm_sourcerpm: rh-python36-python-memcached-1.59-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850363-rh-python36-python-memcached/rh-python36-python-memcached-1.59-1.noarch.rpm
checksum_type: sha256
description:
  [![Build
  Status](https://travis-ci.org/linsomniac/python-memcached.svg)](https://travis-ci.org/linsomniac/python-memcached)



  This software is a 100% Python interface to the memcached memory cache
  daemon.  It is the client side software which allows storing values
  in one or more, possibly remote, memcached servers.  Search google for
  memcached for more information.

  This package was originally written by Evan Martin of Danga.  Please do
  not contact Evan about maintenance.  Sean Reifschneider of tummy.com,
  ltd. has taken over maintenance of it.

  Please report issues and submit code changes to the github repository at:

     https://github.com/linsomniac/python-memcached

  For changes prior to 2013-03-26, see the old Launchpad repository at:

     Historic issues: https://launchpad.net/python-memcached



  Test patches locally and easily by running tox:

      pip install tox
      tox -e py27

  Test for style by running tox:

      tox -e pep8


pkgId: 71558e0418a51c06e93a5261d6bbf918c839b759d6e3de75fc28801b1c5b1505
name: rh-python36-python-mimeparse
arch: noarch
version: 1.6.0
epoch: 0
release: 1
url: https://github.com/dbtsai/python-mimeparse
rpm_license: UNKNOWN
rpm_vendor: DB Tsai <dbtsai@dbtsai.com>
rpm_group: Development/Libraries
rpm_buildhost: 035f5cd03b88447b8b1625a854393e34
rpm_sourcerpm: rh-python36-python-mimeparse-1.6.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887968-rh-python36-python-mimeparse/rh-python36-python-mimeparse-1.6.0-1.noarch.rpm
checksum_type: sha256
summary:
  A module provides basic functions for parsing mime-type names and matching them against a list of media-ranges.

description:
  Python-MimeParse
  ================

  .. image:: https://travis-ci.org/dbtsai/python-mimeparse.svg?branch=master
     :target: https://travis-ci.org/dbtsai/python-mimeparse

  This module provides basic functions for handling mime-types. It can
  handle matching mime-types against a list of media-ranges. See section
  5.3.2 of the HTTP 1.1 Semantics and Content specification [RFC 7231] for
  a complete explanation: https://tools.ietf.org/html/rfc7231#section-5.3.2

  Installation
  ------------

  Use **pip**:

  .. code-block:: sh

      $ pip install python-mimeparse

  It supports Python 2.7 - 3.5 and PyPy.

  Functions
  ---------

  **parse_mime_type()**

  Parses a mime-type into its component parts.

  **parse_media_range()**

  Media-ranges are mime-types with wild-cards and a "q" quality parameter.

  **quality()**

  Determines the quality ("q") of a mime-type when compared against a list of
  media-ranges.

  **quality_parsed()**

  Just like ``quality()`` except the second parameter must be pre-parsed.

  **best_match()**

  Choose the mime-type with the highest quality ("q") from a list of candidates.

  Testing
  -------

  Run the tests by typing: ``python mimeparse_test.py``. The tests require Python 2.6.

  To make sure that the package works in all the supported environments, you can
  run **tox** tests:

  .. code-block:: sh

      $ pip install tox
      $ tox

  The format of the JSON test data file is as follows: A top-level JSON object
  which has a key for each of the functions to be tested. The value corresponding
  to that key is a list of tests. Each test contains: the argument or arguments
  to the function being tested, the expected results and an optional description.


pkgId: db81425c20fef28326f554c33af0177040414221abadec8c5eaec34249c0bacd
name: rh-python36-python-ordereddict
arch: noarch
version: 1.1
epoch: 0
release: 1.el7
summary: A drop-in substitute for Py2.7's new collections.OrderedDict that works in Python 2.4-2.6.
url: None
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: 6972dd750c82417183e8d3bfe0ddda5a
rpm_sourcerpm: rh-python36-python-ordereddict-1.1-1.el7.src.rpm
location_href: 00850364-rh-python36-python-ordereddict/rh-python36-python-ordereddict-1.1-1.el7.noarch.rpm
checksum_type: sha256
description:
  Drop-in substitute for Py2.7's new collections.OrderedDict. The recipe has big-
  oh
  performance that matches regular dictionaries (amortized O(1)
  insertion/deletion/lookup and O(n) iteration/repr/copy/equality_testing).
  Originally based on http://code.activestate.com/recipes/576693/


pkgId: a8c144fd767da5cdbea1c34667a066f55ea6d0363f658ce40bf5d9efb210b097
name: rh-python36-python-pygments
arch: noarch
version: 2.5.2
epoch: 0
release: 1
summary: Pygments is a syntax highlighting package written in Python.
url: http://pygments.org/
rpm_license: BSD License
rpm_vendor: Georg Brandl <georg@python.org>
rpm_group: Development/Libraries
rpm_buildhost: eec316a901f54f85ad548d2270943dec
rpm_sourcerpm: rh-python36-python-pygments-2.5.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143883-rh-python36-python-pygments/rh-python36-python-pygments-2.5.2-1.noarch.rpm
checksum_type: sha256
description:
  Pygments
      ~~~~~~~~

      Pygments is a syntax highlighting package written in Python.

      It is a generic syntax highlighter suitable for use in code hosting, forums,
      wikis or other applications that need to prettify source code.  Highlights
      are:

      * a wide range of over 300 languages and other text formats is supported
      * special attention is paid to details, increasing quality by a fair amount
      * support for new languages and formats are added easily
      * a number of output formats, presently HTML, LaTeX, RTF, SVG, all image       formats that PIL supports and ANSI sequences
      * it is usable as a command-line tool and as a library

      :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
      :license: BSD, see LICENSE for details.


pkgId: 9a4bdf793530e7065fed65d5673e4680097e9fa3d47a5a7a02d986239d1eb9dd
name: rh-python36-python-string-utils
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Utility functions for strings checking and manipulation.
url: https://github.com/daveoncode/python-string-utils
rpm_license: MIT
rpm_vendor: Davide Zanotti <davidezanotti@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 91df12f022b546188b57a20ed76ffc27
rpm_sourcerpm: rh-python36-python-string-utils-0.6.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01048859-rh-python36-python-string-utils/rh-python36-python-string-utils-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  A small utility library to check and manipulate strings.

  - simple and pythonic
  - fast (based on compiled regex)
  - no external dependencies
  - fully documented
  - PEP8 complaint
  - 100% code coverage
  - tested against multiple python versions (2.7, 3.2, 3.3, 3.4, 3.5)






  - is_string
  - is_full_string
  - is_ip
  - is_url
  - is_email
  - is_credit_card
  - is_camel_case
  - is_snake_case
  - is_json
  - is_uuid
  - is_pangram
  - is_palindrome
  - is_isogram
  - is_slug
  - words_count
  - contains_html



  - camel_case_to_snake
  - snake_case_to_camel
  - reverse
  - uuid
  - shuffle
  - strip_html
  - prettify
  - slugify


  ...and more are coming!




      pip install python-string-utils




  Full API documentation available on: <http://python-string-utils.readthedocs.org/en/latest/>


pkgId: ce7ac1e6d9fd7126212f3ebf4a7c43148533f09250df6de95cd1a90ba9479dc4
name: rh-python36-python-subunit
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Python implementation of subunit test streaming protocol
url: http://launchpad.net/subunit
rpm_license: UNKNOWN
rpm_vendor: Robert Collins <subunit-dev@lists.launchpad.net>
rpm_group: Development/Libraries
rpm_buildhost: 3b61dfa1844a45929d0101173bdf4188
rpm_sourcerpm: rh-python36-python-subunit-1.3.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887791-rh-python36-python-subunit/rh-python36-python-subunit-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
    subunit: A streaming protocol for test results
    Copyright (C) 2005-2013 Robert Collins <robertc@robertcollins.net>

    Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
    license at the users choice. A copy of both licenses are available in the
    project source as Apache-2.0 and BSD. You may not use this file except in
    compliance with one of these two licences.

    Unless required by applicable law or agreed to in writing, software
    distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
    license you chose for the specific language governing permissions and
    limitations under that license.

    See the COPYING file for full details on the licensing of Subunit.

    subunit reuses iso8601 by Michael Twomey, distributed under an MIT style
    licence - see python/iso8601/LICENSE for details.

  Subunit
  -------

  Subunit is a streaming protocol for test results.

  There are two major revisions of the protocol. Version 1 was trivially human
  readable but had significant defects as far as highly parallel testing was
  concerned - it had no room for doing discovery and execution in parallel,
  required substantial buffering when multiplexing and was fragile - a corrupt
  byte could cause an entire stream to be misparsed. Version 1.1 added
  encapsulation of binary streams which mitigated some of the issues but the
  core remained.

  Version 2 shares many of the good characteristics of Version 1 - it can be
  embedded into a regular text stream (e.g. from a build system) and it still
  models xUnit style test execution. It also fixes many of the issues with
  Version 1 - Version 2 can be multiplexed without excessive buffering (in
  time or space), it has a well defined recovery mechanism for dealing with
  corrupted streams (e.g. where two processes write to the same stream
  concurrently, or where the stream generator suffers a bug).

  More details on both protocol version s can be found in the 'Protocol' section
  of this document.

  Subunit comes with command line filters to process a subunit stream and
  language bindings for python, C, C++ and shell. Bindings are easy to write
  for other languages.

  A number of useful things can be done easily with subunit:
   * Test aggregation: Tests run separately can be combined and then
     reported/displayed together. For instance, tests from different languages
     can be shown as a seamless whole, and tests running on multiple machines
     can be aggregated into a single stream through a multiplexer.
   * Test archiving: A test run may be recorded and replayed later.
   * Test isolation: Tests that may crash or otherwise interact badly with each
     other can be run seperately and then aggregated, rather than interfering
     with each other or requiring an adhoc test->runner reporting protocol.
   * Grid testing: subunit can act as the necessary serialisation and
     deserialiation to get test runs on distributed machines to be reported in
     real time.

  Subunit supplies the following filters:
   * tap2subunit - convert perl's TestAnythingProtocol to subunit.
   * subunit2csv - convert a subunit stream to csv.
   * subunit2disk - export a subunit stream to files on disk.
   * subunit2pyunit - convert a subunit stream to pyunit test results.
   * subunit2gtk - show a subunit stream in GTK.
   * subunit2junitxml - convert a subunit stream to JUnit's XML format.
   * subunit-diff - compare two subunit streams.
   * subunit-filter - filter out tests from a subunit stream.
   * subunit-ls - list info about tests present in a subunit stream.
   * subunit-stats - generate a summary of a subunit stream.
   * subunit-tags - add or remove tags from a stream.

  Integration with other tools
  ----------------------------

  Subunit's language bindings act as integration with various test runners like
  'check', 'cppunit', Python's 'unittest'. Beyond that a small amount of glue
  (typically a few lines) will allow Subunit to be used in more sophisticated
  ways.

  Python
  ======

  Subunit has excellent Python support: most of the filters and tools are written
  in python and there are facilities for using Subunit to increase test isolation
  seamlessly within a test suite.

  The most common way is to run an existing python test suite and have it output
  subunit via the ``subunit.run`` module::

    $ python -m subunit.run mypackage.tests.test_suite

  For more information on the Python support Subunit offers , please see
  ``pydoc subunit``, or the source in ``python/subunit/``

  C
  =

  Subunit has C bindings to emit the protocol. The 'check' C unit testing project
  has included subunit support in their project for some years now. See
  'c/README' for more details.

  C++
  ===

  The C library is includable and usable directly from C++. A TestListener for
  CPPUnit is included in the Subunit distribution. See 'c++/README' for details.

  shell
  =====

  There are two sets of shell tools. There are filters, which accept a subunit
  stream on stdin and output processed data (or a transformed stream) on stdout.

  Then there are unittest facilities similar to those for C : shell bindings
  consisting of simple functions to output protocol elements, and a patch for
  adding subunit output to the 'ShUnit' shell test runner. See 'shell/README' for
  details.

  Filter recipes
  --------------

  To ignore some failing tests whose root cause is already known::

    subunit-filter --without 'AttributeError.*flavor'


  The xUnit test model
  --------------------

  Subunit implements a slightly modified xUnit test model. The stock standard
  model is that there are tests, which have an id(), can be run, and when run
  start, emit an outcome (like success or failure) and then finish.

  Subunit extends this with the idea of test enumeration (find out about tests
  a runner has without running them), tags (allow users to describe tests in
  ways the test framework doesn't apply any semantic value to), file attachments
  (allow arbitrary data to make analysing a failure easy) and timestamps.

  The protocol
  ------------

  Version 2, or v2 is new and still under development, but is intended to
  supercede version 1 in the very near future. Subunit's bundled tools accept
  only version 2 and only emit version 2, but the new filters subunit-1to2 and
  subunit-2to1 can be used to interoperate with older third party libraries.

  Version 2
  =========

  Version 2 is a binary protocol consisting of independent packets that can be
  embedded in the output from tools like make - as long as each packet has no
  other bytes mixed in with it (which 'make -j N>1' has a tendency of doing).
  Version 2 is currently in draft form, and early adopters should be willing
  to either discard stored results (if protocol changes are made), or bulk
  convert them back to v1 and then to a newer edition of v2.

  The protocol synchronises at the start of the stream, after a packet, or
  after any 0x0A byte. That is, a subunit v2 packet starts after a newline or
  directly after the end of the prior packet.

  Subunit is intended to be transported over a reliable streaming protocol such
  as TCP. As such it does not concern itself with out of order delivery of
  packets. However, because of the possibility of corruption due to either
  bugs in the sender, or due to mixed up data from concurrent writes to the same
  fd when being embedded, subunit strives to recover reasonably gracefully from
  damaged data.

  A key design goal for Subunit version 2 is to allow processing and multiplexing
  without forcing buffering for semantic correctness, as buffering tends to hide
  hung or otherwise misbehaving tests. That said, limited time based buffering
  for network efficiency is a good idea - this is ultimately implementator
  choice. Line buffering is also discouraged for subunit streams, as dropping
  into a debugger or other tool may require interactive traffic even if line
  buffering would not otherwise be a problem.

  In version two there are two conceptual events - a test status event and a file
  attachment event. Events may have timestamps, and the path of multiplexers that
  an event is routed through is recorded to permit sending actions back to the
  source (such as new tests to run or stdin for driving debuggers and other
  interactive input). Test status events are used to enumerate tests, to report
  tests and test helpers as they run. Tests may have tags, used to allow
  tunnelling extra meanings through subunit without requiring parsing of
  arbitrary file attachments. Things that are not standalone tests get marked
  as such by setting the 'Runnable' flag to false. (For instance, individual
  assertions in TAP are not runnable tests, only the top level TAP test script
  is runnable).

  File attachments are used to provide rich detail about the nature of a failure.
  File attachments can also be used to encapsulate stdout and stderr both during
  and outside tests.

  Most numbers are stored in network byte order - Most Significant Byte first
  encoded using a variation of http://www.dlugosz.com/ZIP2/VLI.html. The first
  byte's top 2 high order bits encode the total number of octets in the number.
  This encoding can encode values from 0 to 2**30-1, enough to encode a
  nanosecond. Numbers that are not variable length encoded are still stored in
  MSB order.

  +--------+--------+---------+------------+
  | prefix | octets | max     | max        |
  +========+========+=========+============+
  | 00     |      1 |  2**6-1 |         63 |
  +--------+--------+---------+------------+
  | 01     |      2 | 2**14-1 |      16383 |
  +--------+--------+---------+------------+
  | 10     |      3 | 2**22-1 |    4194303 |
  +--------+--------+---------+------------+
  | 11     |      4 | 2**30-1 | 1073741823 |
  +--------+--------+---------+------------+

  All variable length elements of the packet are stored with a length prefix
  number allowing them to be skipped over for consumers that don't need to
  interpret them.

  UTF-8 strings are with no terminating NUL and should not have any embedded NULs
  (implementations SHOULD validate any such strings that they process and take
  some remedial action (such as discarding the packet as corrupt).

  In short the structure of a packet is:

    PACKET := SIGNATURE FLAGS PACKET_LENGTH TIMESTAMP? TESTID? TAGS? MIME?
              FILECONTENT? ROUTING_CODE? CRC32

  In more detail...

  Packets are identified by a single byte signature - 0xB3, which is never legal
  in a UTF-8 stream as the first byte of a character. 0xB3 starts with the first
  bit set and the second not, which is the UTF-8 signature for a continuation
  byte. 0xB3 was chosen as 0x73 ('s' in ASCII') with the top two bits replaced by
  the 1 and 0 for a continuation byte.

  If subunit packets are being embedded in a non-UTF-8 text stream, where 0x73 is
  a legal character, consider either recoding the text to UTF-8, or using
  subunit's 'file' packets to embed the text stream in subunit, rather than the
  other way around.

  Following the signature byte comes a 16-bit flags field, which includes a
  4-bit version field - if the version is not 0x2 then the packet cannot be
  read. It is recommended to signal an error at this point (e.g. by emitting
  a synthetic error packet and returning to the top level loop to look for
  new packets, or exiting with an error). If recovery is desired, treat the
  packet signature as an opaque byte and scan for a new synchronisation point.
  NB: Subunit V1 and V2 packets may legitimately included 0xB3 internally,
  as they are an 8-bit safe container format, so recovery from this situation
  may involve an arbitrary number of false positives until an actual packet
  is encountered : and even then it may still be false, failing after passing
  the version check due to coincidence.

  Flags are stored in network byte order too.

  +------------+------------+------------------------+
  | High byte               | Low byte               |
  +------------+------------+------------------------+
  | 15 14 13 12 11 10  9  8 | 7  6  5  4  3  2  1  0 |
  +------------+------------+------------------------+
  | VERSION    |      feature bits                   |
  +------------+-------------------------------------+

  Valid version values are:
  0x2 - version 2

  Feature bits:
  Bit 11 - mask 0x0800 - Test id present.
  Bit 10 - mask 0x0400 - Routing code present.
  Bit  9 - mask 0x0200 - Timestamp present.
  Bit  8 - mask 0x0100 - Test is 'runnable'.
  Bit  7 - mask 0x0080 - Tags are present.
  Bit  6 - mask 0x0040 - File content is present.
  Bit  5 - mask 0x0020 - File MIME type is present.
  Bit  4 - mask 0x0010 - EOF marker.
  Bit  3 - mask 0x0008 - Must be zero in version 2.

  Test status gets three bits:
  Bit 2 | Bit 1 | Bit 0 - mask 0x0007 - A test status enum lookup:
  000 - undefined / no test
  001 - Enumeration / existence
  002 - In progress
  003 - Success
  004 - Unexpected Success
  005 - Skipped
  006 - Failed
  007 - Expected failure

  After the flags field is a number field giving the length in bytes for the
  entire packet including the signature and the checksum. This length must
  be less than 4MiB - 4194303 bytes. The encoding can obviously record a larger
  number but one of the goals is to avoid requiring large buffers, or causing
  large latency in the packet forward/processing pipeline. Larger file
  attachments can be communicated in multiple packets, and the overhead in such a
  4MiB packet is approximately 0.2%.

  The rest of the packet is a series of optional features as specified by the set
  feature bits in the flags field. When absent they are entirely absent.

  Forwarding and multiplexing of packets can be done without interpreting the
  remainder of the packet until the routing code and checksum (which are both at
  the end of the packet). Additionally, routers can often avoid copying or moving
  the bulk of the packet, as long as the routing code size increase doesn't force
  the length encoding to take up a new byte (which will only happen to packets
  less than or equal to 16KiB in length) - large packets are very efficient to
  route.

  Timestamp when present is a 32 bit unsigned integer for seconds, and a variable
  length number for nanoseconds, representing UTC time since Unix Epoch in
  seconds and nanoseconds.

  Test id when present is a UTF-8 string. The test id should uniquely identify
  runnable tests such that they can be selected individually. For tests and other
  actions which cannot be individually run (such as test
  fixtures/layers/subtests) uniqueness is not required (though being human
  meaningful is highly recommended).

  Tags when present is a length prefixed vector of UTF-8 strings, one per tag.
  There are no restrictions on tag content (other than the restrictions on UTF-8
  strings in subunit in general). Tags have no ordering.

  When a MIME type is present, it defines the MIME type for the file across all
  packets same file (routing code + testid + name uniquely identifies a file,
  reset when EOF is flagged). If a file never has a MIME type set, it should be
  treated as application/octet-stream.

  File content when present is a UTF-8 string for the name followed by the length
  in bytes of the content, and then the content octets.

  If present routing code is a UTF-8 string. The routing code is used to
  determine which test backend a test was running on when doing data analysis,
  and to route stdin to the test process if interaction is required.

  Multiplexers SHOULD add a routing code if none is present, and prefix any
  existing routing code with a routing code ('/' separated) if one is already
  present. For example, a multiplexer might label each stream it is multiplexing
  with a simple ordinal ('0', '1' etc), and given an incoming packet with route
  code '3' from stream '0' would adjust the route code when forwarding the packet
  to be '0/3'.

  Following the end of the packet is a CRC-32 checksum of the contents of the
  packet including the signature.

  Example packets
  ~~~~~~~~~~~~~~~

  Trivial test "foo" enumeration packet, with test id, runnable set,
  status=enumeration. Spaces below are to visually break up signature / flags /
  length / testid / crc32

  b3 2901 0c 03666f6f 08555f1b


  Version 1 (and 1.1)
  ===================

  Version 1 (and 1.1) are mostly human readable protocols.

  Sample subunit wire contents
  ----------------------------

  The following::

    test: test foo works
    success: test foo works
    test: tar a file.
    failure: tar a file. [
    ..
     ]..  space is eaten.
    foo.c:34 WARNING foo is not defined.
    ]
    a writeln to stdout

  When run through subunit2pyunit::

    .F
    a writeln to stdout

    ========================
    FAILURE: tar a file.
    -------------------
    ..
    ]..  space is eaten.
    foo.c:34 WARNING foo is not defined.


  Subunit v1 protocol description
  ===============================

  This description is being ported to an EBNF style. Currently its only partly in
  that style, but should be fairly clear all the same. When in doubt, refer the
  source (and ideally help fix up the description!). Generally the protocol is
  line orientated and consists of either directives and their parameters, or
  when outside a DETAILS region unexpected lines which are not interpreted by
  the parser - they should be forwarded unaltered::

      test|testing|test:|testing: test LABEL
      success|success:|successful|successful: test LABEL
      success|success:|successful|successful: test LABEL DETAILS
      failure: test LABEL
      failure: test LABEL DETAILS
      error: test LABEL
      error: test LABEL DETAILS
      skip[:] test LABEL
      skip[:] test LABEL DETAILS
      xfail[:] test LABEL
      xfail[:] test LABEL DETAILS
      uxsuccess[:] test LABEL
      uxsuccess[:] test LABEL DETAILS
      progress: [+|-]X
      progress: push
      progress: pop
      tags: [-]TAG ...
      time: YYYY-MM-DD HH:MM:SSZ

      LABEL: UTF8*
      NAME: UTF8*
      DETAILS ::= BRACKETED | MULTIPART
      BRACKETED ::= '[' CR UTF8-lines ']' CR
      MULTIPART ::= '[ multipart' CR PART* ']' CR
      PART ::= PART_TYPE CR NAME CR PART_BYTES CR
      PART_TYPE ::= Content-Type: type/sub-type(;parameter=value,parameter=value)
      PART_BYTES ::= (DIGITS CR LF BYTE{DIGITS})* '0' CR LF

  unexpected output on stdout -> stdout.
  exit w/0 or last test completing -> error

  Tags given outside a test are applied to all following tests
  Tags given after a test: line and before the result line for the same test
  apply only to that test, and inherit the current global tags.
  A '-' before a tag is used to remove tags - e.g. to prevent a global tag
  applying to a single test, or to cancel a global tag.

  The progress directive is used to provide progress information about a stream
  so that stream consumer can provide completion estimates, progress bars and so
  on. Stream generators that know how many tests will be present in the stream
  should output "progress: COUNT". Stream filters that add tests should output
  "progress: +COUNT", and those that remove tests should output
  "progress: -COUNT". An absolute count should reset the progress indicators in
  use - it indicates that two separate streams from different generators have
  been trivially concatenated together, and there is no knowledge of how many
  more complete streams are incoming. Smart concatenation could scan each stream
  for their count and sum them, or alternatively translate absolute counts into
  relative counts inline. It is recommended that outputters avoid absolute counts
  unless necessary. The push and pop directives are used to provide local regions
  for progress reporting. This fits with hierarchically operating test
  environments - such as those that organise tests into suites - the top-most
  runner can report on the number of suites, and each suite surround its output
  with a (push, pop) pair. Interpreters should interpret a pop as also advancing
  the progress of the restored level by one step. Encountering progress
  directives between the start and end of a test pair indicates that a previous
  test was interrupted and did not cleanly terminate: it should be implicitly
  closed with an error (the same as when a stream ends with no closing test
  directive for the most recently started test).

  The time directive acts as a clock event - it sets the time for all future
  events. The value should be a valid ISO8601 time.

  The skip, xfail and uxsuccess outcomes are not supported by all testing
  environments. In Python the testttools (https://launchpad.net/testtools)
  library is used to translate these automatically if an older Python version
  that does not support them is in use. See the testtools documentation for the
  translation policy.

  skip is used to indicate a test was discovered but not executed. xfail is used
  to indicate a test that errored in some expected fashion (also know as "TODO"
  tests in some frameworks). uxsuccess is used to indicate and unexpected success
  where a test though to be failing actually passes. It is complementary to
  xfail.

  Hacking on subunit
  ------------------

  Releases
  ========

  * Update versions in configure.ac and python/subunit/__init__.py.
  * Update NEWS.
  * Do a make distcheck, which will update Makefile etc.
  * Do a PyPI release: PYTHONPATH=../../python python ../../setup.py sdist bdist_wheel upload -s
  * Upload the regular one to LP.
  * Push a tagged commit.
    git push -t origin master:master


pkgId: b7514041bb4dff7f87f9f0cf4d25148253c8dc9cd23d79123f10cead0c286707
name: rh-python36-python3-openid
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: OpenID support for modern servers and consumers.
url: http://github.com/necaris/python3-openid
rpm_license: UNKNOWN
rpm_vendor: Rami Chowdhury <rami.chowdhury@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 55e2f283345140799166c71efd0fe475
rpm_sourcerpm: rh-python36-python3-openid-3.1.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850350-rh-python36-python3-openid/rh-python36-python3-openid-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a set of Python packages to support use of
  the OpenID decentralized identity system in your application, update to Python
  3.  Want to enable single sign-on for your web site?  Use the openid.consumer
  package.  Want to run your own OpenID server? Check out openid.server.
  Includes example code and support for a variety of storage back-ends.


pkgId: 1fb28387ea1f9fb072fa809a13aad82ec9ee2df28c7b957f86c8d283f8423891
name: rh-python36-pytz
arch: noarch
version: 2019.3
epoch: 0
release: 1
summary: World timezone definitions, modern and historical
url: http://pythonhosted.org/pytz
rpm_license: MIT
rpm_vendor: Stuart Bishop <stuart@stuartbishop.net>
rpm_group: Development/Libraries
rpm_buildhost: 9f0754eb8b0e49cbbcb8fc0ed0ca5c4c
rpm_sourcerpm: rh-python36-pytz-2019.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01087347-rh-python36-pytz/rh-python36-pytz-2019.3-1.noarch.rpm
checksum_type: sha256
description:
  pytz - World Timezone Definitions for Python
  ============================================

  :Author: Stuart Bishop <stuart@stuartbishop.net>

  Introduction
  ~~~~~~~~~~~~

  pytz brings the Olson tz database into Python. This library allows
  accurate and cross platform timezone calculations using Python 2.4
  or higher. It also solves the issue of ambiguous times at the end
  of daylight saving time, which you can read more about in the Python
  Library Reference (``datetime.tzinfo``).

  Almost all of the Olson timezones are supported.

  .. note::

      This library differs from the documented Python API for
      tzinfo implementations; if you want to create local wallclock
      times you need to use the ``localize()`` method documented in this
      document. In addition, if you perform date arithmetic on local
      times that cross DST boundaries, the result may be in an incorrect
      timezone (ie. subtract 1 minute from 2002-10-27 1:00 EST and you get
      2002-10-27 0:59 EST instead of the correct 2002-10-27 1:59 EDT). A
      ``normalize()`` method is provided to correct this. Unfortunately these
      issues cannot be resolved without modifying the Python datetime
      implementation (see PEP-431).


  Installation
  ~~~~~~~~~~~~

  This package can either be installed from a .egg file using setuptools,
  or from the tarball using the standard Python distutils.

  If you are installing from a tarball, run the following command as an
  administrative user::

      python setup.py install

  If you are installing using setuptools, you don't even need to download
  anything as the latest version will be downloaded for you
  from the Python package index::

      easy_install --upgrade pytz

  If you already have the .egg file, you can use that too::

      easy_install pytz-2008g-py2.6.egg


  Example & Usage
  ~~~~~~~~~~~~~~~

  Localized times and date arithmetic
  -----------------------------------

  >>> from datetime import datetime, timedelta
  >>> from pytz import timezone
  >>> import pytz
  >>> utc = pytz.utc
  >>> utc.zone
  'UTC'
  >>> eastern = timezone('US/Eastern')
  >>> eastern.zone
  'US/Eastern'
  >>> amsterdam = timezone('Europe/Amsterdam')
  >>> fmt = '%Y-%m-%d %H:%M:%SOURCE %Z%z'

  This library only supports two ways of building a localized time. The
  first is to use the ``localize()`` method provided by the pytz library.
  This is used to localize a naive datetime (datetime with no timezone
  information):

  >>> loc_dt = eastern.localize(datetime(2002, 10, 27, 6, 0, 0))
  >>> print(loc_dt.strftime(fmt))
  2002-10-27 06:00:00 EST-0500

  The second way of building a localized time is by converting an existing
  localized time using the standard ``astimezone()`` method:

  >>> ams_dt = loc_dt.astimezone(amsterdam)
  >>> ams_dt.strftime(fmt)
  '2002-10-27 12:00:00 CET+0100'

  Unfortunately using the tzinfo argument of the standard datetime
  constructors ''does not work'' with pytz for many timezones.

  >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=amsterdam).strftime(fmt)
  '2002-10-27 12:00:00 LMT+0020'

  It is safe for timezones without daylight saving transitions though, such
  as UTC:

  >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=pytz.utc).strftime(fmt)
  '2002-10-27 12:00:00 UTC+0000'

  The preferred way of dealing with times is to always work in UTC,
  converting to localtime only when generating output to be read
  by humans.

  >>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)
  >>> loc_dt = utc_dt.astimezone(eastern)
  >>> loc_dt.strftime(fmt)
  '2002-10-27 01:00:00 EST-0500'

  This library also allows you to do date arithmetic using local
  times, although it is more complicated than working in UTC as you
  need to use the ``normalize()`` method to handle daylight saving time
  and other timezone transitions. In this example, ``loc_dt`` is set
  to the instant when daylight saving time ends in the US/Eastern
  timezone.

  >>> before = loc_dt - timedelta(minutes=10)
  >>> before.strftime(fmt)
  '2002-10-27 00:50:00 EST-0500'
  >>> eastern.normalize(before).strftime(fmt)
  '2002-10-27 01:50:00 EDT-0400'
  >>> after = eastern.normalize(before + timedelta(minutes=20))
  >>> after.strftime(fmt)
  '2002-10-27 01:10:00 EST-0500'

  Creating local times is also tricky, and the reason why working with
  local times is not recommended. Unfortunately, you cannot just pass
  a ``tzinfo`` argument when constructing a datetime (see the next
  section for more details)

  >>> dt = datetime(2002, 10, 27, 1, 30, 0)
  >>> dt1 = eastern.localize(dt, is_dst=True)
  >>> dt1.strftime(fmt)
  '2002-10-27 01:30:00 EDT-0400'
  >>> dt2 = eastern.localize(dt, is_dst=False)
  >>> dt2.strftime(fmt)
  '2002-10-27 01:30:00 EST-0500'

  Converting between timezones is more easily done, using the
  standard astimezone method.

  >>> utc_dt = utc.localize(datetime.utcfromtimestamp(1143408899))
  >>> utc_dt.strftime(fmt)
  '2006-03-26 21:34:59 UTC+0000'
  >>> au_tz = timezone('Australia/Sydney')
  >>> au_dt = utc_dt.astimezone(au_tz)
  >>> au_dt.strftime(fmt)
  '2006-03-27 08:34:59 AEDT+1100'
  >>> utc_dt2 = au_dt.astimezone(utc)
  >>> utc_dt2.strftime(fmt)
  '2006-03-26 21:34:59 UTC+0000'
  >>> utc_dt == utc_dt2
  True

  You can take shortcuts when dealing with the UTC side of timezone
  conversions. ``normalize()`` and ``localize()`` are not really
  necessary when there are no daylight saving time transitions to
  deal with.

  >>> utc_dt = datetime.utcfromtimestamp(1143408899).replace(tzinfo=utc)
  >>> utc_dt.strftime(fmt)
  '2006-03-26 21:34:59 UTC+0000'
  >>> au_tz = timezone('Australia/Sydney')
  >>> au_dt = au_tz.normalize(utc_dt.astimezone(au_tz))
  >>> au_dt.strftime(fmt)
  '2006-03-27 08:34:59 AEDT+1100'
  >>> utc_dt2 = au_dt.astimezone(utc)
  >>> utc_dt2.strftime(fmt)
  '2006-03-26 21:34:59 UTC+0000'


  ``tzinfo`` API
  --------------

  The ``tzinfo`` instances returned by the ``timezone()`` function have
  been extended to cope with ambiguous times by adding an ``is_dst``
  parameter to the ``utcoffset()``, ``dst()`` && ``tzname()`` methods.

  >>> tz = timezone('America/St_Johns')

  >>> normal = datetime(2009, 9, 1)
  >>> ambiguous = datetime(2009, 10, 31, 23, 30)

  The ``is_dst`` parameter is ignored for most timestamps. It is only used
  during DST transition ambiguous periods to resolve that ambiguity.

  >>> tz.utcoffset(normal, is_dst=True)
  datetime.timedelta(-1, 77400)
  >>> tz.dst(normal, is_dst=True)
  datetime.timedelta(0, 3600)
  >>> tz.tzname(normal, is_dst=True)
  'NDT'

  >>> tz.utcoffset(ambiguous, is_dst=True)
  datetime.timedelta(-1, 77400)
  >>> tz.dst(ambiguous, is_dst=True)
  datetime.timedelta(0, 3600)
  >>> tz.tzname(ambiguous, is_dst=True)
  'NDT'

  >>> tz.utcoffset(normal, is_dst=False)
  datetime.timedelta(-1, 77400)
  >>> tz.dst(normal, is_dst=False)
  datetime.timedelta(0, 3600)
  >>> tz.tzname(normal, is_dst=False)
  'NDT'

  >>> tz.utcoffset(ambiguous, is_dst=False)
  datetime.timedelta(-1, 73800)
  >>> tz.dst(ambiguous, is_dst=False)
  datetime.timedelta(0)
  >>> tz.tzname(ambiguous, is_dst=False)
  'NST'

  If ``is_dst`` is not specified, ambiguous timestamps will raise
  an ``pytz.exceptions.AmbiguousTimeError`` exception.

  >>> tz.utcoffset(normal)
  datetime.timedelta(-1, 77400)
  >>> tz.dst(normal)
  datetime.timedelta(0, 3600)
  >>> tz.tzname(normal)
  'NDT'

  >>> import pytz.exceptions
  >>> try:
  ...     tz.utcoffset(ambiguous)
  ... except pytz.exceptions.AmbiguousTimeError:
  ...     print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
  pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00
  >>> try:
  ...     tz.dst(ambiguous)
  ... except pytz.exceptions.AmbiguousTimeError:
  ...     print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
  pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00
  >>> try:
  ...     tz.tzname(ambiguous)
  ... except pytz.exceptions.AmbiguousTimeError:
  ...     print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
  pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00


  Problems with Localtime
  ~~~~~~~~~~~~~~~~~~~~~~~

  The major problem we have to deal with is that certain datetimes
  may occur twice in a year. For example, in the US/Eastern timezone
  on the last Sunday morning in October, the following sequence
  happens:

      - 01:00 EDT occurs
      - 1 hour later, instead of 2:00am the clock is turned back 1 hour
        and 01:00 happens again (this time 01:00 EST)

  In fact, every instant between 01:00 and 02:00 occurs twice. This means
  that if you try and create a time in the 'US/Eastern' timezone
  the standard datetime syntax, there is no way to specify if you meant
  before of after the end-of-daylight-saving-time transition. Using the
  pytz custom syntax, the best you can do is make an educated guess:

  >>> loc_dt = eastern.localize(datetime(2002, 10, 27, 1, 30, 00))
  >>> loc_dt.strftime(fmt)
  '2002-10-27 01:30:00 EST-0500'

  As you can see, the system has chosen one for you and there is a 50%
  chance of it being out by one hour. For some applications, this does
  not matter. However, if you are trying to schedule meetings with people
  in different timezones or analyze log files it is not acceptable.

  The best and simplest solution is to stick with using UTC.  The pytz
  package encourages using UTC for internal timezone representation by
  including a special UTC implementation based on the standard Python
  reference implementation in the Python documentation.

  The UTC timezone unpickles to be the same instance, and pickles to a
  smaller size than other pytz tzinfo instances.  The UTC implementation
  can be obtained as pytz.utc, pytz.UTC, or pytz.timezone('UTC').

  >>> import pickle, pytz
  >>> dt = datetime(2005, 3, 1, 14, 13, 21, tzinfo=utc)
  >>> naive = dt.replace(tzinfo=None)
  >>> p = pickle.dumps(dt, 1)
  >>> naive_p = pickle.dumps(naive, 1)
  >>> len(p) - len(naive_p)
  17
  >>> new = pickle.loads(p)
  >>> new == dt
  True
  >>> new is dt
  False
  >>> new.tzinfo is dt.tzinfo
  True
  >>> pytz.utc is pytz.UTC is pytz.timezone('UTC')
  True

  Note that some other timezones are commonly thought of as the same (GMT,
  Greenwich, Universal, etc.). The definition of UTC is distinct from these
  other timezones, and they are not equivalent. For this reason, they will
  not compare the same in Python.

  >>> utc == pytz.timezone('GMT')
  False

  See the section `What is UTC`_, below.

  If you insist on working with local times, this library provides a
  facility for constructing them unambiguously:

  >>> loc_dt = datetime(2002, 10, 27, 1, 30, 00)
  >>> est_dt = eastern.localize(loc_dt, is_dst=True)
  >>> edt_dt = eastern.localize(loc_dt, is_dst=False)
  >>> print(est_dt.strftime(fmt) + ' / ' + edt_dt.strftime(fmt))
  2002-10-27 01:30:00 EDT-0400 / 2002-10-27 01:30:00 EST-0500

  If you pass None as the is_dst flag to localize(), pytz will refuse to
  guess and raise exceptions if you try to build ambiguous or non-existent
  times.

  For example, 1:30am on 27th Oct 2002 happened twice in the US/Eastern
  timezone when the clocks where put back at the end of Daylight Saving
  Time:

  >>> dt = datetime(2002, 10, 27, 1, 30, 00)
  >>> try:
  ...     eastern.localize(dt, is_dst=None)
  ... except pytz.exceptions.AmbiguousTimeError:
  ...     print('pytz.exceptions.AmbiguousTimeError: %s' % dt)
  pytz.exceptions.AmbiguousTimeError: 2002-10-27 01:30:00

  Similarly, 2:30am on 7th April 2002 never happened at all in the
  US/Eastern timezone, as the clocks where put forward at 2:00am skipping
  the entire hour:

  >>> dt = datetime(2002, 4, 7, 2, 30, 00)
  >>> try:
  ...     eastern.localize(dt, is_dst=None)
  ... except pytz.exceptions.NonExistentTimeError:
  ...     print('pytz.exceptions.NonExistentTimeError: %s' % dt)
  pytz.exceptions.NonExistentTimeError: 2002-04-07 02:30:00

  Both of these exceptions share a common base class to make error handling
  easier:

  >>> isinstance(pytz.AmbiguousTimeError(), pytz.InvalidTimeError)
  True
  >>> isinstance(pytz.NonExistentTimeError(), pytz.InvalidTimeError)
  True


  A special case is where countries change their timezone definitions
  with no daylight savings time switch. For example, in 1915 Warsaw
  switched from Warsaw time to Central European time with no daylight savings
  transition. So at the stroke of midnight on August 5th 1915 the clocks
  were wound back 24 minutes creating an ambiguous time period that cannot
  be specified without referring to the timezone abbreviation or the
  actual UTC offset. In this case midnight happened twice, neither time
  during a daylight saving time period. pytz handles this transition by
  treating the ambiguous period before the switch as daylight savings
  time, and the ambiguous period after as standard time.


  >>> warsaw = pytz.timezone('Europe/Warsaw')
  >>> amb_dt1 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=True)
  >>> amb_dt1.strftime(fmt)
  '1915-08-04 23:59:59 WMT+0124'
  >>> amb_dt2 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=False)
  >>> amb_dt2.strftime(fmt)
  '1915-08-04 23:59:59 CET+0100'
  >>> switch_dt = warsaw.localize(datetime(1915, 8, 5, 00, 00, 00), is_dst=False)
  >>> switch_dt.strftime(fmt)
  '1915-08-05 00:00:00 CET+0100'
  >>> str(switch_dt - amb_dt1)
  '0:24:01'
  >>> str(switch_dt - amb_dt2)
  '0:00:01'

  The best way of creating a time during an ambiguous time period is
  by converting from another timezone such as UTC:

  >>> utc_dt = datetime(1915, 8, 4, 22, 36, tzinfo=pytz.utc)
  >>> utc_dt.astimezone(warsaw).strftime(fmt)
  '1915-08-04 23:36:00 CET+0100'

  The standard Python way of handling all these ambiguities is not to
  handle them, such as demonstrated in this example using the US/Eastern
  timezone definition from the Python documentation (Note that this
  implementation only works for dates between 1987 and 2006 - it is
  included for tests only!):

  >>> from pytz.reference import Eastern # pytz.reference only for tests
  >>> dt = datetime(2002, 10, 27, 0, 30, tzinfo=Eastern)
  >>> str(dt)
  '2002-10-27 00:30:00-04:00'
  >>> str(dt + timedelta(hours=1))
  '2002-10-27 01:30:00-05:00'
  >>> str(dt + timedelta(hours=2))
  '2002-10-27 02:30:00-05:00'
  >>> str(dt + timedelta(hours=3))
  '2002-10-27 03:30:00-05:00'

  Notice the first two results? At first glance you might think they are
  correct, but taking the UTC offset into account you find that they are
  actually two hours appart instead of the 1 hour we asked for.

  >>> from pytz.reference import UTC # pytz.reference only for tests
  >>> str(dt.astimezone(UTC))
  '2002-10-27 04:30:00+00:00'
  >>> str((dt + timedelta(hours=1)).astimezone(UTC))
  '2002-10-27 06:30:00+00:00'


  Country Information
  ~~~~~~~~~~~~~~~~~~~

  A mechanism is provided to access the timezones commonly in use
  for a particular country, looked up using the ISO 3166 country code.
  It returns a list of strings that can be used to retrieve the relevant
  tzinfo instance using ``pytz.timezone()``:

  >>> print(' '.join(pytz.country_timezones['nz']))
  Pacific/Auckland Pacific/Chatham

  The Olson database comes with a ISO 3166 country code to English country
  name mapping that pytz exposes as a dictionary:

  >>> print(pytz.country_names['nz'])
  New Zealand


  What is UTC
  ~~~~~~~~~~~

  'UTC' is `Coordinated Universal Time`_. It is a successor to, but distinct
  from, Greenwich Mean Time (GMT) and the various definitions of Universal
  Time. UTC is now the worldwide standard for regulating clocks and time
  measurement.

  All other timezones are defined relative to UTC, and include offsets like
  UTC+0800 - hours to add or subtract from UTC to derive the local time. No
  daylight saving time occurs in UTC, making it a useful timezone to perform
  date arithmetic without worrying about the confusion and ambiguities caused
  by daylight saving time transitions, your country changing its timezone, or
  mobile computers that roam through multiple timezones.

  ..  _Coordinated Universal Time: https://en.wikipedia.org/wiki/Coordinated_Universal_Time


  Helpers
  ~~~~~~~

  There are two lists of timezones provided.

  ``all_timezones`` is the exhaustive list of the timezone names that can
  be used.

  >>> from pytz import all_timezones
  >>> len(all_timezones) >= 500
  True
  >>> 'Etc/Greenwich' in all_timezones
  True

  ``common_timezones`` is a list of useful, current timezones. It doesn't
  contain deprecated zones or historical zones, except for a few I've
  deemed in common usage, such as US/Eastern (open a bug report if you
  think other timezones are deserving of being included here). It is also
  a sequence of strings.

  >>> from pytz import common_timezones
  >>> len(common_timezones) < len(all_timezones)
  True
  >>> 'Etc/Greenwich' in common_timezones
  False
  >>> 'Australia/Melbourne' in common_timezones
  True
  >>> 'US/Eastern' in common_timezones
  True
  >>> 'Canada/Eastern' in common_timezones
  True
  >>> 'Australia/Yancowinna' in all_timezones
  True
  >>> 'Australia/Yancowinna' in common_timezones
  False

  Both ``common_timezones`` and ``all_timezones`` are alphabetically
  sorted:

  >>> common_timezones_dupe = common_timezones[:]
  >>> common_timezones_dupe.sort()
  >>> common_timezones == common_timezones_dupe
  True
  >>> all_timezones_dupe = all_timezones[:]
  >>> all_timezones_dupe.sort()
  >>> all_timezones == all_timezones_dupe
  True

  ``all_timezones`` and ``common_timezones`` are also available as sets.

  >>> from pytz import all_timezones_set, common_timezones_set
  >>> 'US/Eastern' in all_timezones_set
  True
  >>> 'US/Eastern' in common_timezones_set
  True
  >>> 'Australia/Victoria' in common_timezones_set
  False

  You can also retrieve lists of timezones used by particular countries
  using the ``country_timezones()`` function. It requires an ISO-3166
  two letter country code.

  >>> from pytz import country_timezones
  >>> print(' '.join(country_timezones('ch')))
  Europe/Zurich
  >>> print(' '.join(country_timezones('CH')))
  Europe/Zurich


  Internationalization - i18n/l10n
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Pytz is an interface to the IANA database, which uses ASCII names. The `Unicode  Consortium's Unicode Locales (CLDR) <http://cldr.unicode.org>`_
  project provides translations. Thomas Khyn's
  `l18n <https://pypi.org/project/l18n/>`_ package can be used to access
  these translations from Python.


  License
  ~~~~~~~

  MIT license.

  This code is also available as part of Zope 3 under the Zope Public
  License,  Version 2.1 (ZPL).

  I'm happy to relicense this code if necessary for inclusion in other
  open source projects.


  Latest Versions
  ~~~~~~~~~~~~~~~

  This package will be updated after releases of the Olson timezone
  database.  The latest version can be downloaded from the `Python Package
  Index <https://pypi.org/project/pytz/>`_.  The code that is used
  to generate this distribution is hosted on launchpad.net and available
  using git::

      git clone https://git.launchpad.net/pytz

  A mirror on github is also available at https://github.com/stub42/pytz

  Announcements of new releases are made on
  `Launchpad <https://launchpad.net/pytz>`_, and the
  `Atom feed <http://feeds.launchpad.net/pytz/announcements.atom>`_
  hosted there.


  Bugs, Feature Requests & Patches
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Bugs can be reported using `Launchpad <https://bugs.launchpad.net/pytz>`__.


  Issues & Limitations
  ~~~~~~~~~~~~~~~~~~~~

  - Offsets from UTC are rounded to the nearest whole minute, so timezones
    such as Europe/Amsterdam pre 1937 will be up to 30 seconds out. This
    is a limitation of the Python datetime library.

  - If you think a timezone definition is incorrect, I probably can't fix
    it. pytz is a direct translation of the Olson timezone database, and
    changes to the timezone definitions need to be made to this source.
    If you find errors they should be reported to the time zone mailing
    list, linked from http://www.iana.org/time-zones.


  Further Reading
  ~~~~~~~~~~~~~~~

  More info than you want to know about timezones:
  http://www.twinsun.com/tz/tz-link.htm


  Contact
  ~~~~~~~

  Stuart Bishop <stuart@stuartbishop.net>


pkgId: bc6efa69603112ad9f08890839e3bad2bfcdea23c88512f8430d009b06e1b657
name: rh-python36-pyvmomi
arch: noarch
version: 6.7.3
epoch: 0
release: 2
summary: VMware vSphere Python SDK
url: https://github.com/vmware/pyvmomi
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: VMware, Inc. <jhu@vmware.com>
rpm_group: Development/Libraries
rpm_buildhost: a8165db4c0fe4bef84f592d993506ebb
rpm_sourcerpm: rh-python36-pyvmomi-6.7.3-2.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01051980-rh-python36-pyvmomi/rh-python36-pyvmomi-6.7.3-2.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://travis-ci.org/vmware/pyvmomi.svg?branch=v6.0.0.2016.4
      :target: https://travis-ci.org/vmware/pyvmomi
      :alt: Build Status

  .. image:: https://img.shields.io/pypi/dm/pyvmomi.svg
      :target: https://pypi.python.org/pypi/pyvmomi/
      :alt: Downloads

  pyVmomi is the Python SDK for the VMware vSphere API that allows you to manage
  ESX, ESXi, and vCenter.

  Getting Started
  ================
  To get started, see the `getting started guide <http://vmware.github.io/pyvmomi-community-samples/#getting-started>`_. You'll need `Python <https://www.python.org/downloads/>`_, `pip <https://pip.pypa.io/en/latest/installing.html#using-package-managers>`_, and the `samples project <https://github.com/vmware/pyvmomi-community-samples/tarball/master>`_.

  * http://vmware.github.io/pyvmomi-community-samples/
  * community discussion on IRC freenode.net channels `#pyvmomi and #pyvmomi-dev <http://webchat.freenode.net/?channels=#pyvmomi,#pyvmomi-dev>`_
  * community email is on `nabble <http://pyvmomi.2338814.n4.nabble.com>`_

  Don't know what pip is? Any serious python developer should know, so here's a `throrough intro to pip <http://www.dabapps.com/blog/introduction-to-pip-and-virtualenv-python/>`_ that we like.

  Installing
  ==========
  The master is code that is in development, official releases are tagged and
  posted to `pypi <https://pypi.python.org/pypi/pyvmomi/>`_

  * The official release is available using pip, just run
    ``pip install --upgrade pyvmomi``.
  * To install the version in `github <https://github.com/vmware/pyvmomi>`_ use
    ``python setup.py develop`` for development install or
    ``python setup.py install``.

  Testing
  =======
  Unit tests can be invoked by using the `tox <https://testrun.org/tox/>`_ command. You may have to
  configure multiple python interpreters so that you can test in all the
  environments listed in ``tox.ini`` or you will have to run ``tox`` with the
  ``-e`` flag to run only in your version of python. For example, if you only
  have Python 2.7 then ``tox -e py27`` will limit your test run to Python 2.7.

  Contributing
  ============
  * Research `open issues <https://github.com/vmware/pyvmomi/issues?q=is%3Aopen+is%3Aissue>`_
  * Follow the `contribution standards <https://github.com/vmware/pyvmomi/wiki/Contributions>`_
  * Coordinate with `other developers <http://webchat.freenode.net/?channels=#pyvmomi,#pyvmomi-dev>`_ on the project.

  Documentation
  =============
  For general language neutral documentation of vSphere Management API see:

  * `vSphere WS SDK API Docs <http://pubs.vmware.com/vsphere-65/topic/com.vmware.wssdk.apiref.doc/right-pane.html>`_

  Python Support
  ==============
  * pyVmomi 6.5 supports 2.7, 3.3, 3.4 and 3.5
  * pyVmomi 6.0.0.2016.4 and later support 2.7, 3.3 and 3.4
  * pyVmomi 6.0.0 and later support 2.7, 3.3 and 3.4
  * pyVmomi 5.5.0-2014.1 and 5.5.0-2014.1.1 support Python 2.6, 2.7, 3.3 and 3.4
  * pyVmomi 5.5.0 and below support Python 2.6 and 2.7

  Compatibility Policy
  ====================
  pyVmomi versions are marked vSphere_version-release . Pyvmomi maintains minimum
  backward compatibility with the previous _four_ releases of *vSphere* and it's
  own previous four releases. Compatibility with much older versions may continue
  to work but will not be actively supported.

  For example, version v6.0.0 is most compatible with vSphere 6.0, 5.5, 5.1 and
  5.0. Initial releases compatible with a version of vSphere will bare a naked
  version number of v6.0.0 indicating that version of pyVmomi was released
  simultaneously with the *GA* version of vSphere with the same version number.

  Releases
  ========
  * `6.5 <https://github.com/vmware/pyvmomi/tree/v6.5.0>`_
     release notes https://github.com/vmware/pyvmomi/releases/tag/v6.5.0
  * `6.0.0.2016.4 <https://github.com/vmware/pyvmomi/tree/v6.0.0.2016.4>`_
     release notes https://github.com/vmware/pyvmomi/releases/tag/v6.0.0.2016.4
  * `6.0.0 <https://github.com/vmware/pyvmomi/tree/v6.0.0>`_
     release notes https://github.com/vmware/pyvmomi/releases/tag/v6.0.0
  * `5.5.0-2014.1.1 <https://github.com/vmware/pyvmomi/tree/v5.5.0-2014.1.1>`_
     release notes https://github.com/vmware/pyvmomi/releases/tag/v5.5.0-2014.1.1
  * `5.5.0-2014.1 <https://github.com/vmware/pyvmomi/tree/v5.5.0-2014.1>`_
     release notes https://github.com/vmware/pyvmomi/releases/tag/v5.5.0-2014.1
  * `5.5.0 <https://github.com/vmware/pyvmomi/tree/v5.5.0>`_
  * `5.1.0 <https://github.com/vmware/pyvmomi/tree/v5.1.0>`_
     release notes https://github.com/vmware/pyvmomi/releases/tag/v5.1.0

  Related Projects
  ================
  * VMware vSphere Automation SDK for Python: https://developercenter.vmware.com/web/sdk/65/vsphere-automation-python
  * Samples Project: https://github.com/vmware/pyvmomi-community-samples
  * Feature Incubator: pyvmomi-tools https://github.com/vmware/pyvmomi-tools

  Have fun!


pkgId: fbbcfd785906ff797297c8e15b5e0cf18918207409a07729a735a7741063b752
name: rh-python36-redbaron
arch: noarch
version: 0.6.3
epoch: 0
release: 1
summary: Abstraction on top of baron, a FST for python to make writing refactoring code a realistic task
url: https://github.com/PyCQA/redbaron
rpm_license: lgplv3+
rpm_vendor: Laurent Peuch <cortex@worlddomination.be>
rpm_group: Development/Libraries
rpm_buildhost: 1b21aae94ac64745a2f27f78b4bcccdf
rpm_sourcerpm: rh-python36-redbaron-0.6.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00850371-rh-python36-redbaron/rh-python36-redbaron-0.6.3-1.noarch.rpm
checksum_type: sha256
description:
  Introduction
  ============

  [![Build Status](https://travis-ci.org/PyCQA/redbaron.svg?branch=master)](https://travis-ci.org/PyCQA/redbaron) [![Latest Version](https://pypip.in/version/redbaron/badge.svg)](https://pypi.python.org/pypi/redbaron/) [![Supported Python versions](https://pypip.in/py_versions/redbaron/badge.svg)](https://pypi.python.org/pypi/redbaron/) [![Development Status](https://pypip.in/status/redbaron/badge.svg)](https://pypi.python.org/pypi/redbaron/) [![Wheel Status](https://pypip.in/wheel/redbaron/badge.svg)](https://pypi.python.org/pypi/redbaron/) [![Download format](https://pypip.in/format/redbaron/badge.svg)](https://pypi.python.org/pypi/redbaron/) [![License](https://pypip.in/license/redbaron/badge.svg)](https://pypi.python.org/pypi/redbaron/)

  RedBaron is a python library and tool powerful enough to be used into IPython
  solely that intent to make the process of **writing code that modify source
  code** as easy and as simple as possible. That include writing custom
  refactoring, generic refactoring, tools, IDE or directly modifying you source
  code into IPython with an higher and more powerful abstraction than the
  advanced texts modification tools that you find in advanced text editors and
  IDE.

  RedBaron guaranteed you that **it will only modify your code where you ask him
  to**. To achieve this, it is based on [Baron](https://github.com/PyCQA/baron)
  a lossless [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) for
  Python that guarantees the operation <code>ast_to_code(code_to_ast(source_code)) == source_code</code>.
  (Baron's AST is called a FST, a Full Syntax Tree).

  RedBaron API and feel is heavily inspired by BeautifulSoup. It tries to be
  simple and intuitive and that once you've get the basics principles, you are
  good without reading the doc for 80% of your operations.

  **For now, RedBaron can be considered in alpha, the core is quite stable but it
  is not battle tested yet and is still a bit rough.** Feedback and contribution
  are very welcome.

  The public documented API on the other side is guaranteed to be
  retro-compatible and won't break until 2.0 (if breaking is needed at that
  point).
  There might be the only exception that if you directly call specific nodes
  constructors with FST that this API change, but this is not documented and
  simply horribly unpracticable, so I'm expecting no one to do that.

  **Disclamer**: RedBaron (and baron) is **working** with python3 but it NOT fully parsing it yet.

  Installation
  ============

      pip install redbaron[pygments]

  Or if you don't want to have syntax highlight in your shell or don't need it:

      pip install redbaron

  Running tests
  =============

      pip install pytest
      py.test tests

  Community
  =========

  You can reach us on [irc.freenode.net#baron](https://webchat.freenode.net/?channels=%23baron) or [irc.freenode.net##python-code-quality](https://webchat.freenode.net/?channels=%23%23python-code-quality).

  Code of Conduct
  ===============

  As a member of [PyCQA](https://github.com/PyCQA), RedBaron follows its [Code of Conduct](http://meta.pycqa.org/en/latest/code-of-conduct.html).

  Links
  =====

  **RedBaron is fully documented, be sure to check the turorial and documentation**.

  * [Tutorial](https://redbaron.readthedocs.io/en/latest/tuto.html)
  * [Documentation](https://redbaron.readthedocs.io/en/latest/)
  * [Baron](https://github.com/PyCQA/baron)
  * IRC chat: [irc.freenode.net#baron](https://webchat.freenode.net/?channels=%23baron)


  Changelog
  =========

  0.6.3 (2017-01-02)
  -----------------

  - fix help() after append
  - fix _synchronise() for base_nodes to avoid recursion in __repr__ function if code run not in the shell
  - add at method

  0.6.2 (2016-10-03)
  ----------------

  - fix some old call to log() weren't lazy, that could cause a crash in some situations by an infinite recursive call and also reduce performances
  - fix in _iter_in_rendering_order method to avoid bug in edge cases (issue #107)

  0.6.1 (2016-03-28)
  ----------------

  - fix setup.py, package weren't pushed on pypi since splitting of redbaron.py
    into multiple files.

  0.6 (2016-03-28)
  ----------------

  This release is guaranteed to have a retro-compatible public documented API
  from now on until maybe 2.0.
  There might be the only exception that if you directly call specific nodes
  constructors with FST that this API change, but this is not documented and
  simply horribly unpracticable, so I'm expecting no one to do that.

  From now on the focus will be on moving to a stable 1.0 meaning: bugs fixes and
  API additions for missing needed features and no more big modifications, this
  will be for other releases, the workload is already big enough.

  - BIG improvement on the proxy list merging algorithm, it is not perfect yet (comments aren't handled yet) but it's really a big move forward
  - possible retrocompatibility breaking change: from now on the node.find("name") to node.name shortcut ONLY works with possible nodes identifiers. For example node.i_dont_exist_as_an_identifier will raise AttributeError
  - new helper method .to_python that wrap ast.literal_eval on compatibile nodes https://redbaron.readthedocs.io/en/latest/other.html#to-python
  - breaking: IntNode no longer return an int on .value but a .string instead, use .to_python to have an evaluated version
  - fix node.decrease_indentation (that was simply not working)
  - fix code_block_node.value was broken on node with no parent
  - add string representation for Path object
  - now redbaron Path() class can be compared directly to baron paths
    without using to_baron_path() helper.
  - fix by novocaine: 'function' was used as a function type detector instead of 'def'
  - add getitem() method with same api on NodeList and ProxyList
  - fix: inconsistencies when inserting lines around code blocks
  - inserting a blank lines inserts effectively a \n in a LineProxyList
  - new helper methods: .next_recursive and .previous_recursive https://redbaron.readthedocs.io/en/latest/other.html
  - fix: doc is tested in CI now, it shouldn't break anymore
  - more rendering test for python3, it shouldn't break anymore
  - pygments is now an optional dependancy, "pip install redbaron" won't install it, "pip install redbaron[pygments"] will
  - new node.next_intuitive and node.previous_intuitive methods for situations where .next/previous doesn't behave the way the user expect it https://redbaron.readthedocs.io/en/latest/other.html#next-intuitive-previous-intuitive

  0.5.1 (2015-03-11)
  ------------------

  - fix whitespace duplication when using .insert()
  - DecoratorProxyList of the last method of a function wasn't handling correctly the indentation of its last endl token

  0.5 (2015-01-31)
  ----------------

  - fix index handling in get_absolute_bounding_box_of_attribute method in
    a LineProxyList
  - pretty rendering of RedBaron repr in ipython notebook using _repr_html_, see:
    https://cloud.githubusercontent.com/assets/41827/5731132/65ff4c92-9b80-11e4-977c-0faebbf63415.png
  - fix: RedBaron repr was crashing in bpython and in ipython notebook. The new
    behavior should be way more stable and never crash.
  - new helpers .names, .modules, .full_path_modules for from_import node https://redbaron.readthedocs.io/en/latest/other.html#index-on-parent-raw
  - add a node.index_on_parent_raw and make node.index_on_parent works has it
    should be intuitivly according to the proxy list api https://redbaron.readthedocs.io/en/latest/other.html#index-on-parent-raw
  - new helper methods: .insert_before and .insert_after https://redbaron.readthedocs.io/en/latest/other.html#insert-before-insert-after
  - fix: some white space bugs in the merging algorithm of line proxy
  - fix: on_attribute and parent were correctly set on newly added elements to
    the root node

  0.4 (2014-12-11)
  ----------------

  - compatibility with baron upstream (removal of def_argument_node and
    uniformisation of def_arguments structure)
  - fix: long wasn't supported in redbaron (due to a bug in baron)

  0.3 (2014-11-12)
  ----------------

  - proxy lists, major improvement in the management of list of things
  - .append_value is no more since it is useless now due to proxy lists
  - .index has been renamed to .index_on_parent to be more coherent

  0.2 (2014-09-23)
  ----------------

  - for EVERY NODES in RedBaron, the automagic behavior when passing a string to
    modify an attribute has been done, this is HUGE improvement
    https://redbaron.readthedocs.io/en/latest/modifying.html#full-documentations
  - it's now possible to use regex, globs, list/tuple and lambda (callable) in .find and
    .find_all, see https://redbaron.readthedocs.io/en/latest/querying.html#advanced-querying
  - new method on node: .replace() to replace in place a node
    https://redbaron.readthedocs.io/en/latest/other.html#replace
  - .map .filter and .apply are now documented https://redbaron.readthedocs.io/en/latest/other.html#map-filter-apply
  - .edit() new helper method to launch a text editor on the selected node and
    replace the node with the modified code https://redbaron.readthedocs.io/en/latest/other.html#edit
  - .root node attribute (property) that return the root node of the tree in which the
    node is stored https://redbaron.readthedocs.io/en/latest/other.html#root
  - .index node attribute (property) that returns the index at which the node is
    store if it's store in a nodelist, None otherwise https://redbaron.readthedocs.io/en/latest/other.html#index
  - setitem (a[x] = b) on nodelist now works as expected (accepting string, fst
    node and redbaron node)
  - new method to handle indentation: .increase_indentation and .decrease_indentation https://redbaron.readthedocs.io/en/latest/other.html#increase-indentation-and-decrease-indentation
  - various small bugfix
  - we have one new contributor \o/ https://github.com/ze42
  - to_node has been move to a class method of Node: Node.from_fst
  - pretty print of nodes when using redbaron in a script

  0.1 (2014-06-13)
  ----------------

  - First release


pkgId: 2ac08ffa576e2b0f007ca61b12a9a8c1459ee0ce116df8f2a35963ab33122232
name: rh-python36-redis
arch: noarch
version: 3.3.11
epoch: 0
release: 1
summary: Python client for Redis key-value store
url: https://github.com/andymccurdy/redis-py
rpm_license: MIT
rpm_vendor: Andy McCurdy <sedrik@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 76a78d4cde15440e9f1cd16fc744f8d1
rpm_sourcerpm: rh-python36-redis-3.3.11-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01311578-rh-python36-redis/rh-python36-redis-3.3.11-1.noarch.rpm
checksum_type: sha256
description:
  redis-py
  ========

  The Python interface to the Redis key-value store.

  .. image:: https://secure.travis-ci.org/andymccurdy/redis-py.svg?branch=master
          :target: https://travis-ci.org/andymccurdy/redis-py
  .. image:: https://readthedocs.org/projects/redis-py/badge/?version=latest&style=flat
          :target: https://redis-py.readthedocs.io/en/latest/
  .. image:: https://badge.fury.io/py/redis.svg
          :target: https://pypi.org/project/redis/
  .. image:: https://codecov.io/gh/andymccurdy/redis-py/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/andymccurdy/redis-py

  Installation
  ------------

  redis-py requires a running Redis server. See `Redis's quickstart
  <https://redis.io/topics/quickstart>`_ for installation instructions.

  redis-py can be installed using `pip` similar to other Python packages. Do not use `sudo`
  with `pip`. It is usually good to work in a
  `virtualenv <https://virtualenv.pypa.io/en/latest/>`_ or
  `venv <https://docs.python.org/3/library/venv.html>`_ to avoid conflicts with other package
  managers and Python projects. For a quick introduction see
  `Python Virtual Environments in Five Minutes <https://bit.ly/py-env>`_.

  To install redis-py, simply:

  .. code-block:: bash

      $ pip install redis

  or from source:

  .. code-block:: bash

      $ python setup.py install


  Getting Started
  ---------------

  .. code-block:: pycon

      >>> import redis
      >>> r = redis.Redis(host='localhost', port=6379, db=0)
      >>> r.set('foo', 'bar')
      True
      >>> r.get('foo')
      'bar'

  By default, all responses are returned as `bytes` in Python 3 and `str` in
  Python 2. The user is responsible for decoding to Python 3 strings or Python 2
  unicode objects.

  If **all** string responses from a client should be decoded, the user can
  specify `decode_responses=True` to `Redis.__init__`. In this case, any
  Redis command that returns a string type will be decoded with the `encoding`
  specified.


  Upgrading from redis-py 2.X to 3.0
  ----------------------------------

  redis-py 3.0 introduces many new features but required a number of backwards
  incompatible changes to be made in the process. This section attempts to
  provide an upgrade path for users migrating from 2.X to 3.0.


  Python Version Support
  ^^^^^^^^^^^^^^^^^^^^^^

  redis-py 3.0 now supports Python 2.7 and Python 3.4+. Python 2.6 and 3.3
  support has been dropped.


  Client Classes: Redis and StrictRedis
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  redis-py 3.0 drops support for the legacy "Redis" client class. "StrictRedis"
  has been renamed to "Redis" and an alias named "StrictRedis" is provided so
  that users previously using "StrictRedis" can continue to run unchanged.

  The 2.X "Redis" class provided alternative implementations of a few commands.
  This confused users (rightfully so) and caused a number of support issues. To
  make things easier going forward, it was decided to drop support for these
  alternate implementations and instead focus on a single client class.

  2.X users that are already using StrictRedis don't have to change the class
  name. StrictRedis will continue to work for the forseeable future.

  2.X users that are using the Redis class will have to make changes if they
  use any of the following commands:

  * SETEX: The argument order has changed. The new order is (name, time, value).
  * LREM: The argument order has changed. The new order is (name, num, value).
  * TTL and PTTL: The return value is now always an int and matches the
    official Redis command (>0 indicates the timeout, -1 indicates that the key
    exists but that it has no expire time set, -2 indicates that the key does
    not exist)


  SSL Connections
  ^^^^^^^^^^^^^^^

  redis-py 3.0 changes the default value of the `ssl_cert_reqs` option from
  `None` to `'required'`. See
  `Issue 1016 <https://github.com/andymccurdy/redis-py/issues/1016>`_. This
  change enforces hostname validation when accepting a cert from a remote SSL
  terminator. If the terminator doesn't properly set the hostname on the cert
  this will cause redis-py 3.0 to raise a ConnectionError.

  This check can be disabled by setting `ssl_cert_reqs` to `None`. Note that
  doing so removes the security check. Do so at your own risk.

  It has been reported that SSL certs received from AWS ElastiCache do not have
  proper hostnames and turning off hostname verification is currently required.


  MSET, MSETNX and ZADD
  ^^^^^^^^^^^^^^^^^^^^^

  These commands all accept a mapping of key/value pairs. In redis-py 2.X
  this mapping could be specified as ``*args`` or as ``**kwargs``. Both of these
  styles caused issues when Redis introduced optional flags to ZADD. Relying on
  ``*args`` caused issues with the optional argument order, especially in Python
  2.7. Relying on ``**kwargs`` caused potential collision issues of user keys with
  the argument names in the method signature.

  To resolve this, redis-py 3.0 has changed these three commands to all accept
  a single positional argument named mapping that is expected to be a dict. For
  MSET and MSETNX, the dict is a mapping of key-names -> values. For ZADD, the
  dict is a mapping of element-names -> score.

  MSET, MSETNX and ZADD now look like:

  .. code-block:: pycon

      def mset(self, mapping):
      def msetnx(self, mapping):
      def zadd(self, name, mapping, nx=False, xx=False, ch=False, incr=False):

  All 2.X users that use these commands must modify their code to supply
  keys and values as a dict to these commands.


  ZINCRBY
  ^^^^^^^

  redis-py 2.X accidentally modified the argument order of ZINCRBY, swapping the
  order of value and amount. ZINCRBY now looks like:

  .. code-block:: pycon

      def zincrby(self, name, amount, value):

  All 2.X users that rely on ZINCRBY must swap the order of amount and value
  for the command to continue to work as intended.


  Encoding of User Input
  ^^^^^^^^^^^^^^^^^^^^^^

  redis-py 3.0 only accepts user data as bytes, strings or numbers (ints, longs
  and floats). Attempting to specify a key or a value as any other type will
  raise a DataError exception.

  redis-py 2.X attempted to coerce any type of input into a string. While
  occasionally convenient, this caused all sorts of hidden errors when users
  passed boolean values (which were coerced to 'True' or 'False'), a None
  value (which was coerced to 'None') or other values, such as user defined
  types.

  All 2.X users should make sure that the keys and values they pass into
  redis-py are either bytes, strings or numbers.


  Locks
  ^^^^^

  redis-py 3.0 drops support for the pipeline-based Lock and now only supports
  the Lua-based lock. In doing so, LuaLock has been renamed to Lock. This also
  means that redis-py Lock objects require Redis server 2.6 or greater.

  2.X users that were explicitly referring to "LuaLock" will have to now refer
  to "Lock" instead.


  Locks as Context Managers
  ^^^^^^^^^^^^^^^^^^^^^^^^^

  redis-py 3.0 now raises a LockError when using a lock as a context manager and
  the lock cannot be acquired within the specified timeout. This is more of a
  bug fix than a backwards incompatible change. However, given an error is now
  raised where none was before, this might alarm some users.

  2.X users should make sure they're wrapping their lock code in a try/catch
  like this:

  .. code-block:: pycon

      try:
          with r.lock('my-lock-key', blocking_timeout=5) as lock:
              
      except LockError:
          


  API Reference
  -------------

  The `official Redis command documentation <https://redis.io/commands>`_ does a
  great job of explaining each command in detail. redis-py attempts to adhere
  to the official command syntax. There are a few exceptions:

  * **SELECT**: Not implemented. See the explanation in the Thread Safety section
    below.
  * **DEL**: 'del' is a reserved keyword in the Python syntax. Therefore redis-py
    uses 'delete' instead.
  * **MULTI/EXEC**: These are implemented as part of the Pipeline class. The
    pipeline is wrapped with the MULTI and EXEC statements by default when it
    is executed, which can be disabled by specifying transaction=False.
    See more about Pipelines below.
  * **SUBSCRIBE/LISTEN**: Similar to pipelines, PubSub is implemented as a separate
    class as it places the underlying connection in a state where it can't
    execute non-pubsub commands. Calling the pubsub method from the Redis client
    will return a PubSub instance where you can subscribe to channels and listen
    for messages. You can only call PUBLISH from the Redis client (see
    `this comment on issue #151
    <https://github.com/andymccurdy/redis-py/issues/151#issuecomment-1545015>`_
    for details).
  * **SCAN/SSCAN/HSCAN/ZSCAN**: The \*SCAN commands are implemented as they
    exist in the Redis documentation. In addition, each command has an equivalent
    iterator method. These are purely for convenience so the user doesn't have
    to keep track of the cursor while iterating. Use the
    scan_iter/sscan_iter/hscan_iter/zscan_iter methods for this behavior.


  More Detail
  -----------

  Connection Pools
  ^^^^^^^^^^^^^^^^

  Behind the scenes, redis-py uses a connection pool to manage connections to
  a Redis server. By default, each Redis instance you create will in turn create
  its own connection pool. You can override this behavior and use an existing
  connection pool by passing an already created connection pool instance to the
  connection_pool argument of the Redis class. You may choose to do this in order
  to implement client side sharding or have finer grain control of how
  connections are managed.

  .. code-block:: pycon

      >>> pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
      >>> r = redis.Redis(connection_pool=pool)

  Connections
  ^^^^^^^^^^^

  ConnectionPools manage a set of Connection instances. redis-py ships with two
  types of Connections. The default, Connection, is a normal TCP socket based
  connection. The UnixDomainSocketConnection allows for clients running on the
  same device as the server to connect via a unix domain socket. To use a
  UnixDomainSocketConnection connection, simply pass the unix_socket_path
  argument, which is a string to the unix domain socket file. Additionally, make
  sure the unixsocket parameter is defined in your redis.conf file. It's
  commented out by default.

  .. code-block:: pycon

      >>> r = redis.Redis(unix_socket_path='/tmp/redis.sock')

  You can create your own Connection subclasses as well. This may be useful if
  you want to control the socket behavior within an async framework. To
  instantiate a client class using your own connection, you need to create
  a connection pool, passing your class to the connection_class argument.
  Other keyword parameters you pass to the pool will be passed to the class
  specified during initialization.

  .. code-block:: pycon

      >>> pool = redis.ConnectionPool(connection_class=YourConnectionClass,
                                      your_arg='...', ...)

  Connections maintain an open socket to the Redis server. Sometimes these
  sockets are interrupted or disconnected for a variety of reasons. For example,
  network appliances, load balancers and other services that sit between clients
  and servers are often configured to kill connections that remain idle for a
  given threshold.

  When a connection becomes disconnected, the next command issued on that
  connection will fail and redis-py will raise a ConnectionError to the caller.
  This allows each application that uses redis-py to handle errors in a way
  that's fitting for that specific application. However, constant error
  handling can be verbose and cumbersome, especially when socket disconnections
  happen frequently in many production environments.

  To combat this, redis-py can issue regular health checks to assess the
  liveliness of a connection just before issuing a command. Users can pass
  ``health_check_interval=N`` to the Redis or ConnectionPool classes or
  as a query argument within a Redis URL. The value of ``health_check_interval``
  must be an integer. A value of ``0``, the default, disables health checks.
  Any positive integer will enable health checks. Health checks are performed
  just before a command is executed if the underlying connection has been idle
  for more than ``health_check_interval`` seconds. For example,
  ``health_check_interval=30`` will ensure that a health check is run on any
  connection that has been idle for 30 or more seconds just before a command
  is executed on that connection.

  If your application is running in an environment that disconnects idle
  connections after 30 seconds you should set the ``health_check_interval``
  option to a value less than 30.

  This option also works on any PubSub connection that is created from a
  client with ``health_check_interval`` enabled. PubSub users need to ensure
  that ``get_message()`` or ``listen()`` are called more frequently than
  ``health_check_interval`` seconds. It is assumed that most workloads already
  do this.

  If your PubSub use case doesn't call ``get_message()`` or ``listen()``
  frequently, you should call ``pubsub.check_health()`` explicitly on a
  regularly basis.

  Parsers
  ^^^^^^^

  Parser classes provide a way to control how responses from the Redis server
  are parsed. redis-py ships with two parser classes, the PythonParser and the
  HiredisParser. By default, redis-py will attempt to use the HiredisParser if
  you have the hiredis module installed and will fallback to the PythonParser
  otherwise.

  Hiredis is a C library maintained by the core Redis team. Pieter Noordhuis was
  kind enough to create Python bindings. Using Hiredis can provide up to a
  10x speed improvement in parsing responses from the Redis server. The
  performance increase is most noticeable when retrieving many pieces of data,
  such as from LRANGE or SMEMBERS operations.

  Hiredis is available on PyPI, and can be installed via pip just like redis-py.

  .. code-block:: bash

      $ pip install hiredis

  Response Callbacks
  ^^^^^^^^^^^^^^^^^^

  The client class uses a set of callbacks to cast Redis responses to the
  appropriate Python type. There are a number of these callbacks defined on
  the Redis client class in a dictionary called RESPONSE_CALLBACKS.

  Custom callbacks can be added on a per-instance basis using the
  set_response_callback method. This method accepts two arguments: a command
  name and the callback. Callbacks added in this manner are only valid on the
  instance the callback is added to. If you want to define or override a callback
  globally, you should make a subclass of the Redis client and add your callback
  to its RESPONSE_CALLBACKS class dictionary.

  Response callbacks take at least one parameter: the response from the Redis
  server. Keyword arguments may also be accepted in order to further control
  how to interpret the response. These keyword arguments are specified during the
  command's call to execute_command. The ZRANGE implementation demonstrates the
  use of response callback keyword arguments with its "withscores" argument.

  Thread Safety
  ^^^^^^^^^^^^^

  Redis client instances can safely be shared between threads. Internally,
  connection instances are only retrieved from the connection pool during
  command execution, and returned to the pool directly after. Command execution
  never modifies state on the client instance.

  However, there is one caveat: the Redis SELECT command. The SELECT command
  allows you to switch the database currently in use by the connection. That
  database remains selected until another is selected or until the connection is
  closed. This creates an issue in that connections could be returned to the pool
  that are connected to a different database.

  As a result, redis-py does not implement the SELECT command on client
  instances. If you use multiple Redis databases within the same application, you
  should create a separate client instance (and possibly a separate connection
  pool) for each database.

  It is not safe to pass PubSub or Pipeline objects between threads.

  Pipelines
  ^^^^^^^^^

  Pipelines are a subclass of the base Redis class that provide support for
  buffering multiple commands to the server in a single request. They can be used
  to dramatically increase the performance of groups of commands by reducing the
  number of back-and-forth TCP packets between the client and server.

  Pipelines are quite simple to use:

  .. code-block:: pycon

      >>> r = redis.Redis(...)
      >>> r.set('bing', 'baz')
      >>> # Use the pipeline() method to create a pipeline instance
      >>> pipe = r.pipeline()
      >>> # The following SET commands are buffered
      >>> pipe.set('foo', 'bar')
      >>> pipe.get('bing')
      >>> # the EXECUTE call sends all buffered commands to the server, returning
      >>> # a list of responses, one for each command.
      >>> pipe.execute()
      [True, 'baz']

  For ease of use, all commands being buffered into the pipeline return the
  pipeline object itself. Therefore calls can be chained like:

  .. code-block:: pycon

      >>> pipe.set('foo', 'bar').sadd('faz', 'baz').incr('auto_number').execute()
      [True, True, 6]

  In addition, pipelines can also ensure the buffered commands are executed
  atomically as a group. This happens by default. If you want to disable the
  atomic nature of a pipeline but still want to buffer commands, you can turn
  off transactions.

  .. code-block:: pycon

      >>> pipe = r.pipeline(transaction=False)

  A common issue occurs when requiring atomic transactions but needing to
  retrieve values in Redis prior for use within the transaction. For instance,
  let's assume that the INCR command didn't exist and we need to build an atomic
  version of INCR in Python.

  The completely naive implementation could GET the value, increment it in
  Python, and SET the new value back. However, this is not atomic because
  multiple clients could be doing this at the same time, each getting the same
  value from GET.

  Enter the WATCH command. WATCH provides the ability to monitor one or more keys
  prior to starting a transaction. If any of those keys change prior the
  execution of that transaction, the entire transaction will be canceled and a
  WatchError will be raised. To implement our own client-side INCR command, we
  could do something like this:

  .. code-block:: pycon

      >>> with r.pipeline() as pipe:
      ...     while True:
      ...         try:
      ...             # put a WATCH on the key that holds our sequence value
      ...             pipe.watch('OUR-SEQUENCE-KEY')
      ...             # after WATCHing, the pipeline is put into immediate execution
      ...             # mode until we tell it to start buffering commands again.
      ...             # this allows us to get the current value of our sequence
      ...             current_value = pipe.get('OUR-SEQUENCE-KEY')
      ...             next_value = int(current_value) + 1
      ...             # now we can put the pipeline back into buffered mode with MULTI
      ...             pipe.multi()
      ...             pipe.set('OUR-SEQUENCE-KEY', next_value)
      ...             # and finally, execute the pipeline (the set command)
      ...             pipe.execute()
      ...             # if a WatchError wasn't raised during execution, everything
      ...             # we just did happened atomically.
      ...             break
      ...        except WatchError:
      ...             # another client must have changed 'OUR-SEQUENCE-KEY' between
      ...             # the time we started WATCHing it and the pipeline's execution.
      ...             # our best bet is to just retry.
      ...             continue

  Note that, because the Pipeline must bind to a single connection for the
  duration of a WATCH, care must be taken to ensure that the connection is
  returned to the connection pool by calling the reset() method. If the
  Pipeline is used as a context manager (as in the example above) reset()
  will be called automatically. Of course you can do this the manual way by
  explicitly calling reset():

  .. code-block:: pycon

      >>> pipe = r.pipeline()
      >>> while True:
      ...     try:
      ...         pipe.watch('OUR-SEQUENCE-KEY')
      ...         ...
      ...         pipe.execute()
      ...         break
      ...     except WatchError:
      ...         continue
      ...     finally:
      ...         pipe.reset()

  A convenience method named "transaction" exists for handling all the
  boilerplate of handling and retrying watch errors. It takes a callable that
  should expect a single parameter, a pipeline object, and any number of keys to
  be WATCHed. Our client-side INCR command above can be written like this,
  which is much easier to read:

  .. code-block:: pycon

      >>> def client_side_incr(pipe):
      ...     current_value = pipe.get('OUR-SEQUENCE-KEY')
      ...     next_value = int(current_value) + 1
      ...     pipe.multi()
      ...     pipe.set('OUR-SEQUENCE-KEY', next_value)
      >>>
      >>> r.transaction(client_side_incr, 'OUR-SEQUENCE-KEY')
      [True]

  Publish / Subscribe
  ^^^^^^^^^^^^^^^^^^^

  redis-py includes a `PubSub` object that subscribes to channels and listens
  for new messages. Creating a `PubSub` object is easy.

  .. code-block:: pycon

      >>> r = redis.Redis(...)
      >>> p = r.pubsub()

  Once a `PubSub` instance is created, channels and patterns can be subscribed
  to.

  .. code-block:: pycon

      >>> p.subscribe('my-first-channel', 'my-second-channel', ...)
      >>> p.psubscribe('my-*', ...)

  The `PubSub` instance is now subscribed to those channels/patterns. The
  subscription confirmations can be seen by reading messages from the `PubSub`
  instance.

  .. code-block:: pycon

      >>> p.get_message()
      {'pattern': None, 'type': 'subscribe', 'channel': 'my-second-channel', 'data': 1L}
      >>> p.get_message()
      {'pattern': None, 'type': 'subscribe', 'channel': 'my-first-channel', 'data': 2L}
      >>> p.get_message()
      {'pattern': None, 'type': 'psubscribe', 'channel': 'my-*', 'data': 3L}

  Every message read from a `PubSub` instance will be a dictionary with the
  following keys.

  * **type**: One of the following: 'subscribe', 'unsubscribe', 'psubscribe',
    'punsubscribe', 'message', 'pmessage'
  * **channel**: The channel [un]subscribed to or the channel a message was
    published to
  * **pattern**: The pattern that matched a published message's channel. Will be
    `None` in all cases except for 'pmessage' types.
  * **data**: The message data. With [un]subscribe messages, this value will be
    the number of channels and patterns the connection is currently subscribed
    to. With [p]message messages, this value will be the actual published
    message.

  Let's send a message now.

  .. code-block:: pycon

      
      
      
      
      >>> r.publish('my-first-channel', 'some data')
      2
      >>> p.get_message()
      {'channel': 'my-first-channel', 'data': 'some data', 'pattern': None, 'type': 'message'}
      >>> p.get_message()
      {'channel': 'my-first-channel', 'data': 'some data', 'pattern': 'my-*', 'type': 'pmessage'}

  Unsubscribing works just like subscribing. If no arguments are passed to
  [p]unsubscribe, all channels or patterns will be unsubscribed from.

  .. code-block:: pycon

      >>> p.unsubscribe()
      >>> p.punsubscribe('my-*')
      >>> p.get_message()
      {'channel': 'my-second-channel', 'data': 2L, 'pattern': None, 'type': 'unsubscribe'}
      >>> p.get_message()
      {'channel': 'my-first-channel', 'data': 1L, 'pattern': None, 'type': 'unsubscribe'}
      >>> p.get_message()
      {'channel': 'my-*', 'data': 0L, 'pattern': None, 'type': 'punsubscribe'}

  redis-py also allows you to register callback functions to handle published
  messages. Message handlers take a single argument, the message, which is a
  dictionary just like the examples above. To subscribe to a channel or pattern
  with a message handler, pass the channel or pattern name as a keyword argument
  with its value being the callback function.

  When a message is read on a channel or pattern with a message handler, the
  message dictionary is created and passed to the message handler. In this case,
  a `None` value is returned from get_message() since the message was already
  handled.

  .. code-block:: pycon

      >>> def my_handler(message):
      ...     print 'MY HANDLER: ', message['data']
      >>> p.subscribe(**{'my-channel': my_handler})
      
      >>> p.get_message()
      {'pattern': None, 'type': 'subscribe', 'channel': 'my-channel', 'data': 1L}
      >>> r.publish('my-channel', 'awesome data')
      1
      
      
      
      >>> message = p.get_message()
      MY HANDLER:  awesome data
      
      
      >>> print message
      None

  If your application is not interested in the (sometimes noisy)
  subscribe/unsubscribe confirmation messages, you can ignore them by passing
  `ignore_subscribe_messages=True` to `r.pubsub()`. This will cause all
  subscribe/unsubscribe messages to be read, but they won't bubble up to your
  application.

  .. code-block:: pycon

      >>> p = r.pubsub(ignore_subscribe_messages=True)
      >>> p.subscribe('my-channel')
      >>> p.get_message()  # hides the subscribe message and returns None
      >>> r.publish('my-channel', 'my data')
      1
      >>> p.get_message()
      {'channel': 'my-channel', 'data': 'my data', 'pattern': None, 'type': 'message'}

  There are three different strategies for reading messages.

  The examples above have been using `pubsub.get_message()`. Behind the scenes,
  `get_message()` uses the system's 'select' module to quickly poll the
  connection's socket. If there's data available to be read, `get_message()` will
  read it, format the message and return it or pass it to a message handler. If
  there's no data to be read, `get_message()` will immediately return None. This
  makes it trivial to integrate into an existing event loop inside your
  application.

  .. code-block:: pycon

      >>> while True:
      >>>     message = p.get_message()
      >>>     if message:
      >>>         # do something with the message
      >>>     time.sleep(0.001)  # be nice to the system :)

  Older versions of redis-py only read messages with `pubsub.listen()`. listen()
  is a generator that blocks until a message is available. If your application
  doesn't need to do anything else but receive and act on messages received from
  redis, listen() is an easy way to get up an running.

  .. code-block:: pycon

      >>> for message in p.listen():
      ...     # do something with the message

  The third option runs an event loop in a separate thread.
  `pubsub.run_in_thread()` creates a new thread and starts the event loop. The
  thread object is returned to the caller of `run_in_thread()`. The caller can
  use the `thread.stop()` method to shut down the event loop and thread. Behind
  the scenes, this is simply a wrapper around `get_message()` that runs in a
  separate thread, essentially creating a tiny non-blocking event loop for you.
  `run_in_thread()` takes an optional `sleep_time` argument. If specified, the
  event loop will call `time.sleep()` with the value in each iteration of the
  loop.

  Note: Since we're running in a separate thread, there's no way to handle
  messages that aren't automatically handled with registered message handlers.
  Therefore, redis-py prevents you from calling `run_in_thread()` if you're
  subscribed to patterns or channels that don't have message handlers attached.

  .. code-block:: pycon

      >>> p.subscribe(**{'my-channel': my_handler})
      >>> thread = p.run_in_thread(sleep_time=0.001)
      
      
      >>> thread.stop()

  A PubSub object adheres to the same encoding semantics as the client instance
  it was created from. Any channel or pattern that's unicode will be encoded
  using the `charset` specified on the client before being sent to Redis. If the
  client's `decode_responses` flag is set the False (the default), the
  'channel', 'pattern' and 'data' values in message dictionaries will be byte
  strings (str on Python 2, bytes on Python 3). If the client's
  `decode_responses` is True, then the 'channel', 'pattern' and 'data' values
  will be automatically decoded to unicode strings using the client's `charset`.

  PubSub objects remember what channels and patterns they are subscribed to. In
  the event of a disconnection such as a network error or timeout, the
  PubSub object will re-subscribe to all prior channels and patterns when
  reconnecting. Messages that were published while the client was disconnected
  cannot be delivered. When you're finished with a PubSub object, call its
  `.close()` method to shutdown the connection.

  .. code-block:: pycon

      >>> p = r.pubsub()
      >>> ...
      >>> p.close()


  The PUBSUB set of subcommands CHANNELS, NUMSUB and NUMPAT are also
  supported:

  .. code-block:: pycon

      >>> r.pubsub_channels()
      ['foo', 'bar']
      >>> r.pubsub_numsub('foo', 'bar')
      [('foo', 9001), ('bar', 42)]
      >>> r.pubsub_numsub('baz')
      [('baz', 0)]
      >>> r.pubsub_numpat()
      1204

  Monitor
  ^^^^^^^
  redis-py includes a `Monitor` object that streams every command processed
  by the Redis server. Use `listen()` on the `Monitor` object to block
  until a command is received.

  .. code-block:: pycon

      >>> r = redis.Redis(...)
      >>> with r.monitor() as m:
      >>>     for command in m.listen():
      >>>         print(command)

  Lua Scripting
  ^^^^^^^^^^^^^

  redis-py supports the EVAL, EVALSHA, and SCRIPT commands. However, there are
  a number of edge cases that make these commands tedious to use in real world
  scenarios. Therefore, redis-py exposes a Script object that makes scripting
  much easier to use.

  To create a Script instance, use the `register_script` function on a client
  instance passing the Lua code as the first argument. `register_script` returns
  a Script instance that you can use throughout your code.

  The following trivial Lua script accepts two parameters: the name of a key and
  a multiplier value. The script fetches the value stored in the key, multiplies
  it with the multiplier value and returns the result.

  .. code-block:: pycon

      >>> r = redis.Redis()
      >>> lua = """
      ... local value = redis.call('GET', KEYS[1])
      ... value = tonumber(value)
      ... return value * ARGV[1]"""
      >>> multiply = r.register_script(lua)

  `multiply` is now a Script instance that is invoked by calling it like a
  function. Script instances accept the following optional arguments:

  * **keys**: A list of key names that the script will access. This becomes the
    KEYS list in Lua.
  * **args**: A list of argument values. This becomes the ARGV list in Lua.
  * **client**: A redis-py Client or Pipeline instance that will invoke the
    script. If client isn't specified, the client that initially
    created the Script instance (the one that `register_script` was
    invoked from) will be used.

  Continuing the example from above:

  .. code-block:: pycon

      >>> r.set('foo', 2)
      >>> multiply(keys=['foo'], args=[5])
      10

  The value of key 'foo' is set to 2. When multiply is invoked, the 'foo' key is
  passed to the script along with the multiplier value of 5. Lua executes the
  script and returns the result, 10.

  Script instances can be executed using a different client instance, even one
  that points to a completely different Redis server.

  .. code-block:: pycon

      >>> r2 = redis.Redis('redis2.example.com')
      >>> r2.set('foo', 3)
      >>> multiply(keys=['foo'], args=[5], client=r2)
      15

  The Script object ensures that the Lua script is loaded into Redis's script
  cache. In the event of a NOSCRIPT error, it will load the script and retry
  executing it.

  Script objects can also be used in pipelines. The pipeline instance should be
  passed as the client argument when calling the script. Care is taken to ensure
  that the script is registered in Redis's script cache just prior to pipeline
  execution.

  .. code-block:: pycon

      >>> pipe = r.pipeline()
      >>> pipe.set('foo', 5)
      >>> multiply(keys=['foo'], args=[5], client=pipe)
      >>> pipe.execute()
      [True, 25]

  Sentinel support
  ^^^^^^^^^^^^^^^^

  redis-py can be used together with `Redis Sentinel <https://redis.io/topics/sentinel>`_
  to discover Redis nodes. You need to have at least one Sentinel daemon running
  in order to use redis-py's Sentinel support.

  Connecting redis-py to the Sentinel instance(s) is easy. You can use a
  Sentinel connection to discover the master and slaves network addresses:

  .. code-block:: pycon

      >>> from redis.sentinel import Sentinel
      >>> sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
      >>> sentinel.discover_master('mymaster')
      ('127.0.0.1', 6379)
      >>> sentinel.discover_slaves('mymaster')
      [('127.0.0.1', 6380)]

  You can also create Redis client connections from a Sentinel instance. You can
  connect to either the master (for write operations) or a slave (for read-only
  operations).

  .. code-block:: pycon

      >>> master = sentinel.master_for('mymaster', socket_timeout=0.1)
      >>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
      >>> master.set('foo', 'bar')
      >>> slave.get('foo')
      'bar'

  The master and slave objects are normal Redis instances with their
  connection pool bound to the Sentinel instance. When a Sentinel backed client
  attempts to establish a connection, it first queries the Sentinel servers to
  determine an appropriate host to connect to. If no server is found,
  a MasterNotFoundError or SlaveNotFoundError is raised. Both exceptions are
  subclasses of ConnectionError.

  When trying to connect to a slave client, the Sentinel connection pool will
  iterate over the list of slaves until it finds one that can be connected to.
  If no slaves can be connected to, a connection will be established with the
  master.

  See `Guidelines for Redis clients with support for Redis Sentinel
  <https://redis.io/topics/sentinel-clients>`_ to learn more about Redis Sentinel.

  Scan Iterators
  ^^^^^^^^^^^^^^

  The \*SCAN commands introduced in Redis 2.8 can be cumbersome to use. While
  these commands are fully supported, redis-py also exposes the following methods
  that return Python iterators for convenience: `scan_iter`, `hscan_iter`,
  `sscan_iter` and `zscan_iter`.

  .. code-block:: pycon

      >>> for key, value in (('A', '1'), ('B', '2'), ('C', '3')):
      ...     r.set(key, value)
      >>> for key in r.scan_iter():
      ...     print key, r.get(key)
      A 1
      B 2
      C 3

  Author
  ^^^^^^

  redis-py is developed and maintained by Andy McCurdy (sedrik@gmail.com).
  It can be found here: https://github.com/andymccurdy/redis-py

  Special thanks to:

  * Ludovico Magnocavallo, author of the original Python Redis client, from
    which some of the socket code is still used.
  * Alexander Solovyov for ideas on the generic response callback system.
  * Paul Hubbard for initial packaging support.


