# packages

pkgId: 44c9f72b34c2f689b48290bcd35ae4b92312cdf2e9751c3dfd53848850ad70f5
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: 6ff4a41ce4c94acdae8054df6d61ccce
rpm_sourcerpm: rh-python36-mistune-0.8.4-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879056-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: dde191b952f6d103e51ff53ed9da34509eea671130c58391adad0ab5718d961d
name: rh-python36-mod_wsgi
arch: ppc64le
version: 4.5.18
epoch: 0
release: 1.el7
summary: A WSGI interface for Python web applications in Apache
url: https://modwsgi.readthedocs.io/
rpm_license: ASL 2.0
rpm_group: System Environment/Libraries
rpm_buildhost: 1e781d7e38764e8892c415a5fb782e57
rpm_sourcerpm: rh-python36-mod_wsgi-4.5.18-1.el7.src.rpm
location_href: 00879575-rh-python36-mod_wsgi/rh-python36-mod_wsgi-4.5.18-1.el7.ppc64le.rpm
checksum_type: sha256
description:
  The mod_wsgi adapter is an Apache module that provides a WSGI compliant
  interface for hosting Python based web applications within Apache. The
  adapter is written completely in C code against the Apache C runtime and
  for hosting WSGI applications within Apache has a lower overhead than using
  existing WSGI adapters for mod_python or CGI.


pkgId: fb4023601dff67c5d5468ceec64ebd1e79946fdac6a01657bab1ec95ef81381b
name: rh-python36-mod_wsgi-debuginfo
arch: ppc64le
version: 4.5.18
epoch: 0
release: 1.el7
summary: Debug information for package rh-python36-mod_wsgi
url: https://modwsgi.readthedocs.io/
rpm_license: ASL 2.0
rpm_group: Development/Debug
rpm_buildhost: 1e781d7e38764e8892c415a5fb782e57
rpm_sourcerpm: rh-python36-mod_wsgi-4.5.18-1.el7.src.rpm
location_href: 00879575-rh-python36-mod_wsgi/rh-python36-mod_wsgi-debuginfo-4.5.18-1.el7.ppc64le.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-mod_wsgi.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 43d864fb3893e961ddb6eb73ed00a2dbd892411d437e94274ac83975e597e3fe
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: 1ace2249ed5a4c4590762930fabc8bdc
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: c0ffde7c2182484456ee8b7902da6925ed5d1a926a01e04a11666f404ff53205
name: rh-python36-more-itertools
arch: noarch
version: 8.1.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: b74ee31f90ed436bbf6b68976a09349c
rpm_sourcerpm: rh-python36-more-itertools-8.1.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143889-rh-python36-more-itertools/rh-python36-more-itertools-8.1.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: 58b683b49827ed04d83aff1fa67e92243d8d1edf648fad9dba8bb9094315e5e0
name: rh-python36-msgpack-python-debuginfo
arch: ppc64le
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: bac6de7cea6b4f22aa7470c3a94d8b75
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.ppc64le.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: ae023035b34e62be5edc3c07e7c172269488ef0d692a343c130cddaa240cefb9
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: bff739d2eba6403791ba5cbf44a67527
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: 85da53416b055131cde2e700bbfae000431c8c2dc396aa36a4c99ad0ebe73bca
name: rh-python36-msrestazure
arch: noarch
version: 0.6.2
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: 54cf8110e49b41fea49e891cae53a542
rpm_sourcerpm: rh-python36-msrestazure-0.6.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01034236-rh-python36-msrestazure/rh-python36-msrestazure-0.6.2-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: 355ce9184062491fb93234d5b1bf3d80c055354df8042ce73d186860761a02cd
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: 565136f25e024d16bf0c5441c6459066
rpm_sourcerpm: rh-python36-ncclient-0.6.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879063-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: 40cd2f1520e980ddff4a5e21302bec61ac2f8c16246da5a8c57e6f2aaf91018a
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: c4274c3c7a7145e19f6c1b04767d5138
rpm_sourcerpm: rh-python36-netaddr-0.7.19-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879064-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: 7c00f68ccc6c2739c86b2d8e58276b0862ed2812373ba8e0cb7915044e2ee1c2
name: rh-python36-netifaces
arch: ppc64le
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: c0bf2603b3b94020b464df136a2d2338
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-0.10.9-1.ppc64le.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: 5a28b3f56e76799ac3095901edcb828115315f63dbc227b83e3509a8f16d63ff
name: rh-python36-netifaces-debuginfo
arch: ppc64le
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: c0bf2603b3b94020b464df136a2d2338
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.ppc64le.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: 81804c8a762c0bfd17992ffe607903ddc2b21facc6660491f87a2759085d320b
name: rh-python36-numpy
arch: ppc64le
version: 1.13.1
epoch: 1
release: 1.el7
summary: A fast multidimensional array facility for Python
url: http://www.numpy.org/
rpm_license: BSD and Python
rpm_group: Development/Languages
rpm_buildhost: 69fcfc6a23e64061a2e5be479acb8b9a
rpm_sourcerpm: rh-python36-numpy-1.13.1-1.el7.src.rpm
location_href: 00879527-rh-python36-numpy/rh-python36-numpy-1.13.1-1.el7.ppc64le.rpm
checksum_type: sha256
description:
  NumPy is a general-purpose array-processing package designed to
  efficiently manipulate large multi-dimensional arrays of arbitrary
  records without sacrificing too much speed for small multi-dimensional
  arrays.  NumPy is built on the Numeric code base and adds features
  introduced by numarray as well as an extended C-API and the ability to
  create arrays of arbitrary type.

  There are also basic facilities for discrete fourier transform,
  basic linear algebra and random number generation. Also included in
  this package is a version of f2py that works properly with NumPy.


pkgId: b1470672c3a237e804fc902c9e73d71fe8f5472d12fcea7eb87f3fcf272fb157
name: rh-python36-numpy-debuginfo
arch: ppc64le
version: 1.13.1
epoch: 1
release: 1.el7
summary: Debug information for package rh-python36-numpy
url: http://www.numpy.org/
rpm_license: BSD and Python
rpm_group: Development/Debug
rpm_buildhost: 69fcfc6a23e64061a2e5be479acb8b9a
rpm_sourcerpm: rh-python36-numpy-1.13.1-1.el7.src.rpm
location_href: 00879527-rh-python36-numpy/rh-python36-numpy-debuginfo-1.13.1-1.el7.ppc64le.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-numpy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 0c5f888d98e0b1080a62e6bc102b8e23c02a915191fd5bebeb593f3c8633b3d8
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: b4e0940fdec844279a5657f457820cb2
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: f5621636ed03d689e80827227bbf1bbb951450b9f83f3923ebde62f0e6e62417
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: 6c475337a3ea491d9f2b4e7da88ecd3c
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: 5c50a86a81f22e080ebb0f0275fe7c106cb3d2d214ed851d369843b20a350907
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: cf65be467baf49de9841c44c0498ae37
rpm_sourcerpm: rh-python36-os-client-config-1.29.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879529-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: c4d174107d12a2503b1a465d10134caf3fc08bfb96be1ea041858bd12a9521e1
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: 8319d13a2cd643a59b3f47947e200887
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: 90c252d7025de65467e22946b253402f87e8b05077a0abe726184580c0e02207
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: 1eace306f1f24347af8a6a9fa10beb55
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: ab80c90eefe52a6cf259b0e2fa8992718af7ec460a246404fc07acdf3e82c67d
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: 64be3fe4bf594bff8e8cbfa261d44ea7
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: 8249eadc947fec8c5ba02b31457186379e1afd6e730c47e2ae23ac7c426a0614
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: 87f8668913ea4b109d6954db498d0c45
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: 3928a4e8d2a6d620f584ff6335981fd7be30c68e3922fd6ddfd33fa5d3254dba
name: rh-python36-ovirt-engine-sdk-python
arch: ppc64le
version: 4.3.0
epoch: 0
release: 1
summary: Python SDK for oVirt Engine API
rpm_license: ASL2
rpm_group: Development/Libraries
rpm_buildhost: 8a976676b9084fcd9af05d3b7538d4c8
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:
  = 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>

location_href:
  00944378-rh-python36-ovirt-engine-sdk-python/rh-python36-ovirt-engine-sdk-python-4.3.0-1.ppc64le.rpm


pkgId: aa44475324829cbf590ef2de91c8885ee6314459ff8b061eba0f8f72d61cdeac
name: rh-python36-ovirt-engine-sdk-python-debuginfo
arch: ppc64le
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: 8a976676b9084fcd9af05d3b7538d4c8
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.ppc64le.rpm


pkgId: 18c426d436de455ab7f4bccdf893ba671d4821ae31691f09caa532b6ec8be346
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: 834055f6cccc40d9b7b666161b544430
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: 9f3a799eff1d6fad37b601634f024430cdb3f713f4990e40636c8caf5d4baf49
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: 1d3071ed61c840ddb65ae96af2e0f3e5
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: ae260e599c00262a2ce8fab33966ec72df62bd0dda7a4bab4c4e4e08079db739
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: 5eb5e9bb686d462f94933d3afc68ed66
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: 8518f588e09340db952de76359ad1210e6d3c228673fa1b1e2d89a5c3922c8a1
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: e259440c74924888866994511acb2368
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: 1b6e10a58ce83afdfbf9ed84a5ed6ccb0904e6c0f66c6c117eb408d7b2f07417
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: 1df3110cfc9141f6a70631ac813aeb8a
rpm_sourcerpm: rh-python36-pkgconfig-1.4.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879077-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: ec9f74c268ee7a1b37e9154e5cfbc6203bddb0d03f3f32fee085ec988d0700d0
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: cd098b8636a344908b2c0a1983557bd6
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: 8dd4ed7cf674163544f97cfbad3df82085c6fcd786ec22f0cd74e1b88eb863b3
name: rh-python36-psutil
arch: ppc64le
version: 5.6.7
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: 4df8b6165c214d179b3dcfb98ca21bf5
rpm_sourcerpm: rh-python36-psutil-5.6.7-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143816-rh-python36-psutil/rh-python36-psutil-5.6.7-1.ppc64le.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: efcfffa3877813accdd0e1c5a77ffdd66178a9bc254b5bcbb02b6679bf8e2d34
name: rh-python36-psutil-debuginfo
arch: ppc64le
version: 5.6.7
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: 4df8b6165c214d179b3dcfb98ca21bf5
rpm_sourcerpm: rh-python36-psutil-5.6.7-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143816-rh-python36-psutil/rh-python36-psutil-debuginfo-5.6.7-1.ppc64le.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: fdd9cb9215f74a90df5c12f77bed198bd901bce30d26d5ff449745ac44dc878d
name: rh-python36-psycopg2
arch: ppc64le
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: 56507eef3cd04527964f3b5efe5cab0c
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-2.8.4-1.ppc64le.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: a834a0fe0124a5e38285ef2a34d02be7aff01bf2887818c92938de1bd84b4d50
name: rh-python36-psycopg2-debuginfo
arch: ppc64le
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: 56507eef3cd04527964f3b5efe5cab0c
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.ppc64le.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: bf911b375ece9046df72056e6b89f4755dd8caf0b39fc59c1f7868070050b83b
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: 623ce1a0bc6f4d0b891b21dc045740d9
rpm_sourcerpm: rh-python36-pyOpenSSL-19.0.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879542-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: 6454d5834ad2767d7b1d3a92320e4d644be074bc0b9bd4147cd7b36fc7aa7ca0
name: rh-python36-pyasn1-modules
arch: noarch
version: 0.2.7
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: 90143f9995694cd79a71e4d82d92764a
rpm_sourcerpm: rh-python36-pyasn1-modules-0.2.7-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143818-rh-python36-pyasn1-modules/rh-python36-pyasn1-modules-0.2.7-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: 09b0caf61465cc16de8553241ff80f1670d2eb4f05757b0cb265b956ba308d8b
name: rh-python36-pycparser
arch: noarch
version: 2.19
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: a1efa195c54b4c938f13231d40492b43
rpm_sourcerpm: rh-python36-pycparser-2.19-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879083-rh-python36-pycparser/rh-python36-pycparser-2.19-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: 5823f946ccd09540113df177ee570b6ec66034fe80a72dcfed2d16dcd7a9a33c
name: rh-python36-pycurl
arch: ppc64le
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: 9a76cdd5f539460ead47d8332d482bd7
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-7.43.0.3-1.ppc64le.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: 7f8e776bdf68f1caa294cef63a2d444784903b79cc951318586955d48f758d7f
name: rh-python36-pycurl-debuginfo
arch: ppc64le
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: 9a76cdd5f539460ead47d8332d482bd7
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.ppc64le.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: f47be49765a04b9a4b8209bd677afd0fce633fa73179cfd8116c99618f80a538
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: f6c4e3fcfce34645984ab7f763c3f5e7
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: be19c0fd0ff2f48a5ccdd26dca4351b2e12da7ce07f5ea46edbe4ce522ee0fd0
name: rh-python36-pykerberos
arch: ppc64le
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: 9d344b2b8d4f4e21876bd263d27291ae
rpm_sourcerpm: rh-python36-pykerberos-1.2.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879089-rh-python36-pykerberos/rh-python36-pykerberos-1.2.1-1.ppc64le.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: 0feb0aea7dc0a2338c6c8790f0c99b5a3f0129be84883c50efd28be0f0e70c08
name: rh-python36-pykerberos-debuginfo
arch: ppc64le
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: 9d344b2b8d4f4e21876bd263d27291ae
rpm_sourcerpm: rh-python36-pykerberos-1.2.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879089-rh-python36-pykerberos/rh-python36-pykerberos-debuginfo-1.2.1-1.ppc64le.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: e5911e13f6a7635b87664ffdd640aa6331052b1db2b759dbf48cc533355aa48a
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: 398577661dbd4d27baf812d46004ff88
rpm_sourcerpm: rh-python36-pyperclip-1.7.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887966-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: d04e07558661777137d4254916a7861a32aa70f860ed5092906405fe1d9894a0
name: rh-python36-pyrad
arch: noarch
version: 2.2
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: 9d697f6a0fdc4fa0a84b57a2079b1148
rpm_sourcerpm: rh-python36-pyrad-2.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143824-rh-python36-pyrad/rh-python36-pyrad-2.2-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: 737f59d71895faae4d9d57e82b91f045f4aa5eb131d7a4bf29f7e144a697338f
name: rh-python36-pyrsistent
arch: ppc64le
version: 0.15.6
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: f3b2d225e8b7436e93672d73907e741d
rpm_sourcerpm: rh-python36-pyrsistent-0.15.6-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143826-rh-python36-pyrsistent/rh-python36-pyrsistent-0.15.6-1.ppc64le.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: 58d3f6bfa6c80584bffa9a13d5eab84b2614804f358877c6513bb64bc00f6727
name: rh-python36-pyrsistent-debuginfo
arch: ppc64le
version: 0.15.6
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: f3b2d225e8b7436e93672d73907e741d
rpm_sourcerpm: rh-python36-pyrsistent-0.15.6-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143826-rh-python36-pyrsistent/rh-python36-pyrsistent-debuginfo-0.15.6-1.ppc64le.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: ac9a06beaebfe63fc63b7022b6a7ce76c5650cbe2881e97d9b89b34c1bb6961d
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: d4e51a9f8aae4d77b0ef3ac149a47c81
rpm_sourcerpm: rh-python36-pytest-runner-4.2-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879481-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: 73d2d240d65278a61d7804f4a2e5ddf517e5a962e37de95c13a243e74d44bb96
name: rh-python36-python
arch: ppc64le
version: 3.6.3
epoch: 0
release: 7.el7
summary: Version 3 of the Python programming language aka Python 3000
url: https://www.python.org/
rpm_license: Python
rpm_group: Development/Languages
rpm_buildhost: 102074725aa44422b1c8e1f3f9698490
rpm_sourcerpm: rh-python36-python-3.6.3-7.el7.src.rpm
location_href: 00904423-rh-python36-python/rh-python36-python-3.6.3-7.el7.ppc64le.rpm
checksum_type: sha256
description:
  Python 3 is a new version of the language that is incompatible with the 2.x
  line of releases. The language is mostly the same, but many details, especially
  how built-in objects like dictionaries and strings work, have changed
  considerably, and a lot of deprecated features have finally been removed.


pkgId: 3c25c60ed455d7ba7acb86c6e82fd3c7c5a2ece7bcfb28053ed6646e66ccc9dd
name: rh-python36-python-PyMySQL
arch: noarch
version: 0.7.11
epoch: 0
release: 1.el7
summary: Pure-Python MySQL client library
url: https://pypi.python.org/pypi/PyMySQL/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: 0762a37a9b2f4ca8b7c13c30104f10e7
rpm_sourcerpm: rh-python36-python-PyMySQL-0.7.11-1.el7.src.rpm
location_href: 00879245-rh-python36-python-PyMySQL/rh-python36-python-PyMySQL-0.7.11-1.el7.noarch.rpm
checksum_type: sha256
description:
  This package contains a pure-Python MySQL client library. The goal of PyMySQL
  is to be a drop-in replacement for MySQLdb and work on CPython, PyPy,
  IronPython and Jython.


pkgId: bb3217bdc3aaa9fd922efad47db87558a3c621107979b966a730199ba939b3df
name: rh-python36-python-bson
arch: ppc64le
version: 3.5.1
epoch: 0
release: 1.el7
summary: Python bson library
url: http://api.mongodb.org/python
rpm_license: ASL 2.0 and MIT
rpm_group: Development/Libraries
rpm_buildhost: 42caa6bdd01d4b17b3a468898140aa24
rpm_sourcerpm: rh-python36-python-pymongo-3.5.1-1.el7.src.rpm
location_href: 00879545-rh-python36-python-pymongo/rh-python36-python-bson-3.5.1-1.el7.ppc64le.rpm
checksum_type: sha256
description:
  BSON is a binary-encoded serialization of JSON-like documents. BSON is designed
  to be lightweight, traversable, and efficient. BSON, like JSON, supports the
  embedding of objects and arrays within other objects and arrays.


pkgId: e7ef2a3a41c5b9ecd418343441268f8b63d613855f738d670ce995c061af5546
name: rh-python36-python-coverage
arch: ppc64le
version: 4.4.1
epoch: 0
release: 2.el7
summary: Code coverage testing module for Python
url: https://nedbatchelder.com/code/modules/coverage.html
rpm_license: ASL 2.0 and MIT and (MIT or GPL)
rpm_group: System Environment/Libraries
rpm_buildhost: e64eb3b8c5b34ccdb716dd7b41f76622
rpm_sourcerpm: rh-python36-python-coverage-4.4.1-2.el7.src.rpm
location_href: 00879237-rh-python36-python-coverage/rh-python36-python-coverage-4.4.1-2.el7.ppc64le.rpm
checksum_type: sha256
description:
  Coverage.py is a Python module that measures code coverage during Python
  execution. It uses the code analysis tools and tracing hooks provided in the
  Python standard library to determine which lines are executable, and which
  have been executed.


pkgId: c1473f4c6033485c89970e5d9959eee8eeb53410fc3e51f06d7ec429ef9d7b3f
name: rh-python36-python-coverage-debuginfo
arch: ppc64le
version: 4.4.1
epoch: 0
release: 2.el7
summary: Debug information for package rh-python36-python-coverage
url: https://nedbatchelder.com/code/modules/coverage.html
rpm_license: ASL 2.0 and MIT and (MIT or GPL)
rpm_group: Development/Debug
rpm_buildhost: e64eb3b8c5b34ccdb716dd7b41f76622
rpm_sourcerpm: rh-python36-python-coverage-4.4.1-2.el7.src.rpm
location_href: 00879237-rh-python36-python-coverage/rh-python36-python-coverage-debuginfo-4.4.1-2.el7.ppc64le.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-python-coverage.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 2b736c3b67cbb09aa4e75b6d4977ba94b0dd6a4c3fdc8ddaf1011217149027c8
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: 2043474114e945e18c36ccbb3d84dd42
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: d6bb46eaf5d841f8d32352a4e38233a706ca1c674d1115713fd5dd611f0a5ecd
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: 79c3084526ef49198f861010a578a0f5
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: e499f7558126d32a00f635a36b4ba7fdcb17777ea6a971d4ec5ef3d4967c4acb
name: rh-python36-python-debug
arch: ppc64le
version: 3.6.3
epoch: 0
release: 7.el7
summary: Debug version of the Python 3 runtime
url: https://www.python.org/
rpm_license: Python
rpm_group: Applications/System
rpm_buildhost: 102074725aa44422b1c8e1f3f9698490
rpm_sourcerpm: rh-python36-python-3.6.3-7.el7.src.rpm
location_href: 00904423-rh-python36-python/rh-python36-python-debug-3.6.3-7.el7.ppc64le.rpm
checksum_type: sha256
description:
  python3-debug provides a version of the Python 3 runtime with numerous debugging
  features enabled, aimed at advanced Python users, such as developers of Python
  extension modules.

  This version uses more memory and will be slower than the regular Python 3 build,
  but is useful for tracking down reference-counting issues, and other bugs.

  The bytecodes are unchanged, so that .pyc files are compatible between the two
  versions of Python 3, but the debugging features mean that C/C++ extension
  modules are ABI-incompatible with those built for the standard runtime.

  It shares installation directories with the standard Python 3 runtime, so that
  .py and .pyc files can be shared.  All compiled extension modules gain a "_d"
  suffix ("foo_d.so" rather than "foo.so") so that each Python 3 implementation
  can load its own extensions.


pkgId: 8dc2e8c1030d2ce09a0ea3b116d318c2db29f34f856a16c1ccf61e9a50860551
name: rh-python36-python-debuginfo
arch: ppc64le
version: 3.6.3
epoch: 0
release: 7.el7
summary: Debug information for package rh-python36-python
url: https://www.python.org/
rpm_license: Python
rpm_group: Development/Debug
rpm_buildhost: 102074725aa44422b1c8e1f3f9698490
rpm_sourcerpm: rh-python36-python-3.6.3-7.el7.src.rpm
location_href: 00904423-rh-python36-python/rh-python36-python-debuginfo-3.6.3-7.el7.ppc64le.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-python.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 0f7a715d02974d0e0d306201ea4d48345b488a21e4c8d31aac4a51e31f4c1a08
name: rh-python36-python-devel
arch: ppc64le
version: 3.6.3
epoch: 0
release: 7.el7
summary: Libraries and header files needed for Python 3 development
url: https://www.python.org/
rpm_license: Python
rpm_group: Development/Libraries
rpm_buildhost: 102074725aa44422b1c8e1f3f9698490
rpm_sourcerpm: rh-python36-python-3.6.3-7.el7.src.rpm
location_href: 00904423-rh-python36-python/rh-python36-python-devel-3.6.3-7.el7.ppc64le.rpm
checksum_type: sha256
description:
  This package contains libraries and header files used to build applications
  with and native libraries for Python 3


pkgId: 5575336b9f7901bffff44b1d25abcbb0cd66ac3aaabb15094a9f764cc4f3963d
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: e5ee0c2b83324af992d02ee638922782
rpm_sourcerpm: rh-python36-python-django-oauth-toolkit-1.1.3-1.el7.src.rpm
checksum_type: sha256
location_href:
  00879101-rh-python36-python-django-oauth-toolkit/rh-python36-python-django-oauth-toolkit-1.1.3-1.el7.noarch.rpm


pkgId: 7bfd40a4ed0536634a2d4d9dcd030f33b7af0ac76fa22de6c0ea4ef1e245a27f
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: 2d36c2a57b5248458dcb8ceafac2d0c8
checksum_type: sha256
location_href:
  00879101-rh-python36-python-django-oauth-toolkit/rh-python36-python-django-oauth-toolkit-1.1.3-1.el7.src.rpm


pkgId: 1da6e09115447489ed7373f308b2cc6da070910e4f0f7e2c3fa43edcd96ccced
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: a2ac6894b9c14b0fa6822e2c5c6d0229
rpm_sourcerpm: rh-python36-python-django-solo-1.1.3-1.el7.src.rpm
location_href: 00879105-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: 137cc5129df75e8bab0965f5704f36f15150d9ee60fadfb82ba745d93089b4f9
name: rh-python36-python-docutils
arch: noarch
version: 0.14
epoch: 0
release: 1.el7
summary: System for processing plaintext documentation
url: http://docutils.sourceforge.net
rpm_license: Public Domain and BSD and Python and GPLv3+
rpm_group: Development/Languages
rpm_buildhost: 230b9b2e87794ce28d4ff8b18427cb0d
rpm_sourcerpm: rh-python36-python-docutils-0.14-1.el7.src.rpm
location_href: 00879487-rh-python36-python-docutils/rh-python36-python-docutils-0.14-1.el7.noarch.rpm
checksum_type: sha256
description:
  The Docutils project specifies a plaintext markup language, reStructuredText,
  which is easy to read and quick to write.  The project includes a python
  library to parse rST files and transform them into other useful formats such
  as HTML, XML, and TeX as well as commandline tools that give the enduser
  access to this functionality.

  Currently, the library supports parsing rST that is in standalone files and
  PEPs (Python Enhancement Proposals).  Work is underway to parse rST from
  Python inline documentation modules and packages.


pkgId: c7507bfbcb4b5f68bf1ad1a144bce6a12d948eef659055dda72416bebb504221
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: 60f1808b07b84336951de27e044f7190
rpm_sourcerpm: rh-python36-python-editor-1.0.4-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887967-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: 1c12557c0b049adc960c450b3b2a427b04feb0225b9f0bd349d6f2498f3c7276
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: 1c87a01b5af445a49243ac66df8cf392
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: b9653c3a1f5a23b54949b9711499bb933ac339d5ed2720e05c93101113db74c0
name: rh-python36-python-ldap
arch: ppc64le
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: cdefc565adac41cc866f27d239152592
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-3.2.0-1.ppc64le.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: e71841c73ad5091703a4808900b620067cc87ee265406d71a99e7e5186827b46
name: rh-python36-python-ldap-debuginfo
arch: ppc64le
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: cdefc565adac41cc866f27d239152592
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.ppc64le.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: 177b32f933046fdbc12c784f9eb049e0ca73e9367804a5de998272de0d39c98c
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: fe361b0508d144a3b6f678ccb9d21676
rpm_sourcerpm: rh-python36-python-logstash-0.4.6-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879109-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: ff046e618eabefa8e47b2b8612ec06f9d8296ba694397efa5949232e5023cdb0
name: rh-python36-python-markupsafe
arch: ppc64le
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: 663f11f5f8d84bfdba69b92b088f4098
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-1.1.1-1.ppc64le.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: 48a775382f69e6139d2843ec90645ff4b572de8721c1476dc6ece3f99d2b0fe6
name: rh-python36-python-markupsafe-debuginfo
arch: ppc64le
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: 663f11f5f8d84bfdba69b92b088f4098
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.ppc64le.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: b022ebfa4032d4ce8cc165812ea8416dcb1a1b89c3f37a65bee34136fef2ca37
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: bfbd7b72006d413da4159b3d51f922fb
rpm_sourcerpm: rh-python36-python-memcached-1.59-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879110-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: cae505b65e48a30fd56d333a018e618759ec2f5a676c0a9ee94435945e4eb7c5
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: 921d3a126a9d48b088d212798c7edd1b
rpm_sourcerpm: rh-python36-python-mimeparse-1.6.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00887954-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: e3d28dfc76f5faea33ceb27c640802fd472c8afb75073a666913ce3559d4ae08
name: rh-python36-python-nose
arch: noarch
version: 1.3.7
epoch: 0
release: 3.el7
summary: Discovery-based unittest extension for Python
url: http://somethingaboutorange.com/mrl/projects/nose/
rpm_license: LGPLv2+ and Public Domain
rpm_group: Development/Languages
rpm_buildhost: 2b9d73d26a1b42e6b435cf625eb400e2
rpm_sourcerpm: rh-python36-python-nose-1.3.7-3.el7.src.rpm
location_href: 00879465-rh-python36-python-nose/rh-python36-python-nose-1.3.7-3.el7.noarch.rpm
checksum_type: sha256
description:
  nose extends the test loading and running features of unittest, making
  it easier to write, find and run tests.

  By default, nose will run tests in files or directories under the
  current working directory whose names include "test" or "Test" at a
  word boundary (like "test_this" or "functional_test" or "TestClass"
  but not "libtest"). Test output is similar to that of unittest, but
  also includes captured stdout output from failing tests, for easy
  print-style debugging.

  These features, and many more, are customizable through the use of
  plugins. Plugins included with nose provide support for doctest, code
  coverage and profiling, flexible attribute-based test selection,
  output capture and more.


pkgId: 3f100e2f08a79f7611c01fdfa3ade638df28fe22c72aa18b0f694492b485246c
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: d577425e237142e0b6bc7832816acd4b
rpm_sourcerpm: rh-python36-python-ordereddict-1.1-1.el7.src.rpm
location_href: 00879111-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: b7b93b691d93a423b0a9fd21ffc0d50406d843fcd05119326c76b4c0e58d298c
name: rh-python36-python-pip
arch: noarch
version: 9.0.1
epoch: 0
release: 3.el7
summary: A tool for installing and managing Python packages
url: http://www.pip-installer.org
rpm_license: MIT
rpm_group: Development/Libraries
rpm_buildhost: fbf410ab9e514e1ba3a51bb3b1c72b08
rpm_sourcerpm: rh-python36-python-pip-9.0.1-3.el7.src.rpm
location_href: 00878445-rh-python36-python-pip/rh-python36-python-pip-9.0.1-3.el7.noarch.rpm
checksum_type: sha256
description:
  Pip is a replacement for `easy_install
  <http://peak.telecommunity.com/DevCenter/EasyInstall>`_.  It uses mostly the
  same techniques for finding packages, so packages that were made
  easy_installable should be pip-installable as well.


pkgId: 2f87451f6f9d6dea0c6682f2d8cab008f1dd6a1c8925d6534716edbf5d4bb954
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: bad8335b9f4f4401a4a988ebe98e9ef0
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: 0dd143c3a37c6fc299a6bd486962a24c5f21d2fc3a230a2599217b34b732135d
name: rh-python36-python-pymongo-debuginfo
arch: ppc64le
version: 3.5.1
epoch: 0
release: 1.el7
summary: Debug information for package rh-python36-python-pymongo
url: http://api.mongodb.org/python
rpm_license: ASL 2.0 and MIT
rpm_group: Development/Debug
rpm_buildhost: 42caa6bdd01d4b17b3a468898140aa24
rpm_sourcerpm: rh-python36-python-pymongo-3.5.1-1.el7.src.rpm
location_href: 00879545-rh-python36-python-pymongo/rh-python36-python-pymongo-debuginfo-3.5.1-1.el7.ppc64le.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-python-pymongo.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: b2b3ce6d78ed8488d37185017fe923590831ab0d55f636a119232397a28095d7
name: rh-python36-python-setuptools
arch: noarch
version: 36.5.0
epoch: 0
release: 2.el7
summary: Easily build and distribute Python packages
url: https://pypi.python.org/pypi/setuptools
rpm_license: Python or ZPLv2.0
rpm_group: Applications/System
rpm_buildhost: cf9856573b214777a10350567cdbf7d0
rpm_sourcerpm: rh-python36-python-setuptools-36.5.0-2.el7.src.rpm
location_href: 00878441-rh-python36-python-setuptools/rh-python36-python-setuptools-36.5.0-2.el7.noarch.rpm
checksum_type: sha256
description:
  Setuptools is a collection of enhancements to the Python distutils that allow
  you to more easily build and distribute Python packages, especially ones that
  have dependencies on other packages.

  This package contains the runtime components of setuptools, necessary to
  execute the software that requires pkg_resources.py.

  This package contains the distribute fork of setuptools.


pkgId: 62d3086f7bc4d7072744aebbf498e7c117a2f68ace6451e754fd8922d9554757
name: rh-python36-python-simplejson
arch: ppc64le
version: 3.13.2
epoch: 0
release: 1.el7
summary: Simple, fast, extensible JSON encoder/decoder for Python
url: http://github.com/simplejson/simplejson
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: 8e49630bc95e477d8d37a8976fde7271
rpm_sourcerpm: rh-python36-python-simplejson-3.13.2-1.el7.src.rpm
location_href: 00879113-rh-python36-python-simplejson/rh-python36-python-simplejson-3.13.2-1.el7.ppc64le.rpm
checksum_type: sha256
description:
  simplejson - simplejson is a simple, fast, complete, correct and extensible
  JSON <> encoder and decoder for Python 2.5+ and Python 3.3+. It is pure Python
  code with no dependencies, but includes an optional C extension for a serious
  speed boost.The latest documentation for simplejson can be read online here: is
  the externally maintained development version of the json library included
  with...


pkgId: 1ad63d8f6366115f5365ed02c5bd8e4a66416e80339adbe5a4c602611b03a788
name: rh-python36-python-simplejson-debuginfo
arch: ppc64le
version: 3.13.2
epoch: 0
release: 1.el7
summary: Debug information for package rh-python36-python-simplejson
url: http://github.com/simplejson/simplejson
rpm_license: MIT License
rpm_group: Development/Debug
rpm_buildhost: 8e49630bc95e477d8d37a8976fde7271
rpm_sourcerpm: rh-python36-python-simplejson-3.13.2-1.el7.src.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-python-simplejson.
  Debug information is useful when developing applications that use this
  package or when debugging this package.

location_href:
  00879113-rh-python36-python-simplejson/rh-python36-python-simplejson-debuginfo-3.13.2-1.el7.ppc64le.rpm


pkgId: 51624329e497791862b1a6fab931bbe9bd2e0a3bf6e6110306cf482b4a0f1448
name: rh-python36-python-sphinx
arch: noarch
version: 1.2.3
epoch: 0
release: 3.el7
summary: Python documentation generator
url: http://sphinx.pocoo.org/
rpm_license: BSD and Public Domain and Python and (MIT or GPLv2)
rpm_group: Development/Tools
rpm_buildhost: 154eec987a904c7b937847b41f62ee4d
rpm_sourcerpm: rh-python36-python-sphinx-1.2.3-3.el7.src.rpm
location_href: 00879467-rh-python36-python-sphinx/rh-python36-python-sphinx-1.2.3-3.el7.noarch.rpm
checksum_type: sha256
description:
  Sphinx is a tool that makes it easy to create intelligent and
  beautiful documentation for Python projects (or other documents
  consisting of multiple reStructuredText sources), written by Georg
  Brandl. It was originally created to translate the new Python
  documentation, but has now been cleaned up in the hope that it will be
  useful to many other projects.

  Sphinx uses reStructuredText as its markup language, and many of its
  strengths come from the power and straightforwardness of
  reStructuredText and its parsing and translating suite, the Docutils.

  Although it is still under constant development, the following
  features are already present, work fine and can be seen "in action" in
  the Python docs:

      * Output formats: HTML (including Windows HTML Help) and LaTeX,
        for printable PDF versions
      * Extensive cross-references: semantic markup and automatic links
        for functions, classes, glossary terms and similar pieces of
        information
      * Hierarchical structure: easy definition of a document tree, with
        automatic links to siblings, parents and children
      * Automatic indices: general index as well as a module index
      * Code handling: automatic highlighting using the Pygments highlighter
      * Various extensions are available, e.g. for automatic testing of
        snippets and inclusion of appropriately formatted docstrings.


pkgId: 43975826d73fc8fa6ca576d526a389978f889833ededf48517a842f18403d9a8
name: rh-python36-python-sphinx-doc
arch: noarch
version: 1.2.3
epoch: 0
release: 3.el7
summary: Documentation for python-sphinx
url: http://sphinx.pocoo.org/
rpm_license: BSD
rpm_group: Documentation
rpm_buildhost: 154eec987a904c7b937847b41f62ee4d
rpm_sourcerpm: rh-python36-python-sphinx-1.2.3-3.el7.src.rpm
location_href: 00879467-rh-python36-python-sphinx/rh-python36-python-sphinx-doc-1.2.3-3.el7.noarch.rpm
checksum_type: sha256
description:
  Sphinx is a tool that makes it easy to create intelligent and
  beautiful documentation for Python projects (or other documents
  consisting of multiple reStructuredText sources), written by Georg
  Brandl. It was originally created to translate the new Python
  documentation, but has now been cleaned up in the hope that it will be
  useful to many other projects.

  This package contains documentation in reST and HTML formats.


pkgId: 85c35890732dbd41971aafed34ba5e2eb1d927ef3ce07133c241fbf86c7ea2dc
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: ef7f1ca7200a4dcd9323d2b601b278d2
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: 98f9ee9464158748613924ec60c9ec9a20dde58b14704a4aad18fc504626f36f
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: bfaa21c49a7049e7bd5c3457f9510c53
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: 9f974954dc5f3fffa43ca7840939f9c21e62813d1095b9661aa1f86ba9537688
name: rh-python36-python-test
arch: ppc64le
version: 3.6.3
epoch: 0
release: 7.el7
summary: The test modules from the main python 3 package
url: https://www.python.org/
rpm_license: Python
rpm_group: Development/Languages
rpm_buildhost: 102074725aa44422b1c8e1f3f9698490
rpm_sourcerpm: rh-python36-python-3.6.3-7.el7.src.rpm
location_href: 00904423-rh-python36-python/rh-python36-python-test-3.6.3-7.el7.ppc64le.rpm
checksum_type: sha256
description:
  The test modules from the main rh-python36-python package.
  These are in a separate package to save space, as they are almost never used
  in production.

  You might want to install the python3-test package if you're developing
  python 3 code that uses more than just unittest and/or test_support.py.


pkgId: 72c9e2591f84a9921381c6c0df1f354ca80a2a5a527db8edabb2a1a4e565d701
name: rh-python36-python-tkinter
arch: ppc64le
version: 3.6.3
epoch: 0
release: 7.el7
summary: A GUI toolkit for Python 3
url: https://www.python.org/
rpm_license: Python
rpm_group: Development/Languages
rpm_buildhost: 102074725aa44422b1c8e1f3f9698490
rpm_sourcerpm: rh-python36-python-3.6.3-7.el7.src.rpm
location_href: 00904423-rh-python36-python/rh-python36-python-tkinter-3.6.3-7.el7.ppc64le.rpm
checksum_type: sha256
description:
  The Tkinter (Tk interface) program is an graphical user interface for
  the Python scripting language.


pkgId: 2f5193b69e8c78ef22a3887c4a252951277241229f5078755dcc213fe2385637
name: rh-python36-python-virtualenv
arch: noarch
version: 15.1.0
epoch: 0
release: 2.el7
summary: Tool to create isolated Python environments
url: https://pypi.python.org/pypi/virtualenv
rpm_license: MIT
rpm_group: Development/Languages
rpm_buildhost: 2ef1981abed34d76ba1d239853eebeac
rpm_sourcerpm: rh-python36-python-virtualenv-15.1.0-2.el7.src.rpm
location_href: 00879479-rh-python36-python-virtualenv/rh-python36-python-virtualenv-15.1.0-2.el7.noarch.rpm
checksum_type: sha256
description:
  virtualenv is a tool to create isolated Python environments. virtualenv
  is a successor to workingenv, and an extension of virtual-python. It is
  written by Ian Bicking, and sponsored by the Open Planning Project. It is
  licensed under an MIT-style permissive license.


pkgId: 601ee6a43db48b3883980ae5efcf5fa7cd575ce3f4fe5d7a32ac667c430e257b
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: 64ac51535fd346b9954da2bfcf218be1
rpm_sourcerpm: rh-python36-python3-openid-3.1.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879096-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: 3a255ce767f3858ccf79233df27111d5df68d7e57063ae6de589e28cbc41ad81
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: 091266faaee24e23a314d9c7944836a3
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: 49f4c3de6b77b9e64e8e28e9da51c8f230c3419fde5085294a79fb1ab022d51a
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: cfc5b08002be4d198062c69142cb2cbb
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: 1658d60159573a19c8eac296f31dd06e768688f17481d7b29a789e52e4a004e7
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: 7eb8244b4c0749c3b13cbb27b9d69a1d
rpm_sourcerpm: rh-python36-redbaron-0.6.3-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879120-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: 6af160e2b3ed9bbe6d435cb86118584b9cbbc05a111ff7d42ad2f4096696b92c
name: rh-python36-requests
arch: noarch
version: 2.23.0
epoch: 0
release: 1
summary: Python HTTP for Humans.
url: http://python-requests.org
rpm_license: Apache 2.0
rpm_vendor: Kenneth Reitz <me@kennethreitz.org>
rpm_group: Development/Libraries
rpm_buildhost: 4ef7d5a5d6b14a4c9f71f79c8ae3200e
rpm_sourcerpm: rh-python36-requests-2.23.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01245664-rh-python36-requests/rh-python36-requests-2.23.0-1.noarch.rpm
checksum_type: sha256
description:
  Requests: HTTP for Humans™
  ==========================

  [![image](https://img.shields.io/pypi/v/requests.svg)](https://pypi.org/project/requests/)
  [![image](https://img.shields.io/pypi/l/requests.svg)](https://pypi.org/project/requests/)
  [![image](https://img.shields.io/pypi/pyversions/requests.svg)](https://pypi.org/project/requests/)
  [![codecov.io](https://codecov.io/github/requests/requests/coverage.svg?branch=master)](https://codecov.io/github/requests/requests)
  [![image](https://img.shields.io/github/contributors/requests/requests.svg)](https://github.com/requests/requests/graphs/contributors)
  [![image](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/kennethreitz)

  **If you're interested in financially supporting Kenneth Reitz open source, consider [visiting this link](https://cash.me/$KennethReitz). Your support helps tremendously with sustainability of motivation, as Open Source is no longer part of my day job.**

  Requests is the only *Non-GMO* HTTP library for Python, safe for human
  consumption.

  ![image](https://farm5.staticflickr.com/4317/35198386374_1939af3de6_k_d.jpg)

  Behold, the power of Requests:

  ``` {.sourceCode .python}
  >>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
  >>> r.status_code
  200
  >>> r.headers['content-type']
  'application/json; charset=utf8'
  >>> r.encoding
  'utf-8'
  >>> r.text
  u'{"type":"User"...'
  >>> r.json()
  {u'disk_usage': 368627, u'private_gists': 484, ...}
  ```

  See [the similar code, sans Requests](https://gist.github.com/973705).

  [![image](https://raw.githubusercontent.com/requests/requests/master/docs/_static/requests-logo-small.png)](http://docs.python-requests.org/)

  Requests allows you to send *organic, grass-fed* HTTP/1.1 requests,
  without the need for manual labor. There's no need to manually add query
  strings to your URLs, or to form-encode your POST data. Keep-alive and
  HTTP connection pooling are 100% automatic, thanks to
  [urllib3](https://github.com/shazow/urllib3).

  Besides, all the cool kids are doing it. Requests is one of the most
  downloaded Python packages of all time, pulling in over 11,000,000
  downloads every month. You don't want to be left out!

  Feature Support
  ---------------

  Requests is ready for today's web.

  -   International Domains and URLs
  -   Keep-Alive & Connection Pooling
  -   Sessions with Cookie Persistence
  -   Browser-style SSL Verification
  -   Basic/Digest Authentication
  -   Elegant Key/Value Cookies
  -   Automatic Decompression
  -   Automatic Content Decoding
  -   Unicode Response Bodies
  -   Multipart File Uploads
  -   HTTP(S) Proxy Support
  -   Connection Timeouts
  -   Streaming Downloads
  -   `.netrc` Support
  -   Chunked Requests

  Requests officially supports Python 2.7 & 3.4–3.7, and runs great on
  PyPy.

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

  To install Requests, simply use [pipenv](http://pipenv.org/) (or pip, of
  course):

  ``` {.sourceCode .bash}
  $ pipenv install requests
  ✨🍰✨
  ```

  Satisfaction guaranteed.

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

  Fantastic documentation is available at
  <http://docs.python-requests.org/>, for a limited time only.

  How to Contribute
  -----------------

  1.  Check for open issues or open a fresh issue to start a discussion
      around a feature idea or a bug. There is a [Contributor
      Friendly](https://github.com/requests/requests/issues?direction=desc&labels=Contributor+Friendly&page=1&sort=updated&state=open)
      tag for issues that should be ideal for people who are not very
      familiar with the codebase yet.
  2.  Fork [the repository](https://github.com/requests/requests) on
      GitHub to start making your changes to the **master** branch (or
      branch off of it).
  3.  Write a test which shows that the bug was fixed or that the feature
      works as expected.
  4.  Send a pull request and bug the maintainer until it gets merged and
      published. :) Make sure to add yourself to
      [AUTHORS](https://github.com/requests/requests/blob/master/AUTHORS.rst).


pkgId: f79c2db8927847b4918085f95421ce324c7aee3dcc8662c13df7cab1426e2c81
name: rh-python36-requests-futures
arch: noarch
version: 0.9.7
epoch: 0
release: 1
summary: Asynchronous Python HTTP for Humans.
url: https://github.com/ross/requests-futures
rpm_license: Apache License v2
rpm_vendor: Ross McFarland <rwmcfa1@neces.com>
rpm_group: Development/Libraries
rpm_buildhost: e4ee4f8cace74798bef43f65afb2324f
rpm_sourcerpm: rh-python36-requests-futures-0.9.7-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879124-rh-python36-requests-futures/rh-python36-requests-futures-0.9.7-1.noarch.rpm
checksum_type: sha256
description:
  Asynchronous Python HTTP Requests for Humans
  ============================================

  .. image:: https://travis-ci.org/ross/requests-futures.png?branch=master
          :target: https://travis-ci.org/ross/requests-futures

  Small add-on for the python requests_ http library. Makes use of python 3.2's
  `concurrent.futures`_ or the backport_ for prior versions of python.

  The additional API and changes are minimal and strives to avoid surprises.

  The following synchronous code:

  .. code-block:: python

      from requests import Session

      session = Session()
      
      response_one = session.get('http://httpbin.org/get')
      
      response_two = session.get('http://httpbin.org/get?foo=bar')
      
      print('response one status: {0}'.format(response_one.status_code))
      print(response_one.content)
      print('response two status: {0}'.format(response_two.status_code))
      print(response_two.content)

  Can be translated to make use of futures, and thus be asynchronous by creating
  a FuturesSession and catching the returned Future in place of Response. The
  Response can be retrieved by calling the result method on the Future:

  .. code-block:: python

      from requests_futures.sessions import FuturesSession

      session = FuturesSession()
      
      future_one = session.get('http://httpbin.org/get')
      
      future_two = session.get('http://httpbin.org/get?foo=bar')
      
      response_one = future_one.result()
      print('response one status: {0}'.format(response_one.status_code))
      print(response_one.content)
      
      response_two = future_two.result()
      print('response two status: {0}'.format(response_two.status_code))
      print(response_two.content)

  By default a ThreadPoolExecutor is created with 2 workers. If you would like to
  adjust that value or share a executor across multiple sessions you can provide
  one to the FuturesSession constructor.

  .. code-block:: python

      from concurrent.futures import ThreadPoolExecutor
      from requests_futures.sessions import FuturesSession

      session = FuturesSession(executor=ThreadPoolExecutor(max_workers=10))
      

  As a shortcut in case of just increasing workers number you can pass
  `max_workers` straight to the `FuturesSession` constructor:

  .. code-block:: python

      from requests_futures.sessions import FuturesSession
      session = FuturesSession(max_workers=10)

  FutureSession will use an existing session object if supplied:

  .. code-block:: python

      from requests import session
      from requests_futures.sessions import FuturesSession
      my_session = session()
      future_session = FuturesSession(session=my_session)

  That's it. The api of requests.Session is preserved without any modifications
  beyond returning a Future rather than Response. As with all futures exceptions
  are shifted (thrown) to the future.result() call so try/except blocks should be
  moved there.

  Working in the Background
  =========================

  There is one additional parameter to the various request functions,
  background_callback, which allows you to work with the Response objects in the
  background thread. This can be useful for shifting work out of the foreground,
  for a simple example take json parsing.

  .. code-block:: python

      from pprint import pprint
      from requests_futures.sessions import FuturesSession

      session = FuturesSession()

      def bg_cb(sess, resp):
          
          resp.data = resp.json()

      future = session.get('http://httpbin.org/get', background_callback=bg_cb)
      
      response = future.result()
      print('response status {0}'.format(response.status_code))
      
      pprint(response.data)


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

      pip install requests-futures

  .. _`requests`: https://github.com/kennethreitz/requests
  .. _`concurrent.futures`: http://docs.python.org/dev/library/concurrent.futures.html
  .. _backport: https://pypi.python.org/pypi/futures


pkgId: f58a23c515843a15d26b490d77fe611ea7838267605ae7aa5c23ce2bec1f8ab8
name: rh-python36-requests-kerberos
arch: noarch
version: 0.12.0
epoch: 0
release: 1
summary: A Kerberos authentication handler for python-requests
url: https://github.com/requests/requests-kerberos
rpm_license: UNKNOWN
rpm_vendor: Ian Cordasco, Cory Benfield, Michael Komitee <graffatcolmingov@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 009af01099b84bef9f0c553fd7e6e777
rpm_sourcerpm: rh-python36-requests-kerberos-0.12.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879125-rh-python36-requests-kerberos/rh-python36-requests-kerberos-0.12.0-1.noarch.rpm
checksum_type: sha256
description:
  requests Kerberos/GSSAPI authentication library
  ===============================================

  .. image:: https://travis-ci.org/requests/requests-kerberos.svg?branch=master
      :target: https://travis-ci.org/requests/requests-kerberos

  .. image:: https://coveralls.io/repos/github/requests/requests-kerberos/badge.svg?branch=master
      :target: https://coveralls.io/github/requests/requests-kerberos?branch=master

  Requests is an HTTP library, written in Python, for human beings. This library
  adds optional Kerberos/GSSAPI authentication support and supports mutual
  authentication. Basic GET usage:


  .. code-block:: python

      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth
      >>> r = requests.get("http://example.org", auth=HTTPKerberosAuth())
      ...

  The entire ``requests.api`` should be supported.

  Authentication Failures
  -----------------------

  Client authentication failures will be communicated to the caller by returning
  the 401 response.

  Mutual Authentication
  ---------------------

  REQUIRED
  ^^^^^^^^

  By default, ``HTTPKerberosAuth`` will require mutual authentication from the
  server, and if a server emits a non-error response which cannot be
  authenticated, a ``requests_kerberos.errors.MutualAuthenticationError`` will
  be raised. If a server emits an error which cannot be authenticated, it will
  be returned to the user but with its contents and headers stripped. If the
  response content is more important than the need for mutual auth on errors,
  (eg, for certain WinRM calls) the stripping behavior can be suppressed by
  setting ``sanitize_mutual_error_response=False``:

  .. code-block:: python

      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth, REQUIRED
      >>> kerberos_auth = HTTPKerberosAuth(mutual_authentication=REQUIRED, sanitize_mutual_error_response=False)
      >>> r = requests.get("https://windows.example.org/wsman", auth=kerberos_auth)
      ...


  OPTIONAL
  ^^^^^^^^

  If you'd prefer to not require mutual authentication, you can set your
  preference when constructing your ``HTTPKerberosAuth`` object:

  .. code-block:: python

      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth, OPTIONAL
      >>> kerberos_auth = HTTPKerberosAuth(mutual_authentication=OPTIONAL)
      >>> r = requests.get("http://example.org", auth=kerberos_auth)
      ...

  This will cause ``requests_kerberos`` to attempt mutual authentication if the
  server advertises that it supports it, and cause a failure if authentication
  fails, but not if the server does not support it at all.

  DISABLED
  ^^^^^^^^

  While we don't recommend it, if you'd prefer to never attempt mutual
  authentication, you can do that as well:

  .. code-block:: python

      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth, DISABLED
      >>> kerberos_auth = HTTPKerberosAuth(mutual_authentication=DISABLED)
      >>> r = requests.get("http://example.org", auth=kerberos_auth)
      ...

  Preemptive Authentication
  -------------------------

  ``HTTPKerberosAuth`` can be forced to preemptively initiate the Kerberos
  GSS exchange and present a Kerberos ticket on the initial request (and all
  subsequent). By default, authentication only occurs after a
  ``401 Unauthorized`` response containing a Kerberos or Negotiate challenge
  is received from the origin server. This can cause mutual authentication
  failures for hosts that use a persistent connection (eg, Windows/WinRM), as
  no Kerberos challenges are sent after the initial auth handshake. This
  behavior can be altered by setting  ``force_preemptive=True``:

  .. code-block:: python

      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth, REQUIRED
      >>> kerberos_auth = HTTPKerberosAuth(mutual_authentication=REQUIRED, force_preemptive=True)
      >>> r = requests.get("https://windows.example.org/wsman", auth=kerberos_auth)
      ...

  Hostname Override
  -----------------

  If communicating with a host whose DNS name doesn't match its
  kerberos hostname (eg, behind a content switch or load balancer),
  the hostname used for the Kerberos GSS exchange can be overridden by
  setting the ``hostname_override`` arg:

  .. code-block:: python

      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth, REQUIRED
      >>> kerberos_auth = HTTPKerberosAuth(hostname_override="internalhost.local")
      >>> r = requests.get("https://externalhost.example.org/", auth=kerberos_auth)
      ...

  Explicit Principal
  ------------------

  ``HTTPKerberosAuth`` normally uses the default principal (ie, the user for
  whom you last ran ``kinit`` or ``kswitch``, or an SSO credential if
  applicable). However, an explicit principal can be specified, which will
  cause Kerberos to look for a matching credential cache for the named user.
  This feature depends on OS support for collection-type credential caches,
  as well as working principal support in PyKerberos (it is broken in many
  builds). An explicit principal can be specified with the ``principal`` arg:

  .. code-block:: python

      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth, REQUIRED
      >>> kerberos_auth = HTTPKerberosAuth(principal="user@REALM")
      >>> r = requests.get("http://example.org", auth=kerberos_auth)
      ...

  On Windows, WinKerberos is used instead of PyKerberos. WinKerberos allows the
  use of arbitrary principals instead of a credential cache. Passwords can be
  specified by following the form ``user@realm:password`` for ``principal``.

  Delegation
  ----------

  ``requests_kerberos`` supports credential delegation (``GSS_C_DELEG_FLAG``).
  To enable delegation of credentials to a server that requests delegation, pass
  ``delegate=True`` to ``HTTPKerberosAuth``:

  .. code-block:: python

      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth
      >>> r = requests.get("http://example.org", auth=HTTPKerberosAuth(delegate=True))
      ...

  Be careful to only allow delegation to servers you trust as they will be able
  to impersonate you using the delegated credentials.

  Logging
  -------

  This library makes extensive use of Python's logging facilities.

  Log messages are logged to the ``requests_kerberos`` and
  ``requests_kerberos.kerberos_`` named loggers.

  If you are having difficulty we suggest you configure logging. Issues with the
  underlying kerberos libraries will be made apparent. Additionally, copious debug
  information is made available which may assist in troubleshooting if you
  increase your log level all the way up to debug.


  History
  =======

  0.12.0: 2017-12-20
  ------------------------

  - Add support for channel binding tokens (assumes pykerberos support >= 1.2.1)
  - Add support for kerberos message encryption (assumes pykerberos support >= 1.2.1)
  - Misc CI/test fixes

  0.11.0: 2016-11-02
  ------------------

  - Switch dependency on Windows from kerberos-sspi/pywin32 to WinKerberos.
    This brings Custom Principal support to Windows users.

  0.10.0: 2016-05-18
  ------------------

  - Make it possible to receive errors without having their contents and headers
    stripped.
  - Resolve a bug caused by passing the ``principal`` keyword argument to
    kerberos-sspi on Windows.

  0.9.0: 2016-05-06
  -----------------

  - Support for principal, hostname, and realm override.

  - Added support for mutual auth.

  0.8.0: 2016-01-07
  -----------------

  - Support for Kerberos delegation.

  - Fixed problems declaring kerberos-sspi on Windows installs.

  0.7.0: 2015-05-04
  -----------------

  - Added Windows native authentication support by adding kerberos-sspi as an
    alternative backend.

  - Prevent infinite recursion when a server returns 401 to an authorization
    attempt.

  - Reduce the logging during successful responses.

  0.6.1: 2014-11-14
  -----------------

  - Fix HTTPKerberosAuth not to treat non-file as a file

  - Prevent infinite recursion when GSSErrors occurs

  0.6: 2014-11-04
  ---------------

  - Handle mutual authentication (see pull request 36_)

    All users should upgrade immediately. This has been reported to
    oss-security_ and we are awaiting a proper CVE identifier.

    **Update**: We were issued CVE-2014-8650

  - Distribute as a wheel.

  .. _36: https://github.com/requests/requests-kerberos/pull/36
  .. _oss-security: http://www.openwall.com/lists/oss-security/

  0.5: 2014-05-14
  ---------------

  - Allow non-HTTP service principals with HTTPKerberosAuth using a new optional
    argument ``service``.

  - Fix bug in ``setup.py`` on distributions where the ``compiler`` module is
    not available.

  - Add test dependencies to ``setup.py`` so ``python setup.py test`` will work.

  0.4: 2013-10-26
  ---------------

  - Minor updates in the README
  - Change requirements to depend on requests above 1.1.0

  0.3: 2013-06-02
  ---------------

  - Work with servers operating on non-standard ports

  0.2: 2013-03-26
  ---------------

  - Not documented

  0.1: Never released
  -------------------

  - Initial Release


pkgId: 2a5a2ec6e90029b33e5d655d251d722a6481eaedf5d596e358b2a4d13c2b4cdb
name: rh-python36-requests-oauthlib
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: OAuthlib authentication support for Requests.
url: https://github.com/requests/requests-oauthlib
rpm_license: ISC
rpm_vendor: Kenneth Reitz <me@kennethreitz.com>
rpm_group: Development/Libraries
rpm_buildhost: 0733c90c9c514bfdb946477417cf398c
rpm_sourcerpm: rh-python36-requests-oauthlib-1.3.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01088236-rh-python36-requests-oauthlib/rh-python36-requests-oauthlib-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Requests-OAuthlib |build-status| |coverage-status| |docs|
  =========================================================

  This project provides first-class OAuth library support for `Requests <http://python-requests.org>`_.

  The OAuth 1 workflow
  --------------------

  OAuth 1 can seem overly complicated and it sure has its quirks. Luckily,
  requests_oauthlib hides most of these and let you focus at the task at hand.

  Accessing protected resources using requests_oauthlib is as simple as:

  .. code-block:: pycon

      >>> from requests_oauthlib import OAuth1Session
      >>> twitter = OAuth1Session('client_key',
                                  client_secret='client_secret',
                                  resource_owner_key='resource_owner_key',
                                  resource_owner_secret='resource_owner_secret')
      >>> url = 'https://api.twitter.com/1/account/settings.json'
      >>> r = twitter.get(url)

  Before accessing resources you will need to obtain a few credentials from your
  provider (e.g. Twitter) and authorization from the user for whom you wish to
  retrieve resources for. You can read all about this in the full
  `OAuth 1 workflow guide on RTD <https://requests-oauthlib.readthedocs.io/en/latest/oauth1_workflow.html>`_.

  The OAuth 2 workflow
  --------------------

  OAuth 2 is generally simpler than OAuth 1 but comes in more flavours. The most
  common being the Authorization Code Grant, also known as the WebApplication
  flow.

  Fetching a protected resource after obtaining an access token can be extremely
  simple. However, before accessing resources you will need to obtain a few
  credentials from your provider (e.g. Google) and authorization from the user
  for whom you wish to retrieve resources for. You can read all about this in the
  full `OAuth 2 workflow guide on RTD <https://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html>`_.

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

  To install requests and requests_oauthlib you can use pip:

  .. code-block:: bash

      $ pip install requests requests_oauthlib

  .. |build-status| image:: https://travis-ci.org/requests/requests-oauthlib.svg?branch=master
     :target: https://travis-ci.org/requests/requests-oauthlib
  .. |coverage-status| image:: https://img.shields.io/coveralls/requests/requests-oauthlib.svg
     :target: https://coveralls.io/r/requests/requests-oauthlib
  .. |docs| image:: https://readthedocs.org/projects/requests-oauthlib/badge/
     :alt: Documentation Status
     :scale: 100%
     :target: https://requests-oauthlib.readthedocs.io/


  History
  -------

  UNRELEASED
  ++++++++++

  nothing yet

  v1.2.0 (14 January 2019)
  ++++++++++++++++++++++++

  - This project now depends on OAuthlib 3.0.0 and above. It does **not** support
    versions of OAuthlib before 3.0.0.
  - Updated oauth2 tests to use 'sess' for an OAuth2Session instance instead of `auth`
    because OAuth2Session objects and methods acceept an `auth` paramether which is
    typically an instance of `requests.auth.HTTPBasicAuth`
  - `OAuth2Session.fetch_token` previously tried to guess how and where to provide
    "client" and "user" credentials incorrectly. This was incompatible with some
    OAuth servers and incompatible with breaking changes in oauthlib that seek to
    correctly provide the `client_id`. The older implementation also did not raise
    the correct exceptions when username and password are not present on Legacy
    clients.
  - Avoid automatic netrc authentication for OAuth2Session.

  v1.1.0 (9 January 2019)
  +++++++++++++++++++++++

  - Adjusted version specifier for ``oauthlib`` dependency: this project is
    not yet compatible with ``oauthlib`` 3.0.0.
  - Dropped dependency on ``nose``.
  - Minor changes to clean up the code and make it more readable/maintainable.

  v1.0.0 (4 June 2018)
  ++++++++++++++++++++

  - **Removed support for Python 2.6 and Python 3.3.**
    This project now supports Python 2.7, and Python 3.4 and above.
  - Added several examples to the documentation.
  - Added plentymarkets compliance fix.
  - Added a ``token`` property to OAuth1Session, to match the corresponding
    ``token`` property on OAuth2Session.

  v0.8.0 (14 February 2017)
  +++++++++++++++++++++++++

  - Added Fitbit compliance fix.
  - Fixed an issue where newlines in the response body for the access token
    request would cause errors when trying to extract the token.
  - Fixed an issue introduced in v0.7.0 where users passing ``auth`` to several
    methods would encounter conflicts with the ``client_id`` and
    ``client_secret``-derived auth. The user-supplied ``auth`` argument is now
    used in preference to those options.

  v0.7.0 (22 September 2016)
  ++++++++++++++++++++++++++

  - Allowed ``OAuth2Session.request`` to take the ``client_id`` and
    ``client_secret`` parameters for the purposes of automatic token refresh,
    which may need them.

  v0.6.2 (12 July 2016)
  +++++++++++++++++++++

  - Use ``client_id`` and ``client_secret`` for the Authorization header if
    provided.
  - Allow explicit bypass of the Authorization header by setting ``auth=False``.
  - Pass through the ``proxies`` kwarg when refreshing tokens.
  - Miscellaneous cleanups.

  v0.6.1 (19 February 2016)
  +++++++++++++++++++++++++

  - Fixed a bug when sending authorization in headers with no username and
    password present.
  - Make sure we clear the session token before obtaining a new one.
  - Some improvements to the Slack compliance fix.
  - Avoid timing problems around token refresh.
  - Allow passing arbitrary arguments to requests when calling
    ``fetch_request_token`` and ``fetch_access_token``.

  v0.6.0 (14 December 2015)
  +++++++++++++++++++++++++

  - Add compliance fix for Slack.
  - Add compliance fix for Mailchimp.
  - ``TokenRequestDenied`` exceptions now carry the entire response, not just the
    status code.
  - Pass through keyword arguments when refreshing tokens automatically.
  - Send authorization in headers, not just body, to maximize compatibility.
  - More getters/setters available for OAuth2 session client values.
  - Allow sending custom headers when refreshing tokens, and set some defaults.


  v0.5.0 (4 May 2015)
  +++++++++++++++++++
  - Fix ``TypeError`` being raised instead of ``TokenMissing`` error.
  - Raise requests exceptions on 4XX and 5XX responses in the OAuth2 flow.
  - Avoid ``AttributeError`` when initializing the ``OAuth2Session`` class
    without complete client information.

  v0.4.2 (16 October 2014)
  ++++++++++++++++++++++++
  - New ``authorized`` property on OAuth1Session and OAuth2Session, which allows
    you to easily determine if the session is already authorized with OAuth tokens
    or not.
  - New ``TokenMissing`` and ``VerifierMissing`` exception classes for OAuth1Session:
    this will make it easier to catch and identify these exceptions.

  v0.4.1 (6 June 2014)
  ++++++++++++++++++++
  - New install target ``[rsa]`` for people using OAuth1 RSA-SHA1 signature
    method.
  - Fixed bug in OAuth2 where supplied state param was not used in auth url.
  - OAuth2 HTTPS checking can be disabled by setting environment variable
    ``OAUTHLIB_INSECURE_TRANSPORT``.
  - OAuth1 now re-authorize upon redirects.
  - OAuth1 token fetching now raise a detailed error message when the
    response body is incorrectly encoded or the request was denied.
  - Added support for custom OAuth1 clients.
  - OAuth2 compliance fix for Sina Weibo.
  - Multiple fixes to facebook compliance fix.
  - Compliance fixes now re-encode body properly as bytes in Python 3.
  - Logging now properly done under ``requests_oauthlib`` namespace instead
    of piggybacking on oauthlib namespace.
  - Logging introduced for OAuth1 auth and session.

  v0.4.0 (29 September 2013)
  ++++++++++++++++++++++++++
  - OAuth1Session methods only return unicode strings. #55.
  - Renamed requests_oauthlib.core to requests_oauthlib.oauth1_auth for consistency. #79.
  - Added Facebook compliance fix and access_token_response hook to OAuth2Session. #63.
  - Added LinkedIn compliance fix.
  - Added refresh_token_response compliance hook, invoked before parsing the refresh token.
  - Correctly limit compliance hooks to running only once!
  - Content type guessing should only be done when no content type is given
  - OAuth1 now updates r.headers instead of replacing it with non case insensitive dict
  - Remove last use of Response.content (in OAuth1Session). #44.
  - State param can now be supplied in OAuth2Session.authorize_url


pkgId: 65ccb9ee3e2c851f45e98265a3ea79d2519def801b0b51cfb7f8980a88da959f
name: rh-python36-requestsexceptions
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Import exceptions from potentially bundled packages in requests.
url: http://www.openstack.org/
rpm_license: UNKNOWN
rpm_vendor: OpenStack <openstack-dev@lists.openstack.org>
rpm_group: Development/Libraries
rpm_buildhost: 8eb8f20b97294f61936c4b5c9bd2538d
rpm_sourcerpm: rh-python36-requestsexceptions-1.4.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879123-rh-python36-requestsexceptions/rh-python36-requestsexceptions-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  requestsexceptions
  ==================

  The python requests library bundles the urllib3 library, however, some
  software distributions modify requests to remove the bundled library.
  This makes some operations, such as supressing the "insecure platform
  warning" messages that urllib emits difficult.  This is a simple
  library to find the correct path to exceptions in the requests library
  regardless of whether they are bundled.


pkgId: e14498d613a888bc39cdb28b953060e5ef0ceeba321e0e68a289635b320d8bec
name: rh-python36-rply
arch: noarch
version: 0.7.5
epoch: 0
release: 1
summary: A pure Python Lex/Yacc that works with RPython
rpm_license: UNKNOWN
rpm_vendor: Alex Gaynor <alex.gaynor@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 52395433fc7e4873b8eca32b48e3ce13
rpm_sourcerpm: rh-python36-rply-0.7.5-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879128-rh-python36-rply/rh-python36-rply-0.7.5-1.noarch.rpm
checksum_type: sha256
description:
  RPLY
  ====

  .. image:: https://secure.travis-ci.org/alex/rply.png
      :target: https://travis-ci.org/alex/rply

  Welcome to RPLY! A pure Python parser generator, that also works with RPython.
  It is a more-or-less direct port of David Beazley's awesome PLY, with a new
  public API, and RPython support.

  You can find the documentation `online`_.

  Basic API:

  .. code:: python

      from rply import ParserGenerator, LexerGenerator
      from rply.token import BaseBox

      lg = LexerGenerator()
      
      lg.add("PLUS", r"\+")
      lg.add("MINUS", r"-")
      lg.add("NUMBER", r"\d+")

      lg.ignore(r"\s+")

      
      
      
      
      
      
      
      pg = ParserGenerator(["NUMBER", "PLUS", "MINUS"],
              precedence=[("left", ['PLUS', 'MINUS'])], cache_id="myparser")

      @pg.production("main : expr")
      def main(p):
          
          
          return p[0]

      @pg.production("expr : expr PLUS expr")
      @pg.production("expr : expr MINUS expr")
      def expr_op(p):
          lhs = p[0].getint()
          rhs = p[2].getint()
          if p[1].gettokentype() == "PLUS":
              return BoxInt(lhs + rhs)
          elif p[1].gettokentype() == "MINUS":
              return BoxInt(lhs - rhs)
          else:
              raise AssertionError("This is impossible, abort the time machine!")

      @pg.production("expr : NUMBER")
      def expr_num(p):
          return BoxInt(int(p[0].getstr()))

      lexer = lg.build()
      parser = pg.build()

      class BoxInt(BaseBox):
          def __init__(self, value):
              self.value = value

          def getint(self):
              return self.value

  Then you can do:

  .. code:: python

      parser.parse(lexer.lex("1 + 3 - 2+12-32"))

  You can also substitute your own lexer. A lexer is an object with a ``next()``
  method that returns either the next token in sequence, or ``None`` if the token
  stream has been exhausted.

  Why do we have the boxes?
  -------------------------

  In RPython, like other statically typed languages, a variable must have a
  specific type, we take advantage of polymorphism to keep values in a box so
  that everything is statically typed. You can write whatever boxes you need for
  your project.

  If you don't intend to use your parser from RPython, and just want a cool pure
  Python parser you can ignore all the box stuff and just return whatever you
  like from each production method.

  Error handling
  --------------

  By default, when a parsing error is encountered, an ``rply.ParsingError`` is
  raised, it has a method ``getsourcepos()``, which returns an
  ``rply.token.SourcePosition`` object.

  You may also provide an error handler, which, at the moment, must raise an
  exception. It receives the ``Token`` object that the parser errored on.

  .. code:: python

      pg = ParserGenerator(...)

      @pg.error
      def error_handler(token):
          raise ValueError("Ran into a %s where it wasn't expected" % token.gettokentype())

  Python compatibility
  --------------------

  RPly is tested and known to work under Python 2.6, 2.7, 3.3+, and PyPy. It is
  also valid RPython for PyPy checkouts from ``6c642ae7a0ea`` onwards.

  Links
  -----

  * `Source code and issue tracker <https://github.com/alex/rply/>`_
  * `PyPI releases <https://pypi.python.org/pypi/rply>`_
  * `Talk at PyCon US 2013: So you want to write an interpreter? <http://pyvideo.org/video/1694/so-you-want-to-write-an-interpreter>`_

  .. _`online`: https://rply.readthedocs.io/


pkgId: ccc3df5ac837460eae522f299e1c629b3fbb712485ea71d96551e929bbeb0956
name: rh-python36-rsa
arch: noarch
version: 4.0
epoch: 0
release: 1
summary: Pure-Python RSA implementation
url: https://stuvel.eu/rsa
rpm_license: ASL 2
rpm_vendor: Sybren A. Stuvel <sybren@stuvel.eu>
rpm_group: Development/Libraries
rpm_buildhost: 5945020b44c24980898b96a0135ef4cc
rpm_sourcerpm: rh-python36-rsa-4.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00882961-rh-python36-rsa/rh-python36-rsa-4.0-1.noarch.rpm
checksum_type: sha256
description:
  Pure Python RSA implementation
  ==============================

  [![PyPI](https://img.shields.io/pypi/v/rsa.svg)](https://pypi.org/project/rsa/)
  [![Build Status](https://travis-ci.org/sybrenstuvel/python-rsa.svg?branch=master)](https://travis-ci.org/sybrenstuvel/python-rsa)
  [![Coverage Status](https://coveralls.io/repos/github/sybrenstuvel/python-rsa/badge.svg?branch=master)](https://coveralls.io/github/sybrenstuvel/python-rsa?branch=master)
  [![Code Climate](https://img.shields.io/codeclimate/github/sybrenstuvel/python-rsa.svg)](https://codeclimate.com/github/sybrenstuvel/python-rsa)

  [Python-RSA](https://stuvel.eu/rsa) is a pure-Python RSA implementation. It supports
  encryption and decryption, signing and verifying signatures, and key
  generation according to PKCS#1 version 1.5. It can be used as a Python
  library as well as on the commandline. The code was mostly written by
  Sybren A.  Stüvel.

  Documentation can be found at the [Python-RSA homepage](https://stuvel.eu/rsa).

  Download and install using:

      pip install rsa

  or download it from the [Python Package Index](https://pypi.org/project/rsa/).

  The source code is maintained at [GitHub](https://github.com/sybrenstuvel/python-rsa/) and is
  licensed under the [Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0)


  Major changes in 4.0
  --------------------

  Version 3.4 was the last version in the 3.x range. Version 4.0 drops the following modules,
  as they are insecure:

  - `rsa._version133`
  - `rsa._version200`
  - `rsa.bigfile`
  - `rsa.varblock`

  Those modules were marked as deprecated in version 3.4.

  Furthermore, in 4.0 the I/O functions is streamlined to always work with bytes on all
  supported versions of Python.

  Version 4.0 drops support for Python 2.6 and 3.3.


pkgId: d656f2d116ce5becd5cd04b996550d2b141c3b7ed180b8bafe4221b35751908f
name: rh-python36-ruamel.yaml
arch: ppc64le
version: 0.16.5
epoch: 0
release: 1
url: https://bitbucket.org/ruamel/yaml
rpm_license: MIT license
rpm_vendor: Anthon van der Neut <a.van.der.neut@ruamel.eu>
rpm_group: Development/Libraries
rpm_buildhost: edd9c7012b574297afe3d1d30801dfe1
rpm_sourcerpm: rh-python36-ruamel.yaml-0.16.5-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143848-rh-python36-ruamel.yaml/rh-python36-ruamel.yaml-0.16.5-1.ppc64le.rpm
checksum_type: sha256
summary:
  ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order

description:
  ruamel.yaml
  ===========

  ``ruamel.yaml`` is a YAML 1.2 loader/dumper package for Python.

  :version:       0.15.99
  :updated:       2019-07-12
  :documentation: http://yaml.readthedocs.io
  :repository:    https://bitbucket.org/ruamel/yaml
  :pypi:          https://pypi.org/project/ruamel.yaml/


  Starting with version 0.15.0 the way YAML files are loaded and dumped
  is changing. See the API doc for details.  Currently existing
  functionality will throw a warning before being changed/removed.
  **For production systems you should pin the version being used with
  ``ruamel.yaml<=0.15``**. There might be bug fixes in the 0.14 series,
  but new functionality is likely only to be available via the new API.

  If your package uses ``ruamel.yaml`` and is not listed on PyPI, drop
  me an email, preferably with some information on how you use the
  package (or a link to bitbucket/github) and I'll keep you informed
  when the status of the API is stable enough to make the transition.

  * `Overview <http://yaml.readthedocs.org/en/latest/overview.html>`_
  * `Installing <http://yaml.readthedocs.org/en/latest/install.html>`_
  * `Basic Usage <http://yaml.readthedocs.org/en/latest/basicuse.html>`_
  * `Details <http://yaml.readthedocs.org/en/latest/detail.html>`_
  * `Examples <http://yaml.readthedocs.org/en/latest/example.html>`_
  * `API <http://yaml.readthedocs.org/en/latest/api.html>`_
  * `Differences with PyYAML <http://yaml.readthedocs.org/en/latest/pyyaml.html>`_

  .. image:: https://readthedocs.org/projects/yaml/badge/?version=stable
     :target: https://yaml.readthedocs.org/en/stable

  .. image:: https://bestpractices.coreinfrastructure.org/projects/1128/badge
     :target: https://bestpractices.coreinfrastructure.org/projects/1128

  .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/license.svg
     :target: https://opensource.org/licenses/MIT

  .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/pypi.svg
     :target: https://pypi.org/project/ruamel.yaml/

  .. image:: https://bitbucket.org/ruamel/oitnb/raw/default/_doc/_static/oitnb.svg
     :target: https://pypi.org/project/oitnb/

  .. image:: http://www.mypy-lang.org/static/mypy_badge.svg
     :target: http://mypy-lang.org/

  ChangeLog
  =========

  .. should insert NEXT: at the beginning of line for next key (with empty line)

  0.15.99 (2019-07-12):
    - add `py.typed` to distribution, based on a PR submitted by
      `Michael Crusoe
      <https://bitbucket.org/%7Bc9fbde69-e746-48f5-900d-34992b7860c8%7D/>`__
    - merge PR 40 (also by Michael Crusoe) to more accurately specify
      repository in the README (also reported in a misunderstood issue
      some time ago)

  0.15.98 (2019-07-09):
    - regenerate ext/_ruamel_yaml.c with Cython version 0.29.12, needed
      for Python 3.8.0b2 (reported by `John Vandenberg
      <https://bitbucket.org/%7B6d4e8487-3c97-4dab-a060-088ec50c682c%7D/>`__)

  0.15.97 (2019-06-06):
    - regenerate ext/_ruamel_yaml.c with Cython version 0.29.10, needed for
      Python 3.8.0b1
    - regenerate ext/_ruamel_yaml.c with Cython version 0.29.9, needed for
      Python 3.8.0a4 (reported by `Anthony Sottile
      <https://bitbucket.org/%7B569cc8ea-0d9e-41cb-94a4-19ea517324df%7D/>`__)

  0.15.96 (2019-05-16):
    - fix failure to indent comments on round-trip anchored block style
      scalars in block sequence (reported by `William Kimball
      <https://bitbucket.org/%7Bba35ed20-4bb0-46f8-bb5d-c29871e86a22%7D/>`__)

  0.15.95 (2019-05-16):
    - fix failure to round-trip anchored scalars in block sequence
      (reported by `William Kimball
      <https://bitbucket.org/%7Bba35ed20-4bb0-46f8-bb5d-c29871e86a22%7D/>`__)
    - wheel files for Python 3.4 no longer provided (`Python 3.4 EOL 2019-03-18
      <https://www.python.org/dev/peps/pep-0429/>`__)

  0.15.94 (2019-04-23):
    - fix missing line-break after end-of-file comments not ending in
      line-break (reported by `Philip Thompson
      <https://bitbucket.org/%7Be42ba205-0876-4151-bcbe-ccaea5bd13ce%7D/>`__)

  0.15.93 (2019-04-21):
    - fix failure to parse empty implicit flow mapping key
    - in YAML 1.1 plains scalars `y`, 'n', `Y`, and 'N' are now
      correctly recognised as booleans and such strings dumped quoted
      (reported by `Marcel Bollmann
      <https://bitbucket.org/%7Bd8850921-9145-4ad0-ac30-64c3bd9b036d%7D/>`__)

  0.15.92 (2019-04-16):
    - fix failure to parse empty implicit block mapping key (reported by
      `Nolan W <https://bitbucket.org/i2labs/>`__)

  0.15.91 (2019-04-05):
    - allowing duplicate keys would not work for merge keys (reported by mamacdon on
      `StackOverflow <https://stackoverflow.com/questions/55540686/>`__

  0.15.90 (2019-04-04):
    - fix issue with updating `CommentedMap` from list of tuples (reported by
      `Peter Henry <https://bitbucket.org/mosbasik/>`__)

  0.15.89 (2019-02-27):
    - fix for items with flow-mapping in block sequence output on single line
      (reported by `Zahari Dim <https://bitbucket.org/zahari_dim/>`__)
    - fix for safe dumping erroring in creation of representereror when dumping namedtuple
      (reported and solution by `Jaakko Kantojärvi <https://bitbucket.org/raphendyr/>`__)

  0.15.88 (2019-02-12):
    - fix inclusing of python code from the subpackage data (containing extra tests,
      reported by `Florian Apolloner <https://bitbucket.org/apollo13/>`__)

  0.15.87 (2019-01-22):
    - fix problem with empty lists and the code to reinsert merge keys (reported via email
       by Zaloo)

  0.15.86 (2019-01-16):
    - reinsert merge key in its old position (reported by grumbler on
      `StackOverflow <https://stackoverflow.com/a/54206512/1307905>`__)
    - fix for issue with non-ASCII anchor names (reported and fix
      provided by Dandaleon Flux via email)
    - fix for issue when parsing flow mapping value starting with colon (in pure Python only)
      (reported by `FichteFoll <https://bitbucket.org/FichteFoll/>`__)

  0.15.85 (2019-01-08):
    - the types used by ``SafeConstructor`` for mappings and sequences can
      now by set by assigning to ``XXXConstructor.yaml_base_dict_type``
      (and ``..._list_type``), preventing the need to copy two methods
      with 50+ lines that had ``var = {}`` hardcoded.  (Implemented to
      help solve an feature request by `Anthony Sottile
      <https://bitbucket.org/asottile/>`__ in an easier way)

  0.15.84 (2019-01-07):
    - fix for ``CommentedMap.copy()`` not returning ``CommentedMap``, let alone copying comments etc.
      (reported by `Anthony Sottile <https://bitbucket.org/asottile/>`__)

  0.15.83 (2019-01-02):
    - fix for bug in roundtripping aliases used as key (reported via email by Zaloo)

  0.15.82 (2018-12-28):
    - anchors and aliases on scalar int, float, string and bool are now preserved. Anchors
      do not need a referring alias for these (reported by
      `Alex Harvey <https://bitbucket.org/alexharv074/>`__)
    - anchors no longer lost on tagged objects when roundtripping (reported by `Zaloo
      <https://bitbucket.org/zaloo/>`__)

  0.15.81 (2018-12-06):
    - fix issue dumping methods of metaclass derived classes (reported and fix provided
      by `Douglas Raillard <https://bitbucket.org/DouglasRaillard/>`__)

  0.15.80 (2018-11-26):
    - fix issue emitting BEL character when round-tripping invalid folded input
      (reported by Isaac on `StackOverflow <https://stackoverflow.com/a/53471217/1307905>`__)

  0.15.79 (2018-11-21):
    - fix issue with anchors nested deeper than alias (reported by gaFF on
      `StackOverflow <https://stackoverflow.com/a/53397781/1307905>`__)

  0.15.78 (2018-11-15):
    - fix setup issue for 3.8 (reported by `Sidney Kuyateh
      <https://bitbucket.org/autinerd/>`__)

  0.15.77 (2018-11-09):
    - setting `yaml.sort_base_mapping_type_on_output = False`, will prevent
      explicit sorting by keys in the base representer of mappings. Roundtrip
      already did not do this. Usage only makes real sense for Python 3.6+
      (feature request by `Sebastian Gerber <https://bitbucket.org/spacemanspiff2007/>`__).
    - implement Python version check in YAML metadata in ``_test/test_z_data.py``

  0.15.76 (2018-11-01):
    - fix issue with empty mapping and sequence loaded as flow-style
      (mapping reported by `Min RK <https://bitbucket.org/minrk/>`__, sequence
      by `Maged Ahmed <https://bitbucket.org/maged2/>`__)

  0.15.75 (2018-10-27):
    - fix issue with single '?' scalar (reported by `Terrance
      <https://bitbucket.org/OllieTerrance/>`__)
    - fix issue with duplicate merge keys (prompted by `answering
      <https://stackoverflow.com/a/52852106/1307905>`__ a
      `StackOverflow question <https://stackoverflow.com/q/52851168/1307905>`__
      by `math <https://stackoverflow.com/users/1355634/math>`__)

  0.15.74 (2018-10-17):
    - fix dropping of comment on rt before sequence item that is sequence item
      (reported by `Thorsten Kampe <https://bitbucket.org/thorstenkampe/>`__)

  0.15.73 (2018-10-16):
    - fix irregular output on pre-comment in sequence within sequence (reported
      by `Thorsten Kampe <https://bitbucket.org/thorstenkampe/>`__)
    - allow non-compact (i.e. next line) dumping sequence/mapping within sequence.

  0.15.72 (2018-10-06):
    - fix regression on explicit 1.1 loading with the C based scanner/parser
      (reported by `Tomas Vavra <https://bitbucket.org/xtomik/>`__)

  0.15.71 (2018-09-26):
    - some of the tests now live in YAML files in the
      `yaml.data <https://bitbucket.org/ruamel/yaml.data>`__ repository.
      ``_test/test_z_data.py`` processes these.
    - fix regression where handcrafted CommentedMaps could not be initiated (reported by
      `Dan Helfman <https://bitbucket.org/dhelfman/>`__)
    - fix regression with non-root literal scalars that needed indent indicator
      (reported by `Clark Breyman <https://bitbucket.org/clarkbreyman/>`__)
    - tag:yaml.org,2002:python/object/apply now also uses __qualname__ on PY3
      (reported by `Douglas RAILLARD <https://bitbucket.org/DouglasRaillard/>`__)
    - issue with self-referring object creation
      (reported and fix by `Douglas RAILLARD <https://bitbucket.org/DouglasRaillard/>`__)

  0.15.70 (2018-09-21):
    - reverted CommentedMap and CommentedSeq to subclass ordereddict resp. list,
      reimplemented merge maps so that both ``dict(**commented_map_instance)`` and JSON
      dumping works. This also allows checking with ``isinstance()`` on ``dict`` resp. ``list``.
      (Proposed by `Stuart Berg <https://bitbucket.org/stuarteberg/>`__, with feedback
      from `blhsing <https://stackoverflow.com/users/6890912/blhsing>`__ on
      `StackOverflow <https://stackoverflow.com/q/52314186/1307905>`__)

  0.15.69 (2018-09-20):
    - fix issue with dump_all gobbling end-of-document comments on parsing
      (reported by `Pierre B. <https://bitbucket.org/octplane/>`__)

  0.15.68 (2018-09-20):
    - fix issue with parsabel, but incorrect output with nested flow-style sequences
      (reported by `Dougal Seeley <https://bitbucket.org/dseeley/>`__)
    - fix issue with loading Python objects that have __setstate__ and recursion in parameters
      (reported by `Douglas RAILLARD <https://bitbucket.org/DouglasRaillard/>`__)

  0.15.67 (2018-09-19):
    - fix issue with extra space inserted with non-root literal strings
      (Issue reported and PR with fix provided by
      `Naomi Seyfer <https://bitbucket.org/sixolet/>`__.)

  0.15.66 (2018-09-07):
    - fix issue with fold indicating characters inserted in safe_load-ed folded strings
      (reported by `Maximilian Hils <https://bitbucket.org/mhils/>`__).

  0.15.65 (2018-09-07):
    - fix issue #232 revert to throw ParserError for unexcpected ``]``
      and ``}`` instead of IndexError. (Issue reported and PR with fix
      provided by `Naomi Seyfer <https://bitbucket.org/sixolet/>`__.)
    - added ``key`` and ``reverse`` parameter (suggested by Jannik Klemm via email)
    - indent root level literal scalars that have directive or document end markers
      at the beginning of a line

  0.15.64 (2018-08-30):
    - support round-trip of tagged sequences: ``!Arg [a, {b: 1}]``
    - single entry mappings in flow sequences now written by default without braces,
      set ``yaml.brace_single_entry_mapping_in_flow_sequence=True`` to force
      getting ``[a, {b: 1}, {c: {d: 2}}]`` instead of the default ``[a, b: 1, c: {d: 2}]``
    - fix issue when roundtripping floats starting with a dot such as ``.5``
      (reported by `Harrison Gregg <https://bitbucket.org/HarrisonGregg/>`__)

  0.15.63 (2018-08-29):
    - small fix only necessary for Windows users that don't use wheels.

  0.15.62 (2018-08-29):
    - C based reader/scanner & emitter now allow setting of 1.2 as YAML version.
      ** The loading/dumping is still YAML 1.1 code**, so use the common subset of
      YAML 1.2 and 1.1 (reported by `Ge Yang <https://bitbucket.org/yangge/>`__)

  0.15.61 (2018-08-23):
    - support for round-tripping folded style scalars (initially requested
      by `Johnathan Viduchinsky <https://bitbucket.org/johnathanvidu/>`__)
    - update of C code
    - speed up of scanning (~30% depending on the input)

  0.15.60 (2018-08-18):
    - again allow single entry map in flow sequence context (reported by
      `Lee Goolsbee <https://bitbucket.org/lgoolsbee/>`__)
    - cleanup for mypy
    - spurious print in library (reported by
      `Lele Gaifax <https://bitbucket.org/lele/>`__), now automatically checked

  0.15.59 (2018-08-17):
    - issue with C based loader and leading zeros (reported by
      `Tom Hamilton Stubber <https://bitbucket.org/TomHamiltonStubber/>`__)

  0.15.58 (2018-08-17):
    - simple mappings can now be used as keys when round-tripping::

        {a: 1, b: 2}: hello world

      although using the obvious operations (del, popitem) on the key will
      fail, you can mutilate it by going through its attributes. If you load the
      above YAML in `d`, then changing the value is cumbersome:

          d = {CommentedKeyMap([('a', 1), ('b', 2)]): "goodbye"}

      and changing the key even more so:

          d[CommentedKeyMap([('b', 1), ('a', 2)])] = d.pop(
                       CommentedKeyMap([('a', 1), ('b', 2)]))

      (you can use a `dict` instead of a list of tuples (or ordereddict), but that might result
      in a different order, of the keys of the key, in the output)
    - check integers to dump with 1.2 patterns instead of 1.1 (reported by
      `Lele Gaifax <https://bitbucket.org/lele/>`__)


  0.15.57 (2018-08-15):
    - Fix that CommentedSeq could no longer be used in adding or do a sort
      (reported by `Christopher Wright <https://bitbucket.org/CJ-Wright4242/>`__)

  0.15.56 (2018-08-15):
    - fix issue with ``python -O`` optimizing away code (reported, and detailed cause
      pinpointed, by `Alex Grönholm <https://bitbucket.org/agronholm/>`__)

  0.15.55 (2018-08-14):
    - unmade ``CommentedSeq`` a subclass of ``list``. It is now
      indirectly a subclass of the standard
      ``collections.abc.MutableSequence`` (without .abc if you are
      still on Python2.7). If you do ``isinstance(yaml.load('[1, 2]'),
      list)``) anywhere in your code replace ``list`` with
      ``MutableSequence``.  Directly, ``CommentedSeq`` is a subclass of
      the abstract baseclass ``ruamel.yaml.compat.MutableScliceableSequence``,
      with the result that *(extended) slicing is supported on
      ``CommentedSeq``*.
      (reported by `Stuart Berg <https://bitbucket.org/stuarteberg/>`__)
    - duplicate keys (or their values) with non-ascii now correctly
      report in Python2, instead of raising a Unicode error.
      (Reported by `Jonathan Pyle <https://bitbucket.org/jonathan_pyle/>`__)

  0.15.54 (2018-08-13):
    - fix issue where a comment could pop-up twice in the output (reported by
      `Mike Kazantsev <https://bitbucket.org/mk_fg/>`__ and by
      `Nate Peterson <https://bitbucket.org/ndpete21/>`__)
    - fix issue where JSON object (mapping) without spaces was not parsed
      properly (reported by `Marc Schmidt <https://bitbucket.org/marcj/>`__)
    - fix issue where comments after empty flow-style mappings were not emitted
      (reported by `Qinfench Chen <https://bitbucket.org/flyin5ish/>`__)

  0.15.53 (2018-08-12):
    - fix issue with flow style mapping with comments gobbled newline (reported
      by `Christopher Lambert <https://bitbucket.org/XN137/>`__)
    - fix issue where single '+' under YAML 1.2 was interpreted as
      integer, erroring out (reported by `Jethro Yu
      <https://bitbucket.org/jcppkkk/>`__)

  0.15.52 (2018-08-09):
    - added `.copy()` mapping representation for round-tripping
      (``CommentedMap``) to fix incomplete copies of merged mappings
      (reported by `Will Richards
      <https://bitbucket.org/will_richards/>`__)
    - Also unmade that class a subclass of ordereddict to solve incorrect behaviour
      for ``{**merged-mapping}`` and ``dict(**merged-mapping)`` (reported independently by
      `Tim Olsson <https://bitbucket.org/tgolsson/>`__ and
      `Filip Matzner <https://bitbucket.org/FloopCZ/>`__)

  0.15.51 (2018-08-08):
    - Fix method name dumps (were not dotted) and loads (reported by `Douglas Raillard
      <https://bitbucket.org/DouglasRaillard/>`__)
    - Fix spurious trailing white-space caused when the comment start
      column was no longer reached and there was no actual EOL comment
      (e.g. following empty line) and doing substitutions, or when
      quotes around scalars got dropped.  (reported by `Thomas Guillet
      <https://bitbucket.org/guillett/>`__)

  0.15.50 (2018-08-05):
    - Allow ``YAML()`` as a context manager for output, thereby making it much easier
      to generate multi-documents in a stream.
    - Fix issue with incorrect type information for `load()` and `dump()` (reported
      by `Jimbo Jim <https://bitbucket.org/jimbo1qaz/>`__)

  0.15.49 (2018-08-05):
    - fix preservation of leading newlines in root level literal style scalar,
      and preserve comment after literal style indicator (``|  # some comment``)
      Both needed for round-tripping multi-doc streams in
      `ryd <https://pypi.org/project/ryd/>`__.

  0.15.48 (2018-08-03):
    - housekeeping: ``oitnb`` for formatting, mypy 0.620 upgrade and conformity

  0.15.47 (2018-07-31):
    - fix broken 3.6 manylinux1, the result of an unclean ``build`` (reported by
      `Roman Sichnyi <https://bitbucket.org/rsichnyi-gl/>`__)


  0.15.46 (2018-07-29):
    - fixed DeprecationWarning for importing from ``collections`` on 3.7
      (issue 210, reported by `Reinoud Elhorst
      <https://bitbucket.org/reinhrst/>`__). It was `difficult to find
      why tox/pytest did not report
      <https://stackoverflow.com/q/51573204/1307905>`__ and as time
      consuming to actually `fix
      <https://stackoverflow.com/a/51573205/1307905>`__ the tests.

  0.15.45 (2018-07-26):
    - After adding failing test for ``YAML.load_all(Path())``, remove StopIteration
      (PR provided by `Zachary Buhman <https://bitbucket.org/buhman/>`__,
      also reported by `Steven Hiscocks <https://bitbucket.org/sdhiscocks/>`__.

  0.15.44 (2018-07-14):
    - Correct loading plain scalars consisting of numerals only and
      starting with `0`, when not explicitly specifying YAML version
      1.1. This also fixes the issue about dumping string `'019'` as
      plain scalars as reported by `Min RK
      <https://bitbucket.org/minrk/>`__, that prompted this chance.

  0.15.43 (2018-07-12):
    - merge PR33: Python2.7 on Windows is narrow, but has no
      ``sysconfig.get_config_var('Py_UNICODE_SIZE')``. (merge provided by
      `Marcel Bargull <https://bitbucket.org/mbargull/>`__)
    - ``register_class()`` now returns class (proposed by
      `Mike Nerone <https://bitbucket.org/Manganeez/>`__}

  0.15.42 (2018-07-01):
    - fix regression showing only on narrow Python 2.7 (py27mu) builds
      (with help from
      `Marcel Bargull <https://bitbucket.org/mbargull/>`__ and
      `Colm O'Connor <https://bitbucket.org/colmoconnorgithub/>`__).
    - run pre-commit ``tox`` on Python 2.7 wide and narrow, as well as
      3.4/3.5/3.6/3.7/pypy

  0.15.41 (2018-06-27):
    - add detection of C-compile failure (investigation prompted by
      `StackOverlow <https://stackoverflow.com/a/51057399/1307905>`__ by
      `Emmanuel Blot <https://stackoverflow.com/users/8233409/emmanuel-blot>`__),
      which was removed while no longer dependent on ``libyaml``, C-extensions
      compilation still needs a compiler though.

  0.15.40 (2018-06-18):
    - added links to landing places as suggested in issue 190 by
      `KostisA <https://bitbucket.org/ankostis/>`__
    - fixes issue #201: decoding unicode escaped tags on Python2, reported
      by `Dan Abolafia <https://bitbucket.org/danabo/>`__

  0.15.39 (2018-06-17):
    - merge PR27 improving package startup time (and loading when regexp not
      actually used), provided by
      `Marcel Bargull <https://bitbucket.org/mbargull/>`__

  0.15.38 (2018-06-13):
    - fix for losing precision when roundtripping floats by
      `Rolf Wojtech <https://bitbucket.org/asomov/>`__
    - fix for hardcoded dir separator not working for Windows by
      `Nuno André <https://bitbucket.org/nu_no/>`__
    - typo fix by `Andrey Somov <https://bitbucket.org/asomov/>`__

  0.15.37 (2018-03-21):
    - again trying to create installable files for 187

  0.15.36 (2018-02-07):
    - fix issue 187, incompatibility of C extension with 3.7 (reported by
      Daniel Blanchard)

  0.15.35 (2017-12-03):
    - allow ``None`` as stream when specifying ``transform`` parameters to
      ``YAML.dump()``.
      This is useful if the transforming function doesn't return a meaningful value
      (inspired by `StackOverflow <https://stackoverflow.com/q/47614862/1307905>`__ by
      `rsaw <https://stackoverflow.com/users/406281/rsaw>`__).

  0.15.34 (2017-09-17):
    - fix for issue 157: CDumper not dumping floats (reported by Jan Smitka)

  0.15.33 (2017-08-31):
    - support for "undefined" round-tripping tagged scalar objects (in addition to
      tagged mapping object). Inspired by a use case presented by Matthew Patton
      on `StackOverflow <https://stackoverflow.com/a/45967047/1307905>`__.
    - fix issue 148: replace cryptic error message when using !!timestamp with an
      incorrectly formatted or non- scalar. Reported by FichteFoll.

  0.15.32 (2017-08-21):
    - allow setting ``yaml.default_flow_style = None`` (default: ``False``) for
      for ``typ='rt'``.
    - fix for issue 149: multiplications on ``ScalarFloat`` now return ``float``
      (reported by jan.brezina@tul.cz)

  0.15.31 (2017-08-15):
    - fix Comment dumping

  0.15.30 (2017-08-14):
    - fix for issue with "compact JSON" not parsing: ``{"in":{},"out":{}}``
      (reported on `StackOverflow <https://stackoverflow.com/q/45681626/1307905>`__ by
      `mjalkio <https://stackoverflow.com/users/5130525/mjalkio>`_

  0.15.29 (2017-08-14):
    - fix issue #51: different indents for mappings and sequences (reported by
      Alex Harvey)
    - fix for flow sequence/mapping as element/value of block sequence with
      sequence-indent minus dash-offset not equal two.

  0.15.28 (2017-08-13):
    - fix issue #61: merge of merge cannot be __repr__-ed (reported by Tal Liron)

  0.15.27 (2017-08-13):
    - fix issue 62, YAML 1.2 allows ``?`` and ``:`` in plain scalars if non-ambigious
      (reported by nowox)
    - fix lists within lists which would make comments disappear

  0.15.26 (2017-08-10):
    - fix for disappearing comment after empty flow sequence (reported by
      oit-tzhimmash)

  0.15.25 (2017-08-09):
    - fix for problem with dumping (unloaded) floats (reported by eyenseo)

  0.15.24 (2017-08-09):
    - added ScalarFloat which supports roundtripping of 23.1, 23.100,
      42.00E+56, 0.0, -0.0 etc. while keeping the format. Underscores in mantissas
      are not preserved/supported (yet, is anybody using that?).
    - (finally) fixed longstanding issue 23 (reported by `Antony Sottile
      <https://bitbucket.org/asottile/>`__), now handling comment between block
      mapping key and value correctly
    - warn on YAML 1.1 float input that is incorrect (triggered by invalid YAML
      provided by Cecil Curry)
    - allow setting of boolean representation (`false`, `true`) by using:
      ``yaml.boolean_representation = [u'False', u'True']``

  0.15.23 (2017-08-01):
    - fix for round_tripping integers on 2.7.X > sys.maxint (reported by ccatterina)

  0.15.22 (2017-07-28):
    - fix for round_tripping singe excl. mark tags doubling (reported and fix by Jan Brezina)

  0.15.21 (2017-07-25):
    - fix for writing unicode in new API, (reported on
      `StackOverflow <https://stackoverflow.com/a/45281922/1307905>`__

  0.15.20 (2017-07-23):
    - wheels for windows including C extensions

  0.15.19 (2017-07-13):
    - added object constructor for rt, decorator ``yaml_object`` to replace YAMLObject.
    - fix for problem using load_all with Path() instance
    - fix for load_all in combination with zero indent block style literal
      (``pure=True`` only!)

  0.15.18 (2017-07-04):
    - missing ``pure`` attribute on ``YAML`` useful for implementing `!include` tag
      constructor for `including YAML files in a YAML file
      <https://stackoverflow.com/a/44913652/1307905>`__
    - some documentation improvements
    - trigger of doc build on new revision

  0.15.17 (2017-07-03):
    - support for Unicode supplementary Plane **output**
      (input was already supported, triggered by
      `this <https://stackoverflow.com/a/44875714/1307905>`__ Stack Overflow Q&A)

  0.15.16 (2017-07-01):
    - minor typing issues (reported and fix provided by
      `Manvendra Singh <https://bitbucket.org/manu-chroma/>`__
    - small doc improvements

  0.15.15 (2017-06-27):
    - fix for issue 135, typ='safe' not dumping in Python 2.7
      (reported by Andrzej Ostrowski <https://bitbucket.org/aostr123/>`__)

  0.15.14 (2017-06-25):
    - fix for issue 133, in setup.py: change ModuleNotFoundError to
      ImportError (reported and fix by
      `Asley Drake  <https://github.com/aldraco>`__)

  0.15.13 (2017-06-24):
    - suppress duplicate key warning on mappings with merge keys (reported by
      Cameron Sweeney)

  0.15.12 (2017-06-24):
    - remove fatal dependency of setup.py on wheel package (reported by
      Cameron Sweeney)

  0.15.11 (2017-06-24):
    - fix for issue 130, regression in nested merge keys (reported by
      `David Fee <https://bitbucket.org/dfee/>`__)

  0.15.10 (2017-06-23):
    - top level PreservedScalarString not indented if not explicitly asked to
    - remove Makefile (not very useful anyway)
    - some mypy additions

  0.15.9 (2017-06-16):
    - fix for issue 127: tagged scalars were always quoted and seperated
      by a newline when in a block sequence (reported and largely fixed by
      `Tommy Wang <https://bitbucket.org/twang817/>`__)

  0.15.8 (2017-06-15):
    - allow plug-in install via ``install ruamel.yaml[jinja2]``

  0.15.7 (2017-06-14):
    - add plug-in mechanism for load/dump pre resp. post-processing

  0.15.6 (2017-06-10):
    - a set() with duplicate elements now throws error in rt loading
    - support for toplevel column zero literal/folded scalar in explicit documents

  0.15.5 (2017-06-08):
    - repeat `load()` on a single `YAML()` instance would fail.

  0.15.4 (2017-06-08):
    - `transform` parameter on dump that expects a function taking a
      string and returning a string. This allows transformation of the output
      before it is written to stream. This forces creation of the complete output in memory!
    - some updates to the docs

  0.15.3 (2017-06-07):
    - No longer try to compile C extensions on Windows. Compilation can be forced by setting
      the environment variable `RUAMEL_FORCE_EXT_BUILD` to some value
      before starting the `pip install`.

  0.15.2 (2017-06-07):
    - update to conform to mypy 0.511: mypy --strict

  0.15.1 (2017-06-07):
    - `duplicate keys  <http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys>`__
      in mappings generate an error (in the old API this change generates a warning until 0.16)
    - dependecy on ruamel.ordereddict for 2.7 now via extras_require

  0.15.0 (2017-06-04):
    - it is now allowed to pass in a ``pathlib.Path`` as "stream" parameter to all
      load/dump functions
    - passing in a non-supported object (e.g. a string) as "stream" will result in a
      much more meaningful YAMLStreamError.
    - assigning a normal string value to an existing CommentedMap key or CommentedSeq
      element will result in a value cast to the previous value's type if possible.
    - added ``YAML`` class for new API

  0.14.12 (2017-05-14):
    - fix for issue 119, deepcopy not returning subclasses (reported and PR by
      Constantine Evans <cevans@evanslabs.org>)

  0.14.11 (2017-05-01):
    - fix for issue 103 allowing implicit documents after document end marker line (``...``)
      in YAML 1.2

  0.14.10 (2017-04-26):
    - fix problem with emitting using cyaml

  0.14.9 (2017-04-22):
    - remove dependency on ``typing`` while still supporting ``mypy``
      (http://stackoverflow.com/a/43516781/1307905)
    - fix unclarity in doc that stated 2.6 is supported (reported by feetdust)

  0.14.8 (2017-04-19):
    - fix Text not available on 3.5.0 and 3.5.1, now proactively setting version guards
      on all files (reported by `João Paulo Magalhães <https://bitbucket.org/jpmag/>`__)

  0.14.7 (2017-04-18):
    - round trip of integers (decimal, octal, hex, binary) now preserve
      leading zero(s) padding and underscores. Underscores are presumed
      to be at regular distances (i.e. ``0o12_345_67`` dumps back as
      ``0o1_23_45_67`` as the space from the last digit to the
      underscore before that is the determining factor).

  0.14.6 (2017-04-14):
    - binary, octal and hex integers are now preserved by default. This
      was a known deficiency. Working on this was prompted by the issue report (112)
      from devnoname120, as well as the additional experience with `.replace()`
      on `scalarstring` classes.
    - fix issues 114: cannot install on Buildozer (reported by mixmastamyk).
      Setting env. var ``RUAMEL_NO_PIP_INSTALL_CHECK`` will suppress ``pip``-check.

  0.14.5 (2017-04-04):
    - fix issue 109: None not dumping correctly at top level (reported by Andrea Censi)
    - fix issue 110: .replace on Preserved/DoubleQuoted/SingleQuoted ScalarString
      would give back "normal" string (reported by sandres23)

  0.14.4 (2017-03-31):
    - fix readme

  0.14.3 (2017-03-31):
    - fix for 0o52 not being a string in YAML 1.1 (reported on
      `StackOverflow Q&A 43138503 <http://stackoverflow.com/a/43138503/1307905>`__ by
      `Frank D <http://stackoverflow.com/users/7796630/frank-d>`__)

  0.14.2 (2017-03-23):
    - fix for old default pip on Ubuntu 14.04 (reported by Sébastien Maccagnoni-Munch)

  0.14.1 (2017-03-22):
    - fix Text not available on 3.5.0 and 3.5.1 (reported by Charles Bouchard-Légaré)

  0.14.0 (2017-03-21):
    - updates for mypy --strict
    - preparation for moving away from inheritance in Loader and Dumper, calls from e.g.
      the Representer to the Serializer.serialize() are now done via the attribute
      .serializer.serialize(). Usage of .serialize() outside of Serializer will be
      deprecated soon
    - some extra tests on main.py functions

  ----

  For older changes see the file
  `CHANGES <https://bitbucket.org/ruamel/yaml/src/default/CHANGES>`_


pkgId: f7060b8c957a740794e47e7a5a6716bb89a855d787753a0789c0f4429c79dcac
name: rh-python36-ruamel.yaml-debuginfo
arch: ppc64le
version: 0.16.5
epoch: 0
release: 1
summary: Debug information for package rh-python36-ruamel.yaml
url: https://bitbucket.org/ruamel/yaml
rpm_license: MIT license
rpm_vendor: Anthon van der Neut <a.van.der.neut@ruamel.eu>
rpm_group: Development/Debug
rpm_buildhost: edd9c7012b574297afe3d1d30801dfe1
rpm_sourcerpm: rh-python36-ruamel.yaml-0.16.5-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143848-rh-python36-ruamel.yaml/rh-python36-ruamel.yaml-debuginfo-0.16.5-1.ppc64le.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-ruamel.yaml.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 47f070e17782a625a2fcd93b603825bb9a7762acb582601ec28545d64af36b43
name: rh-python36-ruamel.yaml.clib
arch: ppc64le
version: 0.2.0
epoch: 0
release: 1
summary: C version of reader, parser and emitter for ruamel.yaml derived from libyaml
url: https://bitbucket.org/ruamel/yaml.clib
rpm_license: MIT
rpm_vendor: Anthon van der Neut <a.van.der.neut@ruamel.eu>
rpm_group: Development/Libraries
rpm_buildhost: 9d3e2eaa9dbe46e29d943c19d66853be
rpm_sourcerpm: rh-python36-ruamel.yaml.clib-0.2.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143847-rh-python36-ruamel.yaml.clib/rh-python36-ruamel.yaml.clib-0.2.0-1.ppc64le.rpm
checksum_type: sha256
description:
  ruamel.yaml.clib
  ================

  ``ruamel.yaml.clib`` is the C based reader/scanner and emitter for ruamel.yaml

  :version:       0.2.0
  :updated:       2019-09-26
  :documentation: http://yaml.readthedocs.io
  :repository:    https://bitbucket.org/ruamel/yaml.clib
  :pypi:          https://pypi.org/project/ruamel.yaml.clib/

  This package was split of from ruamel.yaml, so that ruamel.yaml can be build as
  a universal wheel. Apart from the C code seldom changing, and taking a long
  time to compile for all platforms, this allows installation of the .so
  on Linux systems under /usr/lib64/pythonX.Y (without a .pth file or a ruamel
  directory) and the Python code for ruamel.yaml under /usr/lib/pythonX.Y.


  .. image:: https://bestpractices.coreinfrastructure.org/projects/1128/badge
     :target: https://bestpractices.coreinfrastructure.org/projects/1128

  .. image:: https://bitbucket.org/ruamel/yaml/raw/default/_doc/_static/license.svg
     :target: https://opensource.org/licenses/MIT


pkgId: 9b13d25c42862dd98178f0c57e6f51bbdca4bfbe778e246e243851da1089367f
name: rh-python36-ruamel.yaml.clib-debuginfo
arch: ppc64le
version: 0.2.0
epoch: 0
release: 1
summary: Debug information for package rh-python36-ruamel.yaml.clib
url: https://bitbucket.org/ruamel/yaml.clib
rpm_license: MIT
rpm_vendor: Anthon van der Neut <a.van.der.neut@ruamel.eu>
rpm_group: Development/Debug
rpm_buildhost: 9d3e2eaa9dbe46e29d943c19d66853be
rpm_sourcerpm: rh-python36-ruamel.yaml.clib-0.2.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01143847-rh-python36-ruamel.yaml.clib/rh-python36-ruamel.yaml.clib-debuginfo-0.2.0-1.ppc64le.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-ruamel.yaml.clib.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 293a3714e09df3a3ddba85acdfd1dac5bfe8f78b6553866b49b2fc79983cd1e3
name: rh-python36-s3transfer
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: An Amazon S3 Transfer Manager
url: https://github.com/boto/s3transfer
rpm_license: Apache License 2.0
rpm_vendor: Amazon Web Services <kyknapp1@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 1e21fc2923154ff5b09bf7bb41b10a0d
rpm_sourcerpm: rh-python36-s3transfer-0.2.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01031452-rh-python36-s3transfer/rh-python36-s3transfer-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  =====================================================
  s3transfer - An Amazon S3 Transfer Manager for Python
  =====================================================

  S3transfer is a Python library for managing Amazon S3 transfers.

  .. note::

    This project is not currently GA. If you are planning to use this code in
    production, make sure to lock to a minor version as interfaces may break
    from minor version to minor version. For a basic, stable interface of
    s3transfer, try the interfaces exposed in `boto3 <https://boto3.readthedocs.io/en/latest/guide/s3.html#using-the-transfer-manager>`__


pkgId: add206dfafcb4123b0abfb6c61c65306955be7f3828e6277089cae8953d42f47
name: rh-python36-schedule
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Job scheduling for humans.
url: https://github.com/dbader/schedule
rpm_license: MIT
rpm_vendor: Daniel Bader <mail@dbader.org>
rpm_group: Development/Libraries
rpm_buildhost: 3468dfc5d3354bacbd7fb1f158b18274
rpm_sourcerpm: rh-python36-schedule-0.6.0-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 01235591-rh-python36-schedule/rh-python36-schedule-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  schedule
  ========


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

  .. image:: https://coveralls.io/repos/dbader/schedule/badge.svg?branch=master
          :target: https://coveralls.io/r/dbader/schedule

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

  Python job scheduling for humans.

  An in-process scheduler for periodic jobs that uses the builder pattern
  for configuration. Schedule lets you run Python functions (or any other
  callable) periodically at pre-determined intervals using a simple,
  human-friendly syntax.

  Inspired by `Adam Wiggins' <https://github.com/adamwiggins>`_ article `"Rethinking Cron" <https://adam.herokuapp.com/past/2010/4/13/rethinking_cron/>`_ and the `clockwork <https://github.com/Rykian/clockwork>`_ Ruby module.

  Features
  --------
  - A simple to use API for scheduling jobs.
  - Very lightweight and no external dependencies.
  - Excellent test coverage.
  - Tested on Python 2.7, 3.5, and 3.6

  Usage
  -----

  .. code-block:: bash

      $ pip install schedule

  .. code-block:: python

      import schedule
      import time

      def job():
          print("I'm working...")

      schedule.every(10).minutes.do(job)
      schedule.every().hour.do(job)
      schedule.every().day.at("10:30").do(job)
      schedule.every(5).to(10).minutes.do(job)
      schedule.every().monday.do(job)
      schedule.every().wednesday.at("13:15").do(job)
      schedule.every().minute.at(":17").do(job)

      while True:
          schedule.run_pending()
          time.sleep(1)

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

  Schedule's documentation lives at `schedule.readthedocs.io <https://schedule.readthedocs.io/>`_.

  Please also check the FAQ there with common questions.


  Meta
  ----

  Daniel Bader - `@dbader_org <https://twitter.com/dbader_org>`_ - mail@dbader.org

  Distributed under the MIT license. See `LICENSE.txt <https://github.com/dbader/schedule/blob/master/LICENSE.txt>`_ for more information.

  https://github.com/dbader/schedule


pkgId: f74530fe292816b5338b6ccfb76bf9a252b6d15628c5316264044cd5ce1c6812
name: rh-python36-scipy
arch: ppc64le
version: 0.19.1
epoch: 0
release: 2.el7
summary: Scipy: Scientific Tools for Python
url: https://www.scipy.org/
rpm_license: BSD and Boost and Public Domain
rpm_group: Development/Libraries
rpm_buildhost: 2e81019f315f4f81844d21058c0799aa
rpm_sourcerpm: rh-python36-scipy-0.19.1-2.el7.src.rpm
location_href: 00879549-rh-python36-scipy/rh-python36-scipy-0.19.1-2.el7.ppc64le.rpm
checksum_type: sha256
description:
  Scipy is open-source software for mathematics, science, and
  engineering. The core library is NumPy which provides convenient and
  fast N-dimensional array manipulation. The SciPy library is built to
  work with NumPy arrays, and provides many user-friendly and efficient
  numerical routines such as routines for numerical integration and
  optimization. Together, they run on all popular operating systems, are
  quick to install, and are free of charge. NumPy and SciPy are easy to
  use, but powerful enough to be depended upon by some of the world's
  leading scientists and engineers.


pkgId: f84ac0d7d1819cd331edbba719f136a647f68db4e8c2839e1ddc4bc5f97b41eb
name: rh-python36-scipy-debuginfo
arch: ppc64le
version: 0.19.1
epoch: 0
release: 2.el7
summary: Debug information for package rh-python36-scipy
url: https://www.scipy.org/
rpm_license: BSD and Boost and Public Domain
rpm_group: Development/Debug
rpm_buildhost: 2e81019f315f4f81844d21058c0799aa
rpm_sourcerpm: rh-python36-scipy-0.19.1-2.el7.src.rpm
location_href: 00879549-rh-python36-scipy/rh-python36-scipy-debuginfo-0.19.1-2.el7.ppc64le.rpm
checksum_type: sha256
description:
  This package provides debug information for package rh-python36-scipy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 3006acc9e650264e87cfec6eb208dd731a989aaf20d75894bc6eb90884f98c6f
name: rh-python36-scldevel
arch: ppc64le
version: 2.0
epoch: 0
release: 1.el7
summary: Package shipping development files for rh-python36
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: 763b532a9e6a456c92ce297ab3949d70
rpm_sourcerpm: rh-python36-2.0-1.el7.src.rpm
location_href: 00878416-rh-python36/rh-python36-scldevel-2.0-1.el7.ppc64le.rpm
checksum_type: sha256
description:
  Package shipping development files, especially usefull for development of
  packages depending on rh-python36 Software Collection.


pkgId: 1edf9c6cdb6844847d7925299d7420c27348803d64bc1395d6b63e4290bb5696
name: rh-python36-selectors2
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Back-ported, durable, and portable selectors
url: https://www.github.com/SethMichaelLarson/selectors2
rpm_license: MIT
rpm_vendor: Seth Michael Larson <sethmichaellarson@protonmail.com>
rpm_group: Development/Libraries
rpm_buildhost: 7ca0bb4b3d6445e0a88358ef5e658899
rpm_sourcerpm: rh-python36-selectors2-2.0.1-1.src.rpm
rpm_packager: Martin Juhl <m@rtinjuhl.dk>
location_href: 00879131-rh-python36-selectors2/rh-python36-selectors2-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Selectors2
  ==========

  .. image:: https://img.shields.io/travis/SethMichaelLarson/selectors2/master.svg?style=flat-square
      :target: https://travis-ci.org/SethMichaelLarson/selectors2
  .. image:: https://img.shields.io/appveyor/ci/SethMichaelLarson/selectors2/master.svg?style=flat-square
      :target: https://ci.appveyor.com/project/SethMichaelLarson/selectors2
  .. image:: https://img.shields.io/pypi/v/selectors2.svg?style=flat-square
      :target: https://pypi.python.org/pypi/selectors2
  .. image:: https://img.shields.io/badge/say-thanks-ff69b4.svg?style=flat-square
      :target: https://saythanks.io/to/SethMichaelLarson

  Backported, durable, and portable selectors designed to replace
  the standard library selectors module.

  Features
  --------

  * Support for all major platforms. (Linux, Mac OS, Windows)
  * Support for Python 2.6 or later and **Jython**.
  * Support many different selectors
      * ``select.kqueue`` (BSD, Mac OS)
      * ``select.devpoll`` (Solaris)
      * ``select.epoll`` (Linux 2.5.44+)
      * ``select.poll`` (Linux, Mac OS)
      * ``select.select`` - (Linux, Mac OS, Windows)
  * Support for `PEP 475 <https://www.python.org/dev/peps/pep-0475/>`_ (Retries system calls on interrupt)
  * Support for modules which monkey-patch the standard library after import (like greenlet, gevent)
  * Support for systems which define a selector being available but don't actually implement it. ()

  About
  -----

  This module was originally written by me for the `urllib3 <https://github.com/shazow/urllib3>`_ project
  (history in PR `#1001 <https://github.com/shazow/urllib3/pull/1001>`_) but it was decided that it would
  be beneficial for everyone to have access to this work.

  All the additional features that ``selectors2`` provides are real-world problems that have occurred
  and been reported during the lifetime of its maintenance and use within ``urllib3``.

  If this work is useful to you, `feel free to say thanks <https://saythanks.io/to/SethMichaelLarson>`_,
  takes only a little time and really brightens my day! :cake:

  Can this module be used in place of ``selectors``?
  --------------------------------------------------

  Yes! This module is a 1-to-1 drop-in replacement for ``selectors`` and
  provides all selector types that would be available in ``selectors`` including
  ``DevpollSelector``, ``KqueueSelector``, ``EpollSelector``, ``PollSelector``, and ``SelectSelector``.

  What is different between `selectors2` and `selectors34`?
  ---------------------------------------------------------

  This module is similar to ``selectors34`` in that it supports Python 2.6 - 3.3
  but differs in that this module also implements PEP 475 for the backported selectors.
  This allows similar behaviour between Python 3.5+ selectors and selectors from before PEP 475.
  In ``selectors34``, an interrupted system call would result in an incorrect return of no events, which
  for some use cases is not an acceptable behavior.

  I will also add here that ``selectors2`` also makes large improvements on the test suite surrounding it
  providing 100% test coverage for each selector.  The test suite is also more robust and tests durability
  of the selectors in many different situations that aren't tested in ``selectors34``.

  What types of objects are supported?
  ------------------------------------

  At this current time ``selectors2`` only support the ``SelectSelector`` for Windows which cannot select on non-socket objects.
  On Linux and Mac OS, both sockets and pipes are supported (some other types may be supported as well, such as fifos or special file devices).

  What if I have to support a platform without ``select.select``?
  ---------------------------------------------------------------

  There are a few platforms that don't have a selector available, notably
  Google AppEngine. When running on those platforms any call to ``DefaultSelector()``
  will raise a ``RuntimeError`` explaining that there are no selectors available.

  License
  -------

  This module is dual-licensed under MIT and PSF License.

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

  ``$ python -m pip install selectors2``

  Usage
  -----
  .. code-block:: python

      import sys
      import selectors2 as selectors

      
      
      s = selectors.DefaultSelector()

      import socket

      
      sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      sock.connect(("www.google.com", 80))

      
      s.register(sock, selectors.EVENT_WRITE)

      
      
      events = s.select(timeout=1.0)

      
      for key, event in events:
          if event & selectors.EVENT_WRITE:
              key.fileobj.send(b'HEAD / HTTP/1.1\r\n\r\n')

      
      s.modify(sock, selectors.EVENT_READ)

      
      events = s.select(timeout=None)
      for key, event in events:
          if event & selectors.EVENT_READ:
              data = key.fileobj.recv(4096)
              print(data)

      
      s.unregister(sock)
      sock.close()


  Changelog
  =========

  Release 2.0.1 (August 17, 2017)
  -------------------------------

  * [BUGFIX] Timeouts would not be properly recalculated after receiving an EINTR error.

  Release 2.0.0 (May 30, 2017)
  ----------------------------

  * [FEATURE] Add support for Jython with ``JythonSelectSelector``.
  * [FEATURE] Add support for ``/dev/devpoll`` with ``DevpollSelector``.
  * [CHANGE] Raises a ``RuntimeError`` instead of ``ValueError`` if there is no selector available.
  * [CHANGE] No longer wraps exceptions in ``SelectorError``, raises original exception including
    in timeout situations.
  * [BUGFIX] Detect defects in a system that defines a selector but does not implement it.
  * [BUGFIX] Can now detect a change in the ``select`` module after import such as when
    ``gevent.monkey.monkey_patch()`` is called before importing ``selectors2``.

  Release 1.1.1 (February 6, 2017)
  --------------------------------

  * [BUGFIX] Platforms that define ``select.kqueue`` would not have ``KqueueSelector`` as the ``DefaultSelector``.

  Release 1.1.0 (January 17, 2017)
  --------------------------------

  * [FEATURE] Make system calls faster for Python versions that support PEP 475.
  * [FEATURE] Wheels are now universal.

  Release 1.0.0 (November 3, 2016)
  --------------------------------

  * Initial implementation of ``selectors2``.


