oss ydb: fix dstool building and test run

8 files changed, 2329 insertions, 0 deletions

diff --git a/contrib/deprecated/python/configparser/.dist-info/METADATA b/contrib/deprecated/python/configparser/.dist-info/METADATA
new file mode 100644
index 0000000000..e805cc962c
--- /dev/null
+++ b/contrib/deprecated/python/configparser/.dist-info/METADATA
@@ -0,0 +1,259 @@
+Metadata-Version: 2.1
+Name: configparser
+Version: 4.0.2
+Summary: Updated configparser from Python 3.7 for Python 2.6+.
+Home-page: https://github.com/jaraco/configparser/
+Author: Łukasz Langa
+Author-email: lukasz@langa.pl
+Maintainer: Jason R. Coombs
+Maintainer-email: jaraco@jaraco.com
+License: UNKNOWN
+Keywords: configparser ini parsing conf cfg configuration file
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=2.6
+Provides-Extra: docs
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: jaraco.packaging (>=3.2) ; extra == 'docs'
+Requires-Dist: rst.linker (>=1.9) ; extra == 'docs'
+Provides-Extra: testing
+Requires-Dist: pytest (!=3.7.3,>=3.5) ; extra == 'testing'
+Requires-Dist: pytest-checkdocs (>=1.2) ; extra == 'testing'
+Requires-Dist: pytest-flake8 ; extra == 'testing'
+Requires-Dist: pytest-black-multipy ; extra == 'testing'
+
+.. image:: https://img.shields.io/pypi/v/configparser.svg
+   :target: https://pypi.org/project/configparser
+
+.. image:: https://img.shields.io/pypi/pyversions/configparser.svg
+
+.. image:: https://img.shields.io/travis/jaraco/configparser/master.svg
+   :target: https://travis-ci.org/jaraco/configparser
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/ambv/black
+   :alt: Code style: Black
+
+.. .. image:: https://img.shields.io/appveyor/ci/jaraco/configparser/master.svg
+..    :target: https://ci.appveyor.com/project/jaraco/configparser/branch/master
+
+.. image:: https://readthedocs.org/projects/configparser/badge/?version=latest
+   :target: https://configparser.readthedocs.io/en/latest/?badge=latest
+
+.. image:: https://tidelift.com/badges/package/pypi/configparser
+   :target: https://tidelift.com/subscription/pkg/pypi-configparser?utm_source=pypi-configparser&utm_medium=readme
+
+
+The ancient ``ConfigParser`` module available in the standard library 2.x has
+seen a major update in Python 3.2. This is a backport of those changes so that
+they can be used directly in Python 2.6 - 3.5.
+
+To use the ``configparser`` backport instead of the built-in version on both
+Python 2 and Python 3, simply import it explicitly as a backport::
+
+  from backports import configparser
+
+If you'd like to use the backport on Python 2 and the built-in version on
+Python 3, use that invocation instead::
+
+  import configparser
+
+For detailed documentation consult the vanilla version at
+http://docs.python.org/3/library/configparser.html.
+
+Why you'll love ``configparser``
+--------------------------------
+
+Whereas almost completely compatible with its older brother, ``configparser``
+sports a bunch of interesting new features:
+
+* full mapping protocol access (`more info
+  <http://docs.python.org/3/library/configparser.html#mapping-protocol-access>`_)::
+
+    >>> parser = ConfigParser()
+    >>> parser.read_string("""
+    [DEFAULT]
+    location = upper left
+    visible = yes
+    editable = no
+    color = blue
+
+    [main]
+    title = Main Menu
+    color = green
+
+    [options]
+    title = Options
+    """)
+    >>> parser['main']['color']
+    'green'
+    >>> parser['main']['editable']
+    'no'
+    >>> section = parser['options']
+    >>> section['title']
+    'Options'
+    >>> section['title'] = 'Options (editable: %(editable)s)'
+    >>> section['title']
+    'Options (editable: no)'
+
+* there's now one default ``ConfigParser`` class, which basically is the old
+  ``SafeConfigParser`` with a bunch of tweaks which make it more predictable for
+  users. Don't need interpolation? Simply use
+  ``ConfigParser(interpolation=None)``, no need to use a distinct
+  ``RawConfigParser`` anymore.
+
+* the parser is highly `customizable upon instantiation
+  <http://docs.python.org/3/library/configparser.html#customizing-parser-behaviour>`__
+  supporting things like changing option delimiters, comment characters, the
+  name of the DEFAULT section, the interpolation syntax, etc.
+
+* you can easily create your own interpolation syntax but there are two powerful
+  implementations built-in (`more info
+  <http://docs.python.org/3/library/configparser.html#interpolation-of-values>`__):
+
+  * the classic ``%(string-like)s`` syntax (called ``BasicInterpolation``)
+
+  * a new ``${buildout:like}`` syntax (called ``ExtendedInterpolation``)
+
+* fallback values may be specified in getters (`more info
+  <http://docs.python.org/3/library/configparser.html#fallback-values>`__)::
+
+    >>> config.get('closet', 'monster',
+    ...            fallback='No such things as monsters')
+    'No such things as monsters'
+
+* ``ConfigParser`` objects can now read data directly `from strings
+  <http://docs.python.org/3/library/configparser.html#configparser.ConfigParser.read_string>`__
+  and `from dictionaries
+  <http://docs.python.org/3/library/configparser.html#configparser.ConfigParser.read_dict>`__.
+  That means importing configuration from JSON or specifying default values for
+  the whole configuration (multiple sections) is now a single line of code. Same
+  goes for copying data from another ``ConfigParser`` instance, thanks to its
+  mapping protocol support.
+
+* many smaller tweaks, updates and fixes
+
+A few words about Unicode
+-------------------------
+
+``configparser`` comes from Python 3 and as such it works well with Unicode.
+The library is generally cleaned up in terms of internal data storage and
+reading/writing files.  There are a couple of incompatibilities with the old
+``ConfigParser`` due to that. However, the work required to migrate is well
+worth it as it shows the issues that would likely come up during migration of
+your project to Python 3.
+
+The design assumes that Unicode strings are used whenever possible [1]_.  That
+gives you the certainty that what's stored in a configuration object is text.
+Once your configuration is read, the rest of your application doesn't have to
+deal with encoding issues. All you have is text [2]_. The only two phases when
+you should explicitly state encoding is when you either read from an external
+source (e.g. a file) or write back.
+
+Versioning
+----------
+
+This project uses `semver <https://semver.org/spec/v2.0.0.html>`_ to
+communicate the impact of various releases while periodically syncing
+with the upstream implementation in CPython.
+`The changelog <https://github.com/jaraco/configparser/blob/master/CHANGES.rst>`_
+serves as a reference indicating which versions incorporate
+which upstream functionality.
+
+Prior to the ``4.0.0`` release, `another scheme
+<https://github.com/jaraco/configparser/blob/3.8.1/README.rst#versioning>`_
+was used to associate the CPython and backports releases.
+
+Maintenance
+-----------
+
+This backport was originally authored by Łukasz Langa, the current vanilla
+``configparser`` maintainer for CPython and is currently maintained by
+Jason R. Coombs:
+
+* `configparser repository <https://github.com/jaraco/configparser>`_
+
+* `configparser issue tracker <https://github.com/jaraco/configparser/issues>`_
+
+Security Contact
+----------------
+
+To report a security vulnerability, please use the
+`Tidelift security contact <https://tidelift.com/security>`_.
+Tidelift will coordinate the fix and disclosure.
+
+Conversion Process
+------------------
+
+This section is technical and should bother you only if you are wondering how
+this backport is produced. If the implementation details of this backport are
+not important for you, feel free to ignore the following content.
+
+``configparser`` is converted using `python-future
+<http://python-future.org>`_. The project takes the following
+branching approach:
+
+* the ``3.x`` branch holds unchanged files synchronized from the upstream
+  CPython repository. The synchronization is currently done by manually copying
+  the required files and stating from which CPython changeset they come from.
+
+* the ``master`` branch holds a version of the ``3.x`` code with some tweaks
+  that make it independent from libraries and constructions unavailable on 2.x.
+  Code on this branch still *must* work on the corresponding Python 3.x but
+  will also work on Python 2.6 and 2.7 (including PyPy).  You can check this
+  running the supplied unit tests with ``tox``.
+
+The process works like this:
+
+1. In the ``3.x`` branch, run ``pip-run -- sync-upstream.py``, which
+   downloads the latest stable release of Python and copies the relevant
+   files from there into their new locations here and then commits those
+   changes with a nice reference to the relevant upstream commit hash.
+
+2. I check for new names in ``__all__`` and update imports in
+   ``configparser.py`` accordingly. I run the tests on Python 3. Commit.
+
+3. I merge the new commit to ``master``. I run ``tox``. Commit.
+
+4. If there are necessary changes, I do them now (on ``master``). Note that
+   the changes should be written in the syntax subset supported by Python
+   2.6.
+
+5. I run ``tox``. If it works, I update the docs and release the new version.
+   Otherwise, I go back to point 3. I might use ``pasteurize`` to suggest me
+   required changes but usually I do them manually to keep resulting code in
+   a nicer form.
+
+
+Footnotes
+---------
+
+.. [1] To somewhat ease migration, passing bytestrings is still supported but
+       they are converted to Unicode for internal storage anyway. This means
+       that for the vast majority of strings used in configuration files, it
+       won't matter if you pass them as bytestrings or Unicode. However, if you
+       pass a bytestring that cannot be converted to Unicode using the naive
+       ASCII codec, a ``UnicodeDecodeError`` will be raised. This is purposeful
+       and helps you manage proper encoding for all content you store in
+       memory, read from various sources and write back.
+
+.. [2] Life gets much easier when you understand that you basically manage
+       **text** in your application.  You don't care about bytes but about
+       letters.  In that regard the concept of content encoding is meaningless.
+       The only time when you deal with raw bytes is when you write the data to
+       a file.  Then you have to specify how your text should be encoded.  On
+       the other end, to get meaningful text from a file, the application
+       reading it has to know which encoding was used during its creation.  But
+       once the bytes are read and properly decoded, all you have is text.  This
+       is especially powerful when you start interacting with multiple data
+       sources.  Even if each of them uses a different encoding, inside your
+       application data is held in abstract text form.  You can program your
+       business logic without worrying about which data came from which source.
+       You can freely exchange the data you store between sources.  Only
+       reading/writing files requires encoding your text to bytes.
+
+
diff --git a/contrib/deprecated/python/configparser/.dist-info/top_level.txt b/contrib/deprecated/python/configparser/.dist-info/top_level.txt
new file mode 100644
index 0000000000..a6cb03ad92
--- /dev/null
+++ b/contrib/deprecated/python/configparser/.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+backports
+configparser
diff --git a/contrib/deprecated/python/configparser/LICENSE b/contrib/deprecated/python/configparser/LICENSE
new file mode 100644
index 0000000000..5e795a61f3
--- /dev/null
+++ b/contrib/deprecated/python/configparser/LICENSE
@@ -0,0 +1,7 @@
+Copyright Jason R. Coombs
+
+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.
diff --git a/contrib/deprecated/python/configparser/README.rst b/contrib/deprecated/python/configparser/README.rst
new file mode 100644
index 0000000000..cfd4859091
--- /dev/null
+++ b/contrib/deprecated/python/configparser/README.rst
@@ -0,0 +1,229 @@
+.. image:: https://img.shields.io/pypi/v/configparser.svg
+   :target: https://pypi.org/project/configparser
+
+.. image:: https://img.shields.io/pypi/pyversions/configparser.svg
+
+.. image:: https://img.shields.io/travis/jaraco/configparser/master.svg
+   :target: https://travis-ci.org/jaraco/configparser
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/ambv/black
+   :alt: Code style: Black
+
+.. .. image:: https://img.shields.io/appveyor/ci/jaraco/configparser/master.svg
+..    :target: https://ci.appveyor.com/project/jaraco/configparser/branch/master
+
+.. image:: https://readthedocs.org/projects/configparser/badge/?version=latest
+   :target: https://configparser.readthedocs.io/en/latest/?badge=latest
+
+.. image:: https://tidelift.com/badges/package/pypi/configparser
+   :target: https://tidelift.com/subscription/pkg/pypi-configparser?utm_source=pypi-configparser&utm_medium=readme
+
+
+The ancient ``ConfigParser`` module available in the standard library 2.x has
+seen a major update in Python 3.2. This is a backport of those changes so that
+they can be used directly in Python 2.6 - 3.5.
+
+To use the ``configparser`` backport instead of the built-in version on both
+Python 2 and Python 3, simply import it explicitly as a backport::
+
+  from backports import configparser
+
+If you'd like to use the backport on Python 2 and the built-in version on
+Python 3, use that invocation instead::
+
+  import configparser
+
+For detailed documentation consult the vanilla version at
+http://docs.python.org/3/library/configparser.html.
+
+Why you'll love ``configparser``
+--------------------------------
+
+Whereas almost completely compatible with its older brother, ``configparser``
+sports a bunch of interesting new features:
+
+* full mapping protocol access (`more info
+  <http://docs.python.org/3/library/configparser.html#mapping-protocol-access>`_)::
+
+    >>> parser = ConfigParser()
+    >>> parser.read_string("""
+    [DEFAULT]
+    location = upper left
+    visible = yes
+    editable = no
+    color = blue
+
+    [main]
+    title = Main Menu
+    color = green
+
+    [options]
+    title = Options
+    """)
+    >>> parser['main']['color']
+    'green'
+    >>> parser['main']['editable']
+    'no'
+    >>> section = parser['options']
+    >>> section['title']
+    'Options'
+    >>> section['title'] = 'Options (editable: %(editable)s)'
+    >>> section['title']
+    'Options (editable: no)'
+
+* there's now one default ``ConfigParser`` class, which basically is the old
+  ``SafeConfigParser`` with a bunch of tweaks which make it more predictable for
+  users. Don't need interpolation? Simply use
+  ``ConfigParser(interpolation=None)``, no need to use a distinct
+  ``RawConfigParser`` anymore.
+
+* the parser is highly `customizable upon instantiation
+  <http://docs.python.org/3/library/configparser.html#customizing-parser-behaviour>`__
+  supporting things like changing option delimiters, comment characters, the
+  name of the DEFAULT section, the interpolation syntax, etc.
+
+* you can easily create your own interpolation syntax but there are two powerful
+  implementations built-in (`more info
+  <http://docs.python.org/3/library/configparser.html#interpolation-of-values>`__):
+
+  * the classic ``%(string-like)s`` syntax (called ``BasicInterpolation``)
+
+  * a new ``${buildout:like}`` syntax (called ``ExtendedInterpolation``)
+
+* fallback values may be specified in getters (`more info
+  <http://docs.python.org/3/library/configparser.html#fallback-values>`__)::
+
+    >>> config.get('closet', 'monster',
+    ...            fallback='No such things as monsters')
+    'No such things as monsters'
+
+* ``ConfigParser`` objects can now read data directly `from strings
+  <http://docs.python.org/3/library/configparser.html#configparser.ConfigParser.read_string>`__
+  and `from dictionaries
+  <http://docs.python.org/3/library/configparser.html#configparser.ConfigParser.read_dict>`__.
+  That means importing configuration from JSON or specifying default values for
+  the whole configuration (multiple sections) is now a single line of code. Same
+  goes for copying data from another ``ConfigParser`` instance, thanks to its
+  mapping protocol support.
+
+* many smaller tweaks, updates and fixes
+
+A few words about Unicode
+-------------------------
+
+``configparser`` comes from Python 3 and as such it works well with Unicode.
+The library is generally cleaned up in terms of internal data storage and
+reading/writing files.  There are a couple of incompatibilities with the old
+``ConfigParser`` due to that. However, the work required to migrate is well
+worth it as it shows the issues that would likely come up during migration of
+your project to Python 3.
+
+The design assumes that Unicode strings are used whenever possible [1]_.  That
+gives you the certainty that what's stored in a configuration object is text.
+Once your configuration is read, the rest of your application doesn't have to
+deal with encoding issues. All you have is text [2]_. The only two phases when
+you should explicitly state encoding is when you either read from an external
+source (e.g. a file) or write back.
+
+Versioning
+----------
+
+This project uses `semver <https://semver.org/spec/v2.0.0.html>`_ to
+communicate the impact of various releases while periodically syncing
+with the upstream implementation in CPython.
+`The changelog <https://github.com/jaraco/configparser/blob/master/CHANGES.rst>`_
+serves as a reference indicating which versions incorporate
+which upstream functionality.
+
+Prior to the ``4.0.0`` release, `another scheme
+<https://github.com/jaraco/configparser/blob/3.8.1/README.rst#versioning>`_
+was used to associate the CPython and backports releases.
+
+Maintenance
+-----------
+
+This backport was originally authored by Łukasz Langa, the current vanilla
+``configparser`` maintainer for CPython and is currently maintained by
+Jason R. Coombs:
+
+* `configparser repository <https://github.com/jaraco/configparser>`_
+
+* `configparser issue tracker <https://github.com/jaraco/configparser/issues>`_
+
+Security Contact
+----------------
+
+To report a security vulnerability, please use the
+`Tidelift security contact <https://tidelift.com/security>`_.
+Tidelift will coordinate the fix and disclosure.
+
+Conversion Process
+------------------
+
+This section is technical and should bother you only if you are wondering how
+this backport is produced. If the implementation details of this backport are
+not important for you, feel free to ignore the following content.
+
+``configparser`` is converted using `python-future
+<http://python-future.org>`_. The project takes the following
+branching approach:
+
+* the ``3.x`` branch holds unchanged files synchronized from the upstream
+  CPython repository. The synchronization is currently done by manually copying
+  the required files and stating from which CPython changeset they come from.
+
+* the ``master`` branch holds a version of the ``3.x`` code with some tweaks
+  that make it independent from libraries and constructions unavailable on 2.x.
+  Code on this branch still *must* work on the corresponding Python 3.x but
+  will also work on Python 2.6 and 2.7 (including PyPy).  You can check this
+  running the supplied unit tests with ``tox``.
+
+The process works like this:
+
+1. In the ``3.x`` branch, run ``pip-run -- sync-upstream.py``, which
+   downloads the latest stable release of Python and copies the relevant
+   files from there into their new locations here and then commits those
+   changes with a nice reference to the relevant upstream commit hash.
+
+2. I check for new names in ``__all__`` and update imports in
+   ``configparser.py`` accordingly. I run the tests on Python 3. Commit.
+
+3. I merge the new commit to ``master``. I run ``tox``. Commit.
+
+4. If there are necessary changes, I do them now (on ``master``). Note that
+   the changes should be written in the syntax subset supported by Python
+   2.6.
+
+5. I run ``tox``. If it works, I update the docs and release the new version.
+   Otherwise, I go back to point 3. I might use ``pasteurize`` to suggest me
+   required changes but usually I do them manually to keep resulting code in
+   a nicer form.
+
+
+Footnotes
+---------
+
+.. [1] To somewhat ease migration, passing bytestrings is still supported but
+       they are converted to Unicode for internal storage anyway. This means
+       that for the vast majority of strings used in configuration files, it
+       won't matter if you pass them as bytestrings or Unicode. However, if you
+       pass a bytestring that cannot be converted to Unicode using the naive
+       ASCII codec, a ``UnicodeDecodeError`` will be raised. This is purposeful
+       and helps you manage proper encoding for all content you store in
+       memory, read from various sources and write back.
+
+.. [2] Life gets much easier when you understand that you basically manage
+       **text** in your application.  You don't care about bytes but about
+       letters.  In that regard the concept of content encoding is meaningless.
+       The only time when you deal with raw bytes is when you write the data to
+       a file.  Then you have to specify how your text should be encoded.  On
+       the other end, to get meaningful text from a file, the application
+       reading it has to know which encoding was used during its creation.  But
+       once the bytes are read and properly decoded, all you have is text.  This
+       is especially powerful when you start interacting with multiple data
+       sources.  Even if each of them uses a different encoding, inside your
+       application data is held in abstract text form.  You can program your
+       business logic without worrying about which data came from which source.
+       You can freely exchange the data you store between sources.  Only
+       reading/writing files requires encoding your text to bytes.
diff --git a/contrib/deprecated/python/configparser/backports/configparser/__init__.py b/contrib/deprecated/python/configparser/backports/configparser/__init__.py
new file mode 100644
index 0000000000..603d604764
--- /dev/null
+++ b/contrib/deprecated/python/configparser/backports/configparser/__init__.py
@@ -0,0 +1,1473 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# flake8: noqa
+
+"""Configuration file parser.
+
+A configuration file consists of sections, lead by a "[section]" header,
+and followed by "name: value" entries, with continuations and such in
+the style of RFC 822.
+
+Intrinsic defaults can be specified by passing them into the
+ConfigParser constructor as a dictionary.
+
+class:
+
+ConfigParser -- responsible for parsing a list of
+                    configuration files, and managing the parsed database.
+
+    methods:
+
+    __init__(defaults=None, dict_type=_default_dict, allow_no_value=False,
+             delimiters=('=', ':'), comment_prefixes=('#', ';'),
+             inline_comment_prefixes=None, strict=True,
+             empty_lines_in_values=True, default_section='DEFAULT',
+             interpolation=<unset>, converters=<unset>):
+        Create the parser. When `defaults' is given, it is initialized into the
+        dictionary or intrinsic defaults. The keys must be strings, the values
+        must be appropriate for %()s string interpolation.
+
+        When `dict_type' is given, it will be used to create the dictionary
+        objects for the list of sections, for the options within a section, and
+        for the default values.
+
+        When `delimiters' is given, it will be used as the set of substrings
+        that divide keys from values.
+
+        When `comment_prefixes' is given, it will be used as the set of
+        substrings that prefix comments in empty lines. Comments can be
+        indented.
+
+        When `inline_comment_prefixes' is given, it will be used as the set of
+        substrings that prefix comments in non-empty lines.
+
+        When `strict` is True, the parser won't allow for any section or option
+        duplicates while reading from a single source (file, string or
+        dictionary). Default is True.
+
+        When `empty_lines_in_values' is False (default: True), each empty line
+        marks the end of an option. Otherwise, internal empty lines of
+        a multiline option are kept as part of the value.
+
+        When `allow_no_value' is True (default: False), options without
+        values are accepted; the value presented for these is None.
+
+        When `default_section' is given, the name of the special section is
+        named accordingly. By default it is called ``"DEFAULT"`` but this can
+        be customized to point to any other valid section name. Its current
+        value can be retrieved using the ``parser_instance.default_section``
+        attribute and may be modified at runtime.
+
+        When `interpolation` is given, it should be an Interpolation subclass
+        instance. It will be used as the handler for option value
+        pre-processing when using getters. RawConfigParser objects don't do
+        any sort of interpolation, whereas ConfigParser uses an instance of
+        BasicInterpolation. The library also provides a ``zc.buildbot``
+        inspired ExtendedInterpolation implementation.
+
+        When `converters` is given, it should be a dictionary where each key
+        represents the name of a type converter and each value is a callable
+        implementing the conversion from string to the desired datatype. Every
+        converter gets its corresponding get*() method on the parser object and
+        section proxies.
+
+    sections()
+        Return all the configuration section names, sans DEFAULT.
+
+    has_section(section)
+        Return whether the given section exists.
+
+    has_option(section, option)
+        Return whether the given option exists in the given section.
+
+    options(section)
+        Return list of configuration options for the named section.
+
+    read(filenames, encoding=None)
+        Read and parse the iterable of named configuration files, given by
+        name.  A single filename is also allowed.  Non-existing files
+        are ignored.  Return list of successfully read files.
+
+    read_file(f, filename=None)
+        Read and parse one configuration file, given as a file object.
+        The filename defaults to f.name; it is only used in error
+        messages (if f has no `name' attribute, the string `<???>' is used).
+
+    read_string(string)
+        Read configuration from a given string.
+
+    read_dict(dictionary)
+        Read configuration from a dictionary. Keys are section names,
+        values are dictionaries with keys and values that should be present
+        in the section. If the used dictionary type preserves order, sections
+        and their keys will be added in order. Values are automatically
+        converted to strings.
+
+    get(section, option, raw=False, vars=None, fallback=_UNSET)
+        Return a string value for the named option.  All % interpolations are
+        expanded in the return values, based on the defaults passed into the
+        constructor and the DEFAULT section.  Additional substitutions may be
+        provided using the `vars' argument, which must be a dictionary whose
+        contents override any pre-existing defaults. If `option' is a key in
+        `vars', the value from `vars' is used.
+
+    getint(section, options, raw=False, vars=None, fallback=_UNSET)
+        Like get(), but convert value to an integer.
+
+    getfloat(section, options, raw=False, vars=None, fallback=_UNSET)
+        Like get(), but convert value to a float.
+
+    getboolean(section, options, raw=False, vars=None, fallback=_UNSET)
+        Like get(), but convert value to a boolean (currently case
+        insensitively defined as 0, false, no, off for False, and 1, true,
+        yes, on for True).  Returns False or True.
+
+    items(section=_UNSET, raw=False, vars=None)
+        If section is given, return a list of tuples with (name, value) for
+        each option in the section. Otherwise, return a list of tuples with
+        (section_name, section_proxy) for each section, including DEFAULTSECT.
+
+    remove_section(section)
+        Remove the given file section and all its options.
+
+    remove_option(section, option)
+        Remove the given option from the given section.
+
+    set(section, option, value)
+        Set the given option.
+
+    write(fp, space_around_delimiters=True)
+        Write the configuration state in .ini format. If
+        `space_around_delimiters' is True (the default), delimiters
+        between keys and values are surrounded by spaces.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+try:
+    from collections.abc import MutableMapping
+except ImportError:
+    from collections import MutableMapping
+import functools
+import io
+import itertools
+import os
+import re
+import sys
+import warnings
+
+from backports.configparser.helpers import OrderedDict as _default_dict
+from backports.configparser.helpers import ChainMap as _ChainMap
+from backports.configparser.helpers import from_none, open, str, PY2
+from backports.configparser.helpers import PathLike, fspath
+from backports.configparser.helpers import MutableMapping
+
+__all__ = [
+    "NoSectionError",
+    "DuplicateOptionError",
+    "DuplicateSectionError",
+    "NoOptionError",
+    "InterpolationError",
+    "InterpolationDepthError",
+    "InterpolationMissingOptionError",
+    "InterpolationSyntaxError",
+    "ParsingError",
+    "MissingSectionHeaderError",
+    "ConfigParser",
+    "SafeConfigParser",
+    "RawConfigParser",
+    "Interpolation",
+    "BasicInterpolation",
+    "ExtendedInterpolation",
+    "LegacyInterpolation",
+    "SectionProxy",
+    "ConverterMapping",
+    "DEFAULTSECT",
+    "MAX_INTERPOLATION_DEPTH",
+]
+
+DEFAULTSECT = "DEFAULT"
+
+MAX_INTERPOLATION_DEPTH = 10
+
+
+# exception classes
+class Error(Exception):
+    """Base class for ConfigParser exceptions."""
+
+    def __init__(self, msg=''):
+        self.message = msg
+        Exception.__init__(self, msg)
+
+    def __repr__(self):
+        return self.message
+
+    __str__ = __repr__
+
+
+class NoSectionError(Error):
+    """Raised when no section matches a requested option."""
+
+    def __init__(self, section):
+        Error.__init__(self, 'No section: %r' % (section,))
+        self.section = section
+        self.args = (section,)
+
+
+class DuplicateSectionError(Error):
+    """Raised when a section is repeated in an input source.
+
+    Possible repetitions that raise this exception are: multiple creation
+    using the API or in strict parsers when a section is found more than once
+    in a single input file, string or dictionary.
+    """
+
+    def __init__(self, section, source=None, lineno=None):
+        msg = [repr(section), " already exists"]
+        if source is not None:
+            message = ["While reading from ", repr(source)]
+            if lineno is not None:
+                message.append(" [line {0:2d}]".format(lineno))
+            message.append(": section ")
+            message.extend(msg)
+            msg = message
+        else:
+            msg.insert(0, "Section ")
+        Error.__init__(self, "".join(msg))
+        self.section = section
+        self.source = source
+        self.lineno = lineno
+        self.args = (section, source, lineno)
+
+
+class DuplicateOptionError(Error):
+    """Raised by strict parsers when an option is repeated in an input source.
+
+    Current implementation raises this exception only when an option is found
+    more than once in a single file, string or dictionary.
+    """
+
+    def __init__(self, section, option, source=None, lineno=None):
+        msg = [repr(option), " in section ", repr(section), " already exists"]
+        if source is not None:
+            message = ["While reading from ", repr(source)]
+            if lineno is not None:
+                message.append(" [line {0:2d}]".format(lineno))
+            message.append(": option ")
+            message.extend(msg)
+            msg = message
+        else:
+            msg.insert(0, "Option ")
+        Error.__init__(self, "".join(msg))
+        self.section = section
+        self.option = option
+        self.source = source
+        self.lineno = lineno
+        self.args = (section, option, source, lineno)
+
+
+class NoOptionError(Error):
+    """A requested option was not found."""
+
+    def __init__(self, option, section):
+        Error.__init__(self, "No option %r in section: %r" % (option, section))
+        self.option = option
+        self.section = section
+        self.args = (option, section)
+
+
+class InterpolationError(Error):
+    """Base class for interpolation-related exceptions."""
+
+    def __init__(self, option, section, msg):
+        Error.__init__(self, msg)
+        self.option = option
+        self.section = section
+        self.args = (option, section, msg)
+
+
+class InterpolationMissingOptionError(InterpolationError):
+    """A string substitution required a setting which was not available."""
+
+    def __init__(self, option, section, rawval, reference):
+        msg = (
+            "Bad value substitution: option {0!r} in section {1!r} contains "
+            "an interpolation key {2!r} which is not a valid option name. "
+            "Raw value: {3!r}".format(option, section, reference, rawval)
+        )
+        InterpolationError.__init__(self, option, section, msg)
+        self.reference = reference
+        self.args = (option, section, rawval, reference)
+
+
+class InterpolationSyntaxError(InterpolationError):
+    """Raised when the source text contains invalid syntax.
+
+    Current implementation raises this exception when the source text into
+    which substitutions are made does not conform to the required syntax.
+    """
+
+
+class InterpolationDepthError(InterpolationError):
+    """Raised when substitutions are nested too deeply."""
+
+    def __init__(self, option, section, rawval):
+        msg = (
+            "Recursion limit exceeded in value substitution: option {0!r} "
+            "in section {1!r} contains an interpolation key which "
+            "cannot be substituted in {2} steps. Raw value: {3!r}"
+            "".format(option, section, MAX_INTERPOLATION_DEPTH, rawval)
+        )
+        InterpolationError.__init__(self, option, section, msg)
+        self.args = (option, section, rawval)
+
+
+class ParsingError(Error):
+    """Raised when a configuration file does not follow legal syntax."""
+
+    def __init__(self, source=None, filename=None):
+        # Exactly one of `source'/`filename' arguments has to be given.
+        # `filename' kept for compatibility.
+        if filename and source:
+            raise ValueError(
+                "Cannot specify both `filename' and `source'. " "Use `source'."
+            )
+        elif not filename and not source:
+            raise ValueError("Required argument `source' not given.")
+        elif filename:
+            source = filename
+        Error.__init__(self, 'Source contains parsing errors: %r' % source)
+        self.source = source
+        self.errors = []
+        self.args = (source,)
+
+    @property
+    def filename(self):
+        """Deprecated, use `source'."""
+        warnings.warn(
+            "The 'filename' attribute will be removed in future versions.  "
+            "Use 'source' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.source
+
+    @filename.setter
+    def filename(self, value):
+        """Deprecated, user `source'."""
+        warnings.warn(
+            "The 'filename' attribute will be removed in future versions.  "
+            "Use 'source' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.source = value
+
+    def append(self, lineno, line):
+        self.errors.append((lineno, line))
+        self.message += '\n\t[line %2d]: %s' % (lineno, line)
+
+
+class MissingSectionHeaderError(ParsingError):
+    """Raised when a key-value pair is found before any section header."""
+
+    def __init__(self, filename, lineno, line):
+        Error.__init__(
+            self,
+            'File contains no section headers.\nfile: %r, line: %d\n%r'
+            % (filename, lineno, line),
+        )
+        self.source = filename
+        self.lineno = lineno
+        self.line = line
+        self.args = (filename, lineno, line)
+
+
+# Used in parser getters to indicate the default behaviour when a specific
+# option is not found it to raise an exception. Created to enable `None' as
+# a valid fallback value.
+_UNSET = object()
+
+
+class Interpolation(object):
+    """Dummy interpolation that passes the value through with no changes."""
+
+    def before_get(self, parser, section, option, value, defaults):
+        return value
+
+    def before_set(self, parser, section, option, value):
+        return value
+
+    def before_read(self, parser, section, option, value):
+        return value
+
+    def before_write(self, parser, section, option, value):
+        return value
+
+
+class BasicInterpolation(Interpolation):
+    """Interpolation as implemented in the classic ConfigParser.
+
+    The option values can contain format strings which refer to other values in
+    the same section, or values in the special default section.
+
+    For example:
+
+        something: %(dir)s/whatever
+
+    would resolve the "%(dir)s" to the value of dir.  All reference
+    expansions are done late, on demand. If a user needs to use a bare % in
+    a configuration file, she can escape it by writing %%. Other % usage
+    is considered a user error and raises `InterpolationSyntaxError'."""
+
+    _KEYCRE = re.compile(r"%\(([^)]+)\)s")
+
+    def before_get(self, parser, section, option, value, defaults):
+        L = []
+        self._interpolate_some(parser, option, L, value, section, defaults, 1)
+        return ''.join(L)
+
+    def before_set(self, parser, section, option, value):
+        tmp_value = value.replace('%%', '')  # escaped percent signs
+        tmp_value = self._KEYCRE.sub('', tmp_value)  # valid syntax
+        if '%' in tmp_value:
+            raise ValueError(
+                "invalid interpolation syntax in %r at "
+                "position %d" % (value, tmp_value.find('%'))
+            )
+        return value
+
+    def _interpolate_some(self, parser, option, accum, rest, section, map, depth):
+        rawval = parser.get(section, option, raw=True, fallback=rest)
+        if depth > MAX_INTERPOLATION_DEPTH:
+            raise InterpolationDepthError(option, section, rawval)
+        while rest:
+            p = rest.find("%")
+            if p < 0:
+                accum.append(rest)
+                return
+            if p > 0:
+                accum.append(rest[:p])
+                rest = rest[p:]
+            # p is no longer used
+            c = rest[1:2]
+            if c == "%":
+                accum.append("%")
+                rest = rest[2:]
+            elif c == "(":
+                m = self._KEYCRE.match(rest)
+                if m is None:
+                    raise InterpolationSyntaxError(
+                        option,
+                        section,
+                        "bad interpolation variable reference %r" % rest,
+                    )
+                var = parser.optionxform(m.group(1))
+                rest = rest[m.end() :]
+                try:
+                    v = map[var]
+                except KeyError:
+                    raise from_none(
+                        InterpolationMissingOptionError(option, section, rawval, var)
+                    )
+                if "%" in v:
+                    self._interpolate_some(
+                        parser, option, accum, v, section, map, depth + 1
+                    )
+                else:
+                    accum.append(v)
+            else:
+                raise InterpolationSyntaxError(
+                    option,
+                    section,
+                    "'%%' must be followed by '%%' or '(', " "found: %r" % (rest,),
+                )
+
+
+class ExtendedInterpolation(Interpolation):
+    """Advanced variant of interpolation, supports the syntax used by
+    `zc.buildout'. Enables interpolation between sections."""
+
+    _KEYCRE = re.compile(r"\$\{([^}]+)\}")
+
+    def before_get(self, parser, section, option, value, defaults):
+        L = []
+        self._interpolate_some(parser, option, L, value, section, defaults, 1)
+        return ''.join(L)
+
+    def before_set(self, parser, section, option, value):
+        tmp_value = value.replace('$$', '')  # escaped dollar signs
+        tmp_value = self._KEYCRE.sub('', tmp_value)  # valid syntax
+        if '$' in tmp_value:
+            raise ValueError(
+                "invalid interpolation syntax in %r at "
+                "position %d" % (value, tmp_value.find('$'))
+            )
+        return value
+
+    def _interpolate_some(self, parser, option, accum, rest, section, map, depth):
+        rawval = parser.get(section, option, raw=True, fallback=rest)
+        if depth > MAX_INTERPOLATION_DEPTH:
+            raise InterpolationDepthError(option, section, rawval)
+        while rest:
+            p = rest.find("$")
+            if p < 0:
+                accum.append(rest)
+                return
+            if p > 0:
+                accum.append(rest[:p])
+                rest = rest[p:]
+            # p is no longer used
+            c = rest[1:2]
+            if c == "$":
+                accum.append("$")
+                rest = rest[2:]
+            elif c == "{":
+                m = self._KEYCRE.match(rest)
+                if m is None:
+                    raise InterpolationSyntaxError(
+                        option,
+                        section,
+                        "bad interpolation variable reference %r" % rest,
+                    )
+                path = m.group(1).split(':')
+                rest = rest[m.end() :]
+                sect = section
+                opt = option
+                try:
+                    if len(path) == 1:
+                        opt = parser.optionxform(path[0])
+                        v = map[opt]
+                    elif len(path) == 2:
+                        sect = path[0]
+                        opt = parser.optionxform(path[1])
+                        v = parser.get(sect, opt, raw=True)
+                    else:
+                        raise InterpolationSyntaxError(
+                            option, section, "More than one ':' found: %r" % (rest,)
+                        )
+                except (KeyError, NoSectionError, NoOptionError):
+                    raise from_none(
+                        InterpolationMissingOptionError(
+                            option, section, rawval, ":".join(path)
+                        )
+                    )
+                if "$" in v:
+                    self._interpolate_some(
+                        parser,
+                        opt,
+                        accum,
+                        v,
+                        sect,
+                        dict(parser.items(sect, raw=True)),
+                        depth + 1,
+                    )
+                else:
+                    accum.append(v)
+            else:
+                raise InterpolationSyntaxError(
+                    option,
+                    section,
+                    "'$' must be followed by '$' or '{', " "found: %r" % (rest,),
+                )
+
+
+class LegacyInterpolation(Interpolation):
+    """Deprecated interpolation used in old versions of ConfigParser.
+    Use BasicInterpolation or ExtendedInterpolation instead."""
+
+    _KEYCRE = re.compile(r"%\(([^)]*)\)s|.")
+
+    def before_get(self, parser, section, option, value, vars):
+        rawval = value
+        depth = MAX_INTERPOLATION_DEPTH
+        while depth:  # Loop through this until it's done
+            depth -= 1
+            if value and "%(" in value:
+                replace = functools.partial(self._interpolation_replace, parser=parser)
+                value = self._KEYCRE.sub(replace, value)
+                try:
+                    value = value % vars
+                except KeyError as e:
+                    raise from_none(
+                        InterpolationMissingOptionError(
+                            option, section, rawval, e.args[0]
+                        )
+                    )
+            else:
+                break
+        if value and "%(" in value:
+            raise InterpolationDepthError(option, section, rawval)
+        return value
+
+    def before_set(self, parser, section, option, value):
+        return value
+
+    @staticmethod
+    def _interpolation_replace(match, parser):
+        s = match.group(1)
+        if s is None:
+            return match.group()
+        else:
+            return "%%(%s)s" % parser.optionxform(s)
+
+
+class RawConfigParser(MutableMapping):
+    """ConfigParser that does not do interpolation."""
+
+    # Regular expressions for parsing section headers and options
+    _SECT_TMPL = r"""
+        \[                                 # [
+        (?P<header>[^]]+)                  # very permissive!
+        \]                                 # ]
+        """
+    _OPT_TMPL = r"""
+        (?P<option>.*?)                    # very permissive!
+        \s*(?P<vi>{delim})\s*              # any number of space/tab,
+                                           # followed by any of the
+                                           # allowed delimiters,
+                                           # followed by any space/tab
+        (?P<value>.*)$                     # everything up to eol
+        """
+    _OPT_NV_TMPL = r"""
+        (?P<option>.*?)                    # very permissive!
+        \s*(?:                             # any number of space/tab,
+        (?P<vi>{delim})\s*                 # optionally followed by
+                                           # any of the allowed
+                                           # delimiters, followed by any
+                                           # space/tab
+        (?P<value>.*))?$                   # everything up to eol
+        """
+    # Interpolation algorithm to be used if the user does not specify another
+    _DEFAULT_INTERPOLATION = Interpolation()
+    # Compiled regular expression for matching sections
+    SECTCRE = re.compile(_SECT_TMPL, re.VERBOSE)
+    # Compiled regular expression for matching options with typical separators
+    OPTCRE = re.compile(_OPT_TMPL.format(delim="=|:"), re.VERBOSE)
+    # Compiled regular expression for matching options with optional values
+    # delimited using typical separators
+    OPTCRE_NV = re.compile(_OPT_NV_TMPL.format(delim="=|:"), re.VERBOSE)
+    # Compiled regular expression for matching leading whitespace in a line
+    NONSPACECRE = re.compile(r"\S")
+    # Possible boolean values in the configuration.
+    BOOLEAN_STATES = {
+        '1': True,
+        'yes': True,
+        'true': True,
+        'on': True,
+        '0': False,
+        'no': False,
+        'false': False,
+        'off': False,
+    }
+
+    def __init__(
+        self, defaults=None, dict_type=_default_dict, allow_no_value=False, **kwargs
+    ):
+
+        # keyword-only arguments
+        delimiters = kwargs.get('delimiters', ('=', ':'))
+        comment_prefixes = kwargs.get('comment_prefixes', ('#', ';'))
+        inline_comment_prefixes = kwargs.get('inline_comment_prefixes', None)
+        strict = kwargs.get('strict', True)
+        empty_lines_in_values = kwargs.get('empty_lines_in_values', True)
+        default_section = kwargs.get('default_section', DEFAULTSECT)
+        interpolation = kwargs.get('interpolation', _UNSET)
+        converters = kwargs.get('converters', _UNSET)
+
+        self._dict = dict_type
+        self._sections = self._dict()
+        self._defaults = self._dict()
+        self._converters = ConverterMapping(self)
+        self._proxies = self._dict()
+        self._proxies[default_section] = SectionProxy(self, default_section)
+        self._delimiters = tuple(delimiters)
+        if delimiters == ('=', ':'):
+            self._optcre = self.OPTCRE_NV if allow_no_value else self.OPTCRE
+        else:
+            d = "|".join(re.escape(d) for d in delimiters)
+            if allow_no_value:
+                self._optcre = re.compile(self._OPT_NV_TMPL.format(delim=d), re.VERBOSE)
+            else:
+                self._optcre = re.compile(self._OPT_TMPL.format(delim=d), re.VERBOSE)
+        self._comment_prefixes = tuple(comment_prefixes or ())
+        self._inline_comment_prefixes = tuple(inline_comment_prefixes or ())
+        self._strict = strict
+        self._allow_no_value = allow_no_value
+        self._empty_lines_in_values = empty_lines_in_values
+        self.default_section = default_section
+        self._interpolation = interpolation
+        if self._interpolation is _UNSET:
+            self._interpolation = self._DEFAULT_INTERPOLATION
+        if self._interpolation is None:
+            self._interpolation = Interpolation()
+        if converters is not _UNSET:
+            self._converters.update(converters)
+        if defaults:
+            self._read_defaults(defaults)
+
+    def defaults(self):
+        return self._defaults
+
+    def sections(self):
+        """Return a list of section names, excluding [DEFAULT]"""
+        # self._sections will never have [DEFAULT] in it
+        return list(self._sections.keys())
+
+    def add_section(self, section):
+        """Create a new section in the configuration.
+
+        Raise DuplicateSectionError if a section by the specified name
+        already exists. Raise ValueError if name is DEFAULT.
+        """
+        if section == self.default_section:
+            raise ValueError('Invalid section name: %r' % section)
+
+        if section in self._sections:
+            raise DuplicateSectionError(section)
+        self._sections[section] = self._dict()
+        self._proxies[section] = SectionProxy(self, section)
+
+    def has_section(self, section):
+        """Indicate whether the named section is present in the configuration.
+
+        The DEFAULT section is not acknowledged.
+        """
+        return section in self._sections
+
+    def options(self, section):
+        """Return a list of option names for the given section name."""
+        try:
+            opts = self._sections[section].copy()
+        except KeyError:
+            raise from_none(NoSectionError(section))
+        opts.update(self._defaults)
+        return list(opts.keys())
+
+    def read(self, filenames, encoding=None):
+        """Read and parse a filename or an iterable of filenames.
+
+        Files that cannot be opened are silently ignored; this is
+        designed so that you can specify an iterable of potential
+        configuration file locations (e.g. current directory, user's
+        home directory, systemwide directory), and all existing
+        configuration files in the iterable will be read.  A single
+        filename may also be given.
+
+        Return list of successfully read files.
+        """
+        if isinstance(filenames, (str, bytes, PathLike)):
+            filenames = [filenames]
+        read_ok = []
+        for filename in filenames:
+            if isinstance(filename, PathLike):
+                filename = fspath(filename)
+            try:
+                with open(filename, encoding=encoding) as fp:
+                    self._read(fp, filename)
+            except IOError:
+                continue
+            read_ok.append(filename)
+        return read_ok
+
+    def read_file(self, f, source=None):
+        """Like read() but the argument must be a file-like object.
+
+        The `f' argument must be iterable, returning one line at a time.
+        Optional second argument is the `source' specifying the name of the
+        file being read. If not given, it is taken from f.name. If `f' has no
+        `name' attribute, `<???>' is used.
+        """
+        if source is None:
+            try:
+                source = f.name
+            except AttributeError:
+                source = '<???>'
+        self._read(f, source)
+
+    def read_string(self, string, source='<string>'):
+        """Read configuration from a given string."""
+        sfile = io.StringIO(string)
+        self.read_file(sfile, source)
+
+    def read_dict(self, dictionary, source='<dict>'):
+        """Read configuration from a dictionary.
+
+        Keys are section names, values are dictionaries with keys and values
+        that should be present in the section. If the used dictionary type
+        preserves order, sections and their keys will be added in order.
+
+        All types held in the dictionary are converted to strings during
+        reading, including section names, option names and keys.
+
+        Optional second argument is the `source' specifying the name of the
+        dictionary being read.
+        """
+        elements_added = set()
+        for section, keys in dictionary.items():
+            section = str(section)
+            try:
+                self.add_section(section)
+            except (DuplicateSectionError, ValueError):
+                if self._strict and section in elements_added:
+                    raise
+            elements_added.add(section)
+            for key, value in keys.items():
+                key = self.optionxform(str(key))
+                if value is not None:
+                    value = str(value)
+                if self._strict and (section, key) in elements_added:
+                    raise DuplicateOptionError(section, key, source)
+                elements_added.add((section, key))
+                self.set(section, key, value)
+
+    def readfp(self, fp, filename=None):
+        """Deprecated, use read_file instead."""
+        warnings.warn(
+            "This method will be removed in future versions.  "
+            "Use 'parser.read_file()' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.read_file(fp, source=filename)
+
+    def get(self, section, option, **kwargs):
+        """Get an option value for a given section.
+
+        If `vars' is provided, it must be a dictionary. The option is looked up
+        in `vars' (if provided), `section', and in `DEFAULTSECT' in that order.
+        If the key is not found and `fallback' is provided, it is used as
+        a fallback value. `None' can be provided as a `fallback' value.
+
+        If interpolation is enabled and the optional argument `raw' is False,
+        all interpolations are expanded in the return values.
+
+        Arguments `raw', `vars', and `fallback' are keyword only.
+
+        The section DEFAULT is special.
+        """
+        # keyword-only arguments
+        raw = kwargs.get('raw', False)
+        vars = kwargs.get('vars', None)
+        fallback = kwargs.get('fallback', _UNSET)
+
+        try:
+            d = self._unify_values(section, vars)
+        except NoSectionError:
+            if fallback is _UNSET:
+                raise
+            else:
+                return fallback
+        option = self.optionxform(option)
+        try:
+            value = d[option]
+        except KeyError:
+            if fallback is _UNSET:
+                raise NoOptionError(option, section)
+            else:
+                return fallback
+
+        if raw or value is None:
+            return value
+        else:
+            return self._interpolation.before_get(self, section, option, value, d)
+
+    def _get(self, section, conv, option, **kwargs):
+        return conv(self.get(section, option, **kwargs))
+
+    def _get_conv(self, section, option, conv, **kwargs):
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        fallback = kwargs.pop('fallback', _UNSET)
+        try:
+            return self._get(section, conv, option, **kwargs)
+        except (NoSectionError, NoOptionError):
+            if fallback is _UNSET:
+                raise
+            return fallback
+
+    # getint, getfloat and getboolean provided directly for backwards compat
+    def getint(self, section, option, **kwargs):
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        kwargs.setdefault('fallback', _UNSET)
+        return self._get_conv(section, option, int, **kwargs)
+
+    def getfloat(self, section, option, **kwargs):
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        kwargs.setdefault('fallback', _UNSET)
+        return self._get_conv(section, option, float, **kwargs)
+
+    def getboolean(self, section, option, **kwargs):
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        kwargs.setdefault('fallback', _UNSET)
+        return self._get_conv(section, option, self._convert_to_boolean, **kwargs)
+
+    def items(self, section=_UNSET, raw=False, vars=None):
+        """Return a list of (name, value) tuples for each option in a section.
+
+        All % interpolations are expanded in the return values, based on the
+        defaults passed into the constructor, unless the optional argument
+        `raw' is true.  Additional substitutions may be provided using the
+        `vars' argument, which must be a dictionary whose contents overrides
+        any pre-existing defaults.
+
+        The section DEFAULT is special.
+        """
+        if section is _UNSET:
+            return super(RawConfigParser, self).items()
+        d = self._defaults.copy()
+        try:
+            d.update(self._sections[section])
+        except KeyError:
+            if section != self.default_section:
+                raise NoSectionError(section)
+        orig_keys = list(d.keys())
+        # Update with the entry specific variables
+        if vars:
+            for key, value in vars.items():
+                d[self.optionxform(key)] = value
+        value_getter = lambda option: self._interpolation.before_get(
+            self, section, option, d[option], d
+        )
+        if raw:
+            value_getter = lambda option: d[option]
+        return [(option, value_getter(option)) for option in orig_keys]
+
+    def popitem(self):
+        """Remove a section from the parser and return it as
+        a (section_name, section_proxy) tuple. If no section is present, raise
+        KeyError.
+
+        The section DEFAULT is never returned because it cannot be removed.
+        """
+        for key in self.sections():
+            value = self[key]
+            del self[key]
+            return key, value
+        raise KeyError
+
+    def optionxform(self, optionstr):
+        return optionstr.lower()
+
+    def has_option(self, section, option):
+        """Check for the existence of a given option in a given section.
+        If the specified `section' is None or an empty string, DEFAULT is
+        assumed. If the specified `section' does not exist, returns False."""
+        if not section or section == self.default_section:
+            option = self.optionxform(option)
+            return option in self._defaults
+        elif section not in self._sections:
+            return False
+        else:
+            option = self.optionxform(option)
+            return option in self._sections[section] or option in self._defaults
+
+    def set(self, section, option, value=None):
+        """Set an option."""
+        if value:
+            value = self._interpolation.before_set(self, section, option, value)
+        if not section or section == self.default_section:
+            sectdict = self._defaults
+        else:
+            try:
+                sectdict = self._sections[section]
+            except KeyError:
+                raise from_none(NoSectionError(section))
+        sectdict[self.optionxform(option)] = value
+
+    def write(self, fp, space_around_delimiters=True):
+        """Write an .ini-format representation of the configuration state.
+
+        If `space_around_delimiters' is True (the default), delimiters
+        between keys and values are surrounded by spaces.
+        """
+        if space_around_delimiters:
+            d = " {0} ".format(self._delimiters[0])
+        else:
+            d = self._delimiters[0]
+        if self._defaults:
+            self._write_section(fp, self.default_section, self._defaults.items(), d)
+        for section in self._sections:
+            self._write_section(fp, section, self._sections[section].items(), d)
+
+    def _write_section(self, fp, section_name, section_items, delimiter):
+        """Write a single section to the specified `fp'."""
+        fp.write("[{0}]\n".format(section_name))
+        for key, value in section_items:
+            value = self._interpolation.before_write(self, section_name, key, value)
+            if value is not None or not self._allow_no_value:
+                value = delimiter + str(value).replace('\n', '\n\t')
+            else:
+                value = ""
+            fp.write("{0}{1}\n".format(key, value))
+        fp.write("\n")
+
+    def remove_option(self, section, option):
+        """Remove an option."""
+        if not section or section == self.default_section:
+            sectdict = self._defaults
+        else:
+            try:
+                sectdict = self._sections[section]
+            except KeyError:
+                raise from_none(NoSectionError(section))
+        option = self.optionxform(option)
+        existed = option in sectdict
+        if existed:
+            del sectdict[option]
+        return existed
+
+    def remove_section(self, section):
+        """Remove a file section."""
+        existed = section in self._sections
+        if existed:
+            del self._sections[section]
+            del self._proxies[section]
+        return existed
+
+    def __getitem__(self, key):
+        if key != self.default_section and not self.has_section(key):
+            raise KeyError(key)
+        return self._proxies[key]
+
+    def __setitem__(self, key, value):
+        # To conform with the mapping protocol, overwrites existing values in
+        # the section.
+        if key in self and self[key] is value:
+            return
+        # XXX this is not atomic if read_dict fails at any point. Then again,
+        # no update method in configparser is atomic in this implementation.
+        if key == self.default_section:
+            self._defaults.clear()
+        elif key in self._sections:
+            self._sections[key].clear()
+        self.read_dict({key: value})
+
+    def __delitem__(self, key):
+        if key == self.default_section:
+            raise ValueError("Cannot remove the default section.")
+        if not self.has_section(key):
+            raise KeyError(key)
+        self.remove_section(key)
+
+    def __contains__(self, key):
+        return key == self.default_section or self.has_section(key)
+
+    def __len__(self):
+        return len(self._sections) + 1  # the default section
+
+    def __iter__(self):
+        # XXX does it break when underlying container state changed?
+        return itertools.chain((self.default_section,), self._sections.keys())
+
+    def _read(self, fp, fpname):
+        """Parse a sectioned configuration file.
+
+        Each section in a configuration file contains a header, indicated by
+        a name in square brackets (`[]'), plus key/value options, indicated by
+        `name' and `value' delimited with a specific substring (`=' or `:' by
+        default).
+
+        Values can span multiple lines, as long as they are indented deeper
+        than the first line of the value. Depending on the parser's mode, blank
+        lines may be treated as parts of multiline values or ignored.
+
+        Configuration files may include comments, prefixed by specific
+        characters (`#' and `;' by default). Comments may appear on their own
+        in an otherwise empty line or may be entered in lines holding values or
+        section names.
+        """
+        elements_added = set()
+        cursect = None  # None, or a dictionary
+        sectname = None
+        optname = None
+        lineno = 0
+        indent_level = 0
+        e = None  # None, or an exception
+        for lineno, line in enumerate(fp, start=1):
+            comment_start = sys.maxsize
+            # strip inline comments
+            inline_prefixes = dict((p, -1) for p in self._inline_comment_prefixes)
+            while comment_start == sys.maxsize and inline_prefixes:
+                next_prefixes = {}
+                for prefix, index in inline_prefixes.items():
+                    index = line.find(prefix, index + 1)
+                    if index == -1:
+                        continue
+                    next_prefixes[prefix] = index
+                    if index == 0 or (index > 0 and line[index - 1].isspace()):
+                        comment_start = min(comment_start, index)
+                inline_prefixes = next_prefixes
+            # strip full line comments
+            for prefix in self._comment_prefixes:
+                if line.strip().startswith(prefix):
+                    comment_start = 0
+                    break
+            if comment_start == sys.maxsize:
+                comment_start = None
+            value = line[:comment_start].strip()
+            if not value:
+                if self._empty_lines_in_values:
+                    # add empty line to the value, but only if there was no
+                    # comment on the line
+                    if (
+                        comment_start is None
+                        and cursect is not None
+                        and optname
+                        and cursect[optname] is not None
+                    ):
+                        cursect[optname].append('')  # newlines added at join
+                else:
+                    # empty line marks end of value
+                    indent_level = sys.maxsize
+                continue
+            # continuation line?
+            first_nonspace = self.NONSPACECRE.search(line)
+            cur_indent_level = first_nonspace.start() if first_nonspace else 0
+            if cursect is not None and optname and cur_indent_level > indent_level:
+                cursect[optname].append(value)
+            # a section header or option header?
+            else:
+                indent_level = cur_indent_level
+                # is it a section header?
+                mo = self.SECTCRE.match(value)
+                if mo:
+                    sectname = mo.group('header')
+                    if sectname in self._sections:
+                        if self._strict and sectname in elements_added:
+                            raise DuplicateSectionError(sectname, fpname, lineno)
+                        cursect = self._sections[sectname]
+                        elements_added.add(sectname)
+                    elif sectname == self.default_section:
+                        cursect = self._defaults
+                    else:
+                        cursect = self._dict()
+                        self._sections[sectname] = cursect
+                        self._proxies[sectname] = SectionProxy(self, sectname)
+                        elements_added.add(sectname)
+                    # So sections can't start with a continuation line
+                    optname = None
+                # no section header in the file?
+                elif cursect is None:
+                    raise MissingSectionHeaderError(fpname, lineno, line)
+                # an option line?
+                else:
+                    mo = self._optcre.match(value)
+                    if mo:
+                        optname, vi, optval = mo.group('option', 'vi', 'value')
+                        if not optname:
+                            e = self._handle_error(e, fpname, lineno, line)
+                        optname = self.optionxform(optname.rstrip())
+                        if self._strict and (sectname, optname) in elements_added:
+                            raise DuplicateOptionError(
+                                sectname, optname, fpname, lineno
+                            )
+                        elements_added.add((sectname, optname))
+                        # This check is fine because the OPTCRE cannot
+                        # match if it would set optval to None
+                        if optval is not None:
+                            optval = optval.strip()
+                            cursect[optname] = [optval]
+                        else:
+                            # valueless option handling
+                            cursect[optname] = None
+                    else:
+                        # a non-fatal parsing error occurred. set up the
+                        # exception but keep going. the exception will be
+                        # raised at the end of the file and will contain a
+                        # list of all bogus lines
+                        e = self._handle_error(e, fpname, lineno, line)
+        self._join_multiline_values()
+        # if any parsing errors occurred, raise an exception
+        if e:
+            raise e
+
+    def _join_multiline_values(self):
+        defaults = self.default_section, self._defaults
+        all_sections = itertools.chain((defaults,), self._sections.items())
+        for section, options in all_sections:
+            for name, val in options.items():
+                if isinstance(val, list):
+                    val = '\n'.join(val).rstrip()
+                options[name] = self._interpolation.before_read(
+                    self, section, name, val
+                )
+
+    def _read_defaults(self, defaults):
+        """Read the defaults passed in the initializer.
+        Note: values can be non-string."""
+        for key, value in defaults.items():
+            self._defaults[self.optionxform(key)] = value
+
+    def _handle_error(self, exc, fpname, lineno, line):
+        if not exc:
+            exc = ParsingError(fpname)
+        exc.append(lineno, repr(line))
+        return exc
+
+    def _unify_values(self, section, vars):
+        """Create a sequence of lookups with 'vars' taking priority over
+        the 'section' which takes priority over the DEFAULTSECT.
+
+        """
+        sectiondict = {}
+        try:
+            sectiondict = self._sections[section]
+        except KeyError:
+            if section != self.default_section:
+                raise NoSectionError(section)
+        # Update with the entry specific variables
+        vardict = {}
+        if vars:
+            for key, value in vars.items():
+                if value is not None:
+                    value = str(value)
+                vardict[self.optionxform(key)] = value
+        return _ChainMap(vardict, sectiondict, self._defaults)
+
+    def _convert_to_boolean(self, value):
+        """Return a boolean value translating from other types if necessary.
+        """
+        if value.lower() not in self.BOOLEAN_STATES:
+            raise ValueError('Not a boolean: %s' % value)
+        return self.BOOLEAN_STATES[value.lower()]
+
+    def _validate_value_types(self, **kwargs):
+        """Raises a TypeError for non-string values.
+
+        The only legal non-string value if we allow valueless
+        options is None, so we need to check if the value is a
+        string if:
+        - we do not allow valueless options, or
+        - we allow valueless options but the value is not None
+
+        For compatibility reasons this method is not used in classic set()
+        for RawConfigParsers. It is invoked in every case for mapping protocol
+        access and in ConfigParser.set().
+        """
+        # keyword-only arguments
+        section = kwargs.get('section', "")
+        option = kwargs.get('option', "")
+        value = kwargs.get('value', "")
+
+        if PY2 and bytes in (type(section), type(option), type(value)):
+            # we allow for a little unholy magic for Python 2 so that
+            # people not using unicode_literals can still use the library
+            # conveniently
+            warnings.warn(
+                "You passed a bytestring. Implicitly decoding as UTF-8 string."
+                " This will not work on Python 3. Please switch to using"
+                " Unicode strings across the board.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            if isinstance(section, bytes):
+                section = section.decode('utf8')
+            if isinstance(option, bytes):
+                option = option.decode('utf8')
+            if isinstance(value, bytes):
+                value = value.decode('utf8')
+
+        if not isinstance(section, str):
+            raise TypeError("section names must be strings")
+        if not isinstance(option, str):
+            raise TypeError("option keys must be strings")
+        if not self._allow_no_value or value:
+            if not isinstance(value, str):
+                raise TypeError("option values must be strings")
+
+        return section, option, value
+
+    @property
+    def converters(self):
+        return self._converters
+
+
+class ConfigParser(RawConfigParser):
+    """ConfigParser implementing interpolation."""
+
+    _DEFAULT_INTERPOLATION = BasicInterpolation()
+
+    def set(self, section, option, value=None):
+        """Set an option.  Extends RawConfigParser.set by validating type and
+        interpolation syntax on the value."""
+        _, option, value = self._validate_value_types(option=option, value=value)
+        super(ConfigParser, self).set(section, option, value)
+
+    def add_section(self, section):
+        """Create a new section in the configuration.  Extends
+        RawConfigParser.add_section by validating if the section name is
+        a string."""
+        section, _, _ = self._validate_value_types(section=section)
+        super(ConfigParser, self).add_section(section)
+
+    def _read_defaults(self, defaults):
+        """Reads the defaults passed in the initializer, implicitly converting
+        values to strings like the rest of the API.
+
+        Does not perform interpolation for backwards compatibility.
+        """
+        try:
+            hold_interpolation = self._interpolation
+            self._interpolation = Interpolation()
+            self.read_dict({self.default_section: defaults})
+        finally:
+            self._interpolation = hold_interpolation
+
+
+class SafeConfigParser(ConfigParser):
+    """ConfigParser alias for backwards compatibility purposes."""
+
+    def __init__(self, *args, **kwargs):
+        super(SafeConfigParser, self).__init__(*args, **kwargs)
+        warnings.warn(
+            "The SafeConfigParser class has been renamed to ConfigParser "
+            "in Python 3.2. This alias will be removed in future versions."
+            " Use ConfigParser directly instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+
+class SectionProxy(MutableMapping):
+    """A proxy for a single section from a parser."""
+
+    def __init__(self, parser, name):
+        """Creates a view on a section of the specified `name` in `parser`."""
+        self._parser = parser
+        self._name = name
+        for conv in parser.converters:
+            key = 'get' + conv
+            getter = functools.partial(self.get, _impl=getattr(parser, key))
+            setattr(self, key, getter)
+
+    def __repr__(self):
+        return '<Section: {0}>'.format(self._name)
+
+    def __getitem__(self, key):
+        if not self._parser.has_option(self._name, key):
+            raise KeyError(key)
+        return self._parser.get(self._name, key)
+
+    def __setitem__(self, key, value):
+        _, key, value = self._parser._validate_value_types(option=key, value=value)
+        return self._parser.set(self._name, key, value)
+
+    def __delitem__(self, key):
+        if not (
+            self._parser.has_option(self._name, key)
+            and self._parser.remove_option(self._name, key)
+        ):
+            raise KeyError(key)
+
+    def __contains__(self, key):
+        return self._parser.has_option(self._name, key)
+
+    def __len__(self):
+        return len(self._options())
+
+    def __iter__(self):
+        return self._options().__iter__()
+
+    def _options(self):
+        if self._name != self._parser.default_section:
+            return self._parser.options(self._name)
+        else:
+            return self._parser.defaults()
+
+    @property
+    def parser(self):
+        # The parser object of the proxy is read-only.
+        return self._parser
+
+    @property
+    def name(self):
+        # The name of the section on a proxy is read-only.
+        return self._name
+
+    def get(self, option, fallback=None, **kwargs):
+        """Get an option value.
+
+        Unless `fallback` is provided, `None` will be returned if the option
+        is not found.
+
+        """
+        # keyword-only arguments
+        kwargs.setdefault('raw', False)
+        kwargs.setdefault('vars', None)
+        _impl = kwargs.pop('_impl', None)
+        # If `_impl` is provided, it should be a getter method on the parser
+        # object that provides the desired type conversion.
+        if not _impl:
+            _impl = self._parser.get
+        return _impl(self._name, option, fallback=fallback, **kwargs)
+
+
+class ConverterMapping(MutableMapping):
+    """Enables reuse of get*() methods between the parser and section proxies.
+
+    If a parser class implements a getter directly, the value for the given
+    key will be ``None``. The presence of the converter name here enables
+    section proxies to find and use the implementation on the parser class.
+    """
+
+    GETTERCRE = re.compile(r"^get(?P<name>.+)$")
+
+    def __init__(self, parser):
+        self._parser = parser
+        self._data = {}
+        for getter in dir(self._parser):
+            m = self.GETTERCRE.match(getter)
+            if not m or not callable(getattr(self._parser, getter)):
+                continue
+            self._data[m.group('name')] = None  # See class docstring.
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __setitem__(self, key, value):
+        try:
+            k = 'get' + key
+        except TypeError:
+            raise ValueError(
+                'Incompatible key: {} (type: {})' ''.format(key, type(key))
+            )
+        if k == 'get':
+            raise ValueError('Incompatible key: cannot use "" as a name')
+        self._data[key] = value
+        func = functools.partial(self._parser._get_conv, conv=value)
+        func.converter = value
+        setattr(self._parser, k, func)
+        for proxy in self._parser.values():
+            getter = functools.partial(proxy.get, _impl=func)
+            setattr(proxy, k, getter)
+
+    def __delitem__(self, key):
+        try:
+            k = 'get' + (key or None)
+        except TypeError:
+            raise KeyError(key)
+        del self._data[key]
+        for inst in itertools.chain((self._parser,), self._parser.values()):
+            try:
+                delattr(inst, k)
+            except AttributeError:
+                # don't raise since the entry was present in _data, silently
+                # clean up
+                continue
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __len__(self):
+        return len(self._data)
diff --git a/contrib/deprecated/python/configparser/backports/configparser/helpers.py b/contrib/deprecated/python/configparser/backports/configparser/helpers.py
new file mode 100644
index 0000000000..e7eb72243f
--- /dev/null
+++ b/contrib/deprecated/python/configparser/backports/configparser/helpers.py
@@ -0,0 +1,274 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import abc
+import os
+
+try:
+    from collections.abc import MutableMapping
+except ImportError:
+    from collections import MutableMapping
+
+try:
+    from collections import UserDict
+except ImportError:
+    from UserDict import UserDict
+
+try:
+    from collections import OrderedDict
+except ImportError:
+    from ordereddict import OrderedDict
+
+try:
+    import pathlib
+except ImportError:
+    pathlib = None
+
+from io import open
+import sys
+
+try:
+    from thread import get_ident
+except ImportError:
+    try:
+        from _thread import get_ident
+    except ImportError:
+        from _dummy_thread import get_ident
+
+
+__all__ = ['UserDict', 'OrderedDict', 'open']
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+native_str = str
+str = type('str')
+
+
+def from_none(exc):
+    """raise from_none(ValueError('a')) == raise ValueError('a') from None"""
+    exc.__cause__ = None
+    exc.__suppress_context__ = True
+    return exc
+
+
+# from reprlib 3.2.1
+def recursive_repr(fillvalue='...'):
+    'Decorator to make a repr function return fillvalue for a recursive call'
+
+    def decorating_function(user_function):
+        repr_running = set()
+
+        def wrapper(self):
+            key = id(self), get_ident()
+            if key in repr_running:
+                return fillvalue
+            repr_running.add(key)
+            try:
+                result = user_function(self)
+            finally:
+                repr_running.discard(key)
+            return result
+
+        # Can't use functools.wraps() here because of bootstrap issues
+        wrapper.__module__ = getattr(user_function, '__module__')
+        wrapper.__doc__ = getattr(user_function, '__doc__')
+        wrapper.__name__ = getattr(user_function, '__name__')
+        wrapper.__annotations__ = getattr(user_function, '__annotations__', {})
+        return wrapper
+
+    return decorating_function
+
+
+# from collections 3.2.1
+class _ChainMap(MutableMapping):
+    ''' A ChainMap groups multiple dicts (or other mappings) together
+    to create a single, updateable view.
+
+    The underlying mappings are stored in a list.  That list is public and can
+    accessed or updated using the *maps* attribute.  There is no other state.
+
+    Lookups search the underlying mappings successively until a key is found.
+    In contrast, writes, updates, and deletions only operate on the first
+    mapping.
+
+    '''
+
+    def __init__(self, *maps):
+        '''Initialize a ChainMap by setting *maps* to the given mappings.
+        If no mappings are provided, a single empty dictionary is used.
+
+        '''
+        self.maps = list(maps) or [{}]  # always at least one map
+
+    def __missing__(self, key):
+        raise KeyError(key)
+
+    def __getitem__(self, key):
+        for mapping in self.maps:
+            try:
+                # can't use 'key in mapping' with defaultdict
+                return mapping[key]
+            except KeyError:
+                pass
+        # support subclasses that define __missing__
+        return self.__missing__(key)
+
+    def get(self, key, default=None):
+        return self[key] if key in self else default
+
+    def __len__(self):
+        # reuses stored hash values if possible
+        return len(set().union(*self.maps))
+
+    def __iter__(self):
+        return iter(set().union(*self.maps))
+
+    def __contains__(self, key):
+        return any(key in m for m in self.maps)
+
+    @recursive_repr()
+    def __repr__(self):
+        return '{0.__class__.__name__}({1})'.format(
+            self, ', '.join(map(repr, self.maps))
+        )
+
+    @classmethod
+    def fromkeys(cls, iterable, *args):
+        'Create a ChainMap with a single dict created from the iterable.'
+        return cls(dict.fromkeys(iterable, *args))
+
+    def copy(self):
+        """
+        New ChainMap or subclass with a new copy of
+        maps[0] and refs to maps[1:]
+        """
+        return self.__class__(self.maps[0].copy(), *self.maps[1:])
+
+    __copy__ = copy
+
+    def new_child(self):  # like Django's Context.push()
+        'New ChainMap with a new dict followed by all previous maps.'
+        return self.__class__({}, *self.maps)
+
+    @property
+    def parents(self):  # like Django's Context.pop()
+        'New ChainMap from maps[1:].'
+        return self.__class__(*self.maps[1:])
+
+    def __setitem__(self, key, value):
+        self.maps[0][key] = value
+
+    def __delitem__(self, key):
+        try:
+            del self.maps[0][key]
+        except KeyError:
+            raise KeyError('Key not found in the first mapping: {!r}'.format(key))
+
+    def popitem(self):
+        """
+        Remove and return an item pair from maps[0].
+        Raise KeyError is maps[0] is empty.
+        """
+        try:
+            return self.maps[0].popitem()
+        except KeyError:
+            raise KeyError('No keys found in the first mapping.')
+
+    def pop(self, key, *args):
+        """
+        Remove *key* from maps[0] and return its value.
+        Raise KeyError if *key* not in maps[0].
+        """
+
+        try:
+            return self.maps[0].pop(key, *args)
+        except KeyError:
+            raise KeyError('Key not found in the first mapping: {!r}'.format(key))
+
+    def clear(self):
+        'Clear maps[0], leaving maps[1:] intact.'
+        self.maps[0].clear()
+
+
+try:
+    from collections import ChainMap
+except ImportError:
+    ChainMap = _ChainMap
+
+
+_ABC = getattr(
+    abc,
+    'ABC',
+    # Python 3.3 compatibility
+    abc.ABCMeta(native_str('__ABC'), (object,), dict(__metaclass__=abc.ABCMeta)),
+)
+
+
+class _PathLike(_ABC):
+
+    """Abstract base class for implementing the file system path protocol."""
+
+    @abc.abstractmethod
+    def __fspath__(self):
+        """Return the file system path representation of the object."""
+        raise NotImplementedError
+
+    @classmethod
+    def __subclasshook__(cls, subclass):
+        return bool(
+            hasattr(subclass, '__fspath__')
+            # workaround for Python 3.5
+            or pathlib
+            and issubclass(subclass, pathlib.Path)
+        )
+
+
+PathLike = getattr(os, 'PathLike', _PathLike)
+
+
+def _fspath(path):
+    """Return the path representation of a path-like object.
+
+    If str or bytes is passed in, it is returned unchanged. Otherwise the
+    os.PathLike interface is used to get the path representation. If the
+    path representation is not str or bytes, TypeError is raised. If the
+    provided path is not str, bytes, or os.PathLike, TypeError is raised.
+    """
+    if isinstance(path, (str, bytes)):
+        return path
+
+    if not hasattr(path, '__fspath__') and isinstance(path, pathlib.Path):
+        # workaround for Python 3.5
+        return str(path)
+
+    # Work from the object's type to match method resolution of other magic
+    # methods.
+    path_type = type(path)
+    try:
+        path_repr = path_type.__fspath__(path)
+    except AttributeError:
+
+        if hasattr(path_type, '__fspath__'):
+            raise
+        else:
+            raise TypeError(
+                "expected str, bytes or os.PathLike object, "
+                "not " + path_type.__name__
+            )
+    if isinstance(path_repr, (str, bytes)):
+        return path_repr
+    else:
+        raise TypeError(
+            "expected {}.__fspath__() to return str or bytes, "
+            "not {}".format(path_type.__name__, type(path_repr).__name__)
+        )
+
+
+fspath = getattr(os, 'fspath', _fspath)
diff --git a/contrib/deprecated/python/configparser/configparser.py b/contrib/deprecated/python/configparser/configparser.py
new file mode 100644
index 0000000000..0a18360239
--- /dev/null
+++ b/contrib/deprecated/python/configparser/configparser.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""Convenience module importing everything from backports.configparser."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+from backports.configparser import (
+    RawConfigParser,
+    ConfigParser,
+    SafeConfigParser,
+    SectionProxy,
+    Interpolation,
+    BasicInterpolation,
+    ExtendedInterpolation,
+    LegacyInterpolation,
+    NoSectionError,
+    DuplicateSectionError,
+    DuplicateOptionError,
+    NoOptionError,
+    InterpolationError,
+    InterpolationMissingOptionError,
+    InterpolationSyntaxError,
+    InterpolationDepthError,
+    ParsingError,
+    MissingSectionHeaderError,
+    ConverterMapping,
+    DEFAULTSECT,
+    MAX_INTERPOLATION_DEPTH,
+)
+
+from backports.configparser import Error, _UNSET, _default_dict, _ChainMap  # noqa: F401
+
+__all__ = [
+    "NoSectionError",
+    "DuplicateOptionError",
+    "DuplicateSectionError",
+    "NoOptionError",
+    "InterpolationError",
+    "InterpolationDepthError",
+    "InterpolationMissingOptionError",
+    "InterpolationSyntaxError",
+    "ParsingError",
+    "MissingSectionHeaderError",
+    "ConfigParser",
+    "SafeConfigParser",
+    "RawConfigParser",
+    "Interpolation",
+    "BasicInterpolation",
+    "ExtendedInterpolation",
+    "LegacyInterpolation",
+    "SectionProxy",
+    "ConverterMapping",
+    "DEFAULTSECT",
+    "MAX_INTERPOLATION_DEPTH",
+]
+
+# NOTE: names missing from __all__ imported anyway for backwards compatibility.
diff --git a/contrib/deprecated/python/configparser/ya.make b/contrib/deprecated/python/configparser/ya.make
new file mode 100644
index 0000000000..6859a6033a
--- /dev/null
+++ b/contrib/deprecated/python/configparser/ya.make
@@ -0,0 +1,24 @@
+# Generated by devtools/yamaker (pypi).
+
+PY2_LIBRARY()
+
+VERSION(4.0.2)
+
+LICENSE(MIT)
+
+NO_LINT()
+
+PY_SRCS(
+    TOP_LEVEL
+    backports/configparser/__init__.py
+    backports/configparser/helpers.py
+    configparser.py
+)
+
+RESOURCE_FILES(
+    PREFIX contrib/deprecated/python/configparser/
+    .dist-info/METADATA
+    .dist-info/top_level.txt
+)
+
+END()