alpcentaur
/
basabuuka_prototyp


								# -*- coding: utf-8 -*-

								#

								# Copyright (C) 2013-2017 Vinay Sajip.

								# Licensed to the Python Software Foundation under a contributor agreement.

								# See LICENSE.txt and CONTRIBUTORS.txt.

								#

								from __future__ import absolute_import


								import os

								import re

								import sys


								try:

								    import ssl

								except ImportError:  # pragma: no cover

								    ssl = None


								if sys.version_info[0] < 3:  # pragma: no cover

								    from StringIO import StringIO

								    string_types = basestring,

								    text_type = unicode

								    from types import FileType as file_type

								    import __builtin__ as builtins

								    import ConfigParser as configparser

								    from ._backport import shutil

								    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urlunsplit

								    from urllib import (urlretrieve, quote as _quote, unquote, url2pathname,

								                        pathname2url, ContentTooShortError, splittype)


								    def quote(s):

								        if isinstance(s, unicode):

								            s = s.encode('utf-8')

								        return _quote(s)


								    import urllib2

								    from urllib2 import (Request, urlopen, URLError, HTTPError,

								                         HTTPBasicAuthHandler, HTTPPasswordMgr,

								                         HTTPHandler, HTTPRedirectHandler,

								                         build_opener)

								    if ssl:

								        from urllib2 import HTTPSHandler

								    import httplib

								    import xmlrpclib

								    import Queue as queue

								    from HTMLParser import HTMLParser

								    import htmlentitydefs

								    raw_input = raw_input

								    from itertools import ifilter as filter

								    from itertools import ifilterfalse as filterfalse


								    _userprog = None

								    def splituser(host):

								        """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'."""

								        global _userprog

								        if _userprog is None:

								            import re

								            _userprog = re.compile('^(.*)@(.*)$')


								        match = _userprog.match(host)

								        if match: return match.group(1, 2)

								        return None, host


								else:  # pragma: no cover

								    from io import StringIO

								    string_types = str,

								    text_type = str

								    from io import TextIOWrapper as file_type

								    import builtins

								    import configparser

								    import shutil

								    from urllib.parse import (urlparse, urlunparse, urljoin, splituser, quote,

								                              unquote, urlsplit, urlunsplit, splittype)

								    from urllib.request import (urlopen, urlretrieve, Request, url2pathname,

								                                pathname2url,

								                                HTTPBasicAuthHandler, HTTPPasswordMgr,

								                                HTTPHandler, HTTPRedirectHandler,

								                                build_opener)

								    if ssl:

								        from urllib.request import HTTPSHandler

								    from urllib.error import HTTPError, URLError, ContentTooShortError

								    import http.client as httplib

								    import urllib.request as urllib2

								    import xmlrpc.client as xmlrpclib

								    import queue

								    from html.parser import HTMLParser

								    import html.entities as htmlentitydefs

								    raw_input = input

								    from itertools import filterfalse

								    filter = filter


								try:

								    from ssl import match_hostname, CertificateError

								except ImportError: # pragma: no cover

								    class CertificateError(ValueError):

								        pass


								    def _dnsname_match(dn, hostname, max_wildcards=1):

								        """Matching according to RFC 6125, section 6.4.3


								        http://tools.ietf.org/html/rfc6125#section-6.4.3

								        """

								        pats = []

								        if not dn:

								            return False


								        parts = dn.split('.')

								        leftmost, remainder = parts[0], parts[1:]


								        wildcards = leftmost.count('*')

								        if wildcards > max_wildcards:

								            # Issue #17980: avoid denials of service by refusing more

								            # than one wildcard per fragment.  A survey of established

								            # policy among SSL implementations showed it to be a

								            # reasonable choice.

								            raise CertificateError(

								                "too many wildcards in certificate DNS name: " + repr(dn))


								        # speed up common case w/o wildcards

								        if not wildcards:

								            return dn.lower() == hostname.lower()


								        # RFC 6125, section 6.4.3, subitem 1.

								        # The client SHOULD NOT attempt to match a presented identifier in which

								        # the wildcard character comprises a label other than the left-most label.

								        if leftmost == '*':

								            # When '*' is a fragment by itself, it matches a non-empty dotless

								            # fragment.

								            pats.append('[^.]+')

								        elif leftmost.startswith('xn--') or hostname.startswith('xn--'):

								            # RFC 6125, section 6.4.3, subitem 3.

								            # The client SHOULD NOT attempt to match a presented identifier

								            # where the wildcard character is embedded within an A-label or

								            # U-label of an internationalized domain name.

								            pats.append(re.escape(leftmost))

								        else:

								            # Otherwise, '*' matches any dotless string, e.g. www*

								            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))


								        # add the remaining fragments, ignore any wildcards

								        for frag in remainder:

								            pats.append(re.escape(frag))


								        pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)

								        return pat.match(hostname)


								    def match_hostname(cert, hostname):

								        """Verify that *cert* (in decoded format as returned by

								        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125

								        rules are followed, but IP addresses are not accepted for *hostname*.


								        CertificateError is raised on failure. On success, the function

								        returns nothing.

								        """

								        if not cert:

								            raise ValueError("empty or no certificate, match_hostname needs a "

								                             "SSL socket or SSL context with either "

								                             "CERT_OPTIONAL or CERT_REQUIRED")

								        dnsnames = []

								        san = cert.get('subjectAltName', ())

								        for key, value in san:

								            if key == 'DNS':

								                if _dnsname_match(value, hostname):

								                    return

								                dnsnames.append(value)

								        if not dnsnames:

								            # The subject is only checked when there is no dNSName entry

								            # in subjectAltName

								            for sub in cert.get('subject', ()):

								                for key, value in sub:

								                    # XXX according to RFC 2818, the most specific Common Name

								                    # must be used.

								                    if key == 'commonName':

								                        if _dnsname_match(value, hostname):

								                            return

								                        dnsnames.append(value)

								        if len(dnsnames) > 1:

								            raise CertificateError("hostname %r "

								                "doesn't match either of %s"

								                % (hostname, ', '.join(map(repr, dnsnames))))

								        elif len(dnsnames) == 1:

								            raise CertificateError("hostname %r "

								                "doesn't match %r"

								                % (hostname, dnsnames[0]))

								        else:

								            raise CertificateError("no appropriate commonName or "

								                "subjectAltName fields were found")


								try:

								    from types import SimpleNamespace as Container

								except ImportError:  # pragma: no cover

								    class Container(object):

								        """

								        A generic container for when multiple values need to be returned

								        """

								        def __init__(self, **kwargs):

								            self.__dict__.update(kwargs)


								try:

								    from shutil import which

								except ImportError:  # pragma: no cover

								    # Implementation from Python 3.3

								    def which(cmd, mode=os.F_OK | os.X_OK, path=None):

								        """Given a command, mode, and a PATH string, return the path which

								        conforms to the given mode on the PATH, or None if there is no such

								        file.


								        `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result

								        of os.environ.get("PATH"), or can be overridden with a custom search

								        path.


								        """

								        # Check that a given file can be accessed with the correct mode.

								        # Additionally check that `file` is not a directory, as on Windows

								        # directories pass the os.access check.

								        def _access_check(fn, mode):

								            return (os.path.exists(fn) and os.access(fn, mode)

								                    and not os.path.isdir(fn))


								        # If we're given a path with a directory part, look it up directly rather

								        # than referring to PATH directories. This includes checking relative to the

								        # current directory, e.g. ./script

								        if os.path.dirname(cmd):

								            if _access_check(cmd, mode):

								                return cmd

								            return None


								        if path is None:

								            path = os.environ.get("PATH", os.defpath)

								        if not path:

								            return None

								        path = path.split(os.pathsep)


								        if sys.platform == "win32":

								            # The current directory takes precedence on Windows.

								            if not os.curdir in path:

								                path.insert(0, os.curdir)


								            # PATHEXT is necessary to check on Windows.

								            pathext = os.environ.get("PATHEXT", "").split(os.pathsep)

								            # See if the given file matches any of the expected path extensions.

								            # This will allow us to short circuit when given "python.exe".

								            # If it does match, only test that one, otherwise we have to try

								            # others.

								            if any(cmd.lower().endswith(ext.lower()) for ext in pathext):

								                files = [cmd]

								            else:

								                files = [cmd + ext for ext in pathext]

								        else:

								            # On other platforms you don't have things like PATHEXT to tell you

								            # what file suffixes are executable, so just pass on cmd as-is.

								            files = [cmd]


								        seen = set()

								        for dir in path:

								            normdir = os.path.normcase(dir)

								            if not normdir in seen:

								                seen.add(normdir)

								                for thefile in files:

								                    name = os.path.join(dir, thefile)

								                    if _access_check(name, mode):

								                        return name

								        return None


								# ZipFile is a context manager in 2.7, but not in 2.6


								from zipfile import ZipFile as BaseZipFile


								if hasattr(BaseZipFile, '__enter__'):  # pragma: no cover

								    ZipFile = BaseZipFile

								else:  # pragma: no cover

								    from zipfile import ZipExtFile as BaseZipExtFile


								    class ZipExtFile(BaseZipExtFile):

								        def __init__(self, base):

								            self.__dict__.update(base.__dict__)


								        def __enter__(self):

								            return self


								        def __exit__(self, *exc_info):

								            self.close()

								            # return None, so if an exception occurred, it will propagate


								    class ZipFile(BaseZipFile):

								        def __enter__(self):

								            return self


								        def __exit__(self, *exc_info):

								            self.close()

								            # return None, so if an exception occurred, it will propagate


								        def open(self, *args, **kwargs):

								            base = BaseZipFile.open(self, *args, **kwargs)

								            return ZipExtFile(base)


								try:

								    from platform import python_implementation

								except ImportError: # pragma: no cover

								    def python_implementation():

								        """Return a string identifying the Python implementation."""

								        if 'PyPy' in sys.version:

								            return 'PyPy'

								        if os.name == 'java':

								            return 'Jython'

								        if sys.version.startswith('IronPython'):

								            return 'IronPython'

								        return 'CPython'


								try:

								    import sysconfig

								except ImportError: # pragma: no cover

								    from ._backport import sysconfig


								try:

								    callable = callable

								except NameError:   # pragma: no cover

								    from collections import Callable


								    def callable(obj):

								        return isinstance(obj, Callable)


								try:

								    fsencode = os.fsencode

								    fsdecode = os.fsdecode

								except AttributeError:  # pragma: no cover

								    # Issue #99: on some systems (e.g. containerised),

								    # sys.getfilesystemencoding() returns None, and we need a real value,

								    # so fall back to utf-8. From the CPython 2.7 docs relating to Unix and

								    # sys.getfilesystemencoding(): the return value is "the user’s preference

								    # according to the result of nl_langinfo(CODESET), or None if the

								    # nl_langinfo(CODESET) failed."

								    _fsencoding = sys.getfilesystemencoding() or 'utf-8'

								    if _fsencoding == 'mbcs':

								        _fserrors = 'strict'

								    else:

								        _fserrors = 'surrogateescape'


								    def fsencode(filename):

								        if isinstance(filename, bytes):

								            return filename

								        elif isinstance(filename, text_type):

								            return filename.encode(_fsencoding, _fserrors)

								        else:

								            raise TypeError("expect bytes or str, not %s" %

								                            type(filename).__name__)


								    def fsdecode(filename):

								        if isinstance(filename, text_type):

								            return filename

								        elif isinstance(filename, bytes):

								            return filename.decode(_fsencoding, _fserrors)

								        else:

								            raise TypeError("expect bytes or str, not %s" %

								                            type(filename).__name__)


								try:

								    from tokenize import detect_encoding

								except ImportError: # pragma: no cover

								    from codecs import BOM_UTF8, lookup

								    import re


								    cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)")


								    def _get_normal_name(orig_enc):

								        """Imitates get_normal_name in tokenizer.c."""

								        # Only care about the first 12 characters.

								        enc = orig_enc[:12].lower().replace("_", "-")

								        if enc == "utf-8" or enc.startswith("utf-8-"):

								            return "utf-8"

								        if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \

								           enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")):

								            return "iso-8859-1"

								        return orig_enc


								    def detect_encoding(readline):

								        """

								        The detect_encoding() function is used to detect the encoding that should

								        be used to decode a Python source file.  It requires one argument, readline,

								        in the same way as the tokenize() generator.


								        It will call readline a maximum of twice, and return the encoding used

								        (as a string) and a list of any lines (left as bytes) it has read in.


								        It detects the encoding from the presence of a utf-8 bom or an encoding

								        cookie as specified in pep-0263.  If both a bom and a cookie are present,

								        but disagree, a SyntaxError will be raised.  If the encoding cookie is an

								        invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,

								        'utf-8-sig' is returned.


								        If no encoding is specified, then the default of 'utf-8' will be returned.

								        """

								        try:

								            filename = readline.__self__.name

								        except AttributeError:

								            filename = None

								        bom_found = False

								        encoding = None

								        default = 'utf-8'

								        def read_or_stop():

								            try:

								                return readline()

								            except StopIteration:

								                return b''


								        def find_cookie(line):

								            try:

								                # Decode as UTF-8. Either the line is an encoding declaration,

								                # in which case it should be pure ASCII, or it must be UTF-8

								                # per default encoding.

								                line_string = line.decode('utf-8')

								            except UnicodeDecodeError:

								                msg = "invalid or missing encoding declaration"

								                if filename is not None:

								                    msg = '{} for {!r}'.format(msg, filename)

								                raise SyntaxError(msg)


								            matches = cookie_re.findall(line_string)

								            if not matches:

								                return None

								            encoding = _get_normal_name(matches[0])

								            try:

								                codec = lookup(encoding)

								            except LookupError:

								                # This behaviour mimics the Python interpreter

								                if filename is None:

								                    msg = "unknown encoding: " + encoding

								                else:

								                    msg = "unknown encoding for {!r}: {}".format(filename,

								                            encoding)

								                raise SyntaxError(msg)


								            if bom_found:

								                if codec.name != 'utf-8':

								                    # This behaviour mimics the Python interpreter

								                    if filename is None:

								                        msg = 'encoding problem: utf-8'

								                    else:

								                        msg = 'encoding problem for {!r}: utf-8'.format(filename)

								                    raise SyntaxError(msg)

								                encoding += '-sig'

								            return encoding


								        first = read_or_stop()

								        if first.startswith(BOM_UTF8):

								            bom_found = True

								            first = first[3:]

								            default = 'utf-8-sig'

								        if not first:

								            return default, []


								        encoding = find_cookie(first)

								        if encoding:

								            return encoding, [first]


								        second = read_or_stop()

								        if not second:

								            return default, [first]


								        encoding = find_cookie(second)

								        if encoding:

								            return encoding, [first, second]


								        return default, [first, second]


								# For converting & <-> &amp; etc.

								try:

								    from html import escape

								except ImportError:

								    from cgi import escape

								if sys.version_info[:2] < (3, 4):

								    unescape = HTMLParser().unescape

								else:

								    from html import unescape


								try:

								    from collections import ChainMap

								except ImportError: # pragma: no cover

								    from collections import MutableMapping


								    try:

								        from reprlib import recursive_repr as _recursive_repr

								    except ImportError:

								        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


								    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:

								                    return mapping[key]             # can't use 'key in mapping' with defaultdict

								                except KeyError:

								                    pass

								            return self.__missing__(key)            # support subclasses that define __missing__


								        def get(self, key, default=None):

								            return self[key] if key in self else default


								        def __len__(self):

								            return len(set().union(*self.maps))     # reuses stored hash values if possible


								        def __iter__(self):

								            return iter(set().union(*self.maps))


								        def __contains__(self, key):

								            return any(key in m for m in self.maps)


								        def __bool__(self):

								            return any(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 importlib.util import cache_from_source  # Python >= 3.4

								except ImportError:  # pragma: no cover

								    try:

								        from imp import cache_from_source

								    except ImportError:  # pragma: no cover

								        def cache_from_source(path, debug_override=None):

								            assert path.endswith('.py')

								            if debug_override is None:

								                debug_override = __debug__

								            if debug_override:

								                suffix = 'c'

								            else:

								                suffix = 'o'

								            return path + suffix


								try:

								    from collections import OrderedDict

								except ImportError: # pragma: no cover

								## {{{ http://code.activestate.com/recipes/576693/ (r9)

								# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.

								# Passes Python2.7's test suite and incorporates all the latest updates.

								    try:

								        from thread import get_ident as _get_ident

								    except ImportError:

								        from dummy_thread import get_ident as _get_ident


								    try:

								        from _abcoll import KeysView, ValuesView, ItemsView

								    except ImportError:

								        pass


								    class OrderedDict(dict):

								        'Dictionary that remembers insertion order'

								        # An inherited dict maps keys to values.

								        # The inherited dict provides __getitem__, __len__, __contains__, and get.

								        # The remaining methods are order-aware.

								        # Big-O running times for all methods are the same as for regular dictionaries.


								        # The internal self.__map dictionary maps keys to links in a doubly linked list.

								        # The circular doubly linked list starts and ends with a sentinel element.

								        # The sentinel element never gets deleted (this simplifies the algorithm).

								        # Each link is stored as a list of length three:  [PREV, NEXT, KEY].


								        def __init__(self, *args, **kwds):

								            '''Initialize an ordered dictionary.  Signature is the same as for

								            regular dictionaries, but keyword arguments are not recommended

								            because their insertion order is arbitrary.


								            '''

								            if len(args) > 1:

								                raise TypeError('expected at most 1 arguments, got %d' % len(args))

								            try:

								                self.__root

								            except AttributeError:

								                self.__root = root = []                     # sentinel node

								                root[:] = [root, root, None]

								                self.__map = {}

								            self.__update(*args, **kwds)


								        def __setitem__(self, key, value, dict_setitem=dict.__setitem__):

								            'od.__setitem__(i, y) <==> od[i]=y'

								            # Setting a new item creates a new link which goes at the end of the linked

								            # list, and the inherited dictionary is updated with the new key/value pair.

								            if key not in self:

								                root = self.__root

								                last = root[0]

								                last[1] = root[0] = self.__map[key] = [last, root, key]

								            dict_setitem(self, key, value)


								        def __delitem__(self, key, dict_delitem=dict.__delitem__):

								            'od.__delitem__(y) <==> del od[y]'

								            # Deleting an existing item uses self.__map to find the link which is

								            # then removed by updating the links in the predecessor and successor nodes.

								            dict_delitem(self, key)

								            link_prev, link_next, key = self.__map.pop(key)

								            link_prev[1] = link_next

								            link_next[0] = link_prev


								        def __iter__(self):

								            'od.__iter__() <==> iter(od)'

								            root = self.__root

								            curr = root[1]

								            while curr is not root:

								                yield curr[2]

								                curr = curr[1]


								        def __reversed__(self):

								            'od.__reversed__() <==> reversed(od)'

								            root = self.__root

								            curr = root[0]

								            while curr is not root:

								                yield curr[2]

								                curr = curr[0]


								        def clear(self):

								            'od.clear() -> None.  Remove all items from od.'

								            try:

								                for node in self.__map.itervalues():

								                    del node[:]

								                root = self.__root

								                root[:] = [root, root, None]

								                self.__map.clear()

								            except AttributeError:

								                pass

								            dict.clear(self)


								        def popitem(self, last=True):

								            '''od.popitem() -> (k, v), return and remove a (key, value) pair.

								            Pairs are returned in LIFO order if last is true or FIFO order if false.


								            '''

								            if not self:

								                raise KeyError('dictionary is empty')

								            root = self.__root

								            if last:

								                link = root[0]

								                link_prev = link[0]

								                link_prev[1] = root

								                root[0] = link_prev

								            else:

								                link = root[1]

								                link_next = link[1]

								                root[1] = link_next

								                link_next[0] = root

								            key = link[2]

								            del self.__map[key]

								            value = dict.pop(self, key)

								            return key, value


								        # -- the following methods do not depend on the internal structure --


								        def keys(self):

								            'od.keys() -> list of keys in od'

								            return list(self)


								        def values(self):

								            'od.values() -> list of values in od'

								            return [self[key] for key in self]


								        def items(self):

								            'od.items() -> list of (key, value) pairs in od'

								            return [(key, self[key]) for key in self]


								        def iterkeys(self):

								            'od.iterkeys() -> an iterator over the keys in od'

								            return iter(self)


								        def itervalues(self):

								            'od.itervalues -> an iterator over the values in od'

								            for k in self:

								                yield self[k]


								        def iteritems(self):

								            'od.iteritems -> an iterator over the (key, value) items in od'

								            for k in self:

								                yield (k, self[k])


								        def update(*args, **kwds):

								            '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.


								            If E is a dict instance, does:           for k in E: od[k] = E[k]

								            If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]

								            Or if E is an iterable of items, does:   for k, v in E: od[k] = v

								            In either case, this is followed by:     for k, v in F.items(): od[k] = v


								            '''

								            if len(args) > 2:

								                raise TypeError('update() takes at most 2 positional '

								                                'arguments (%d given)' % (len(args),))

								            elif not args:

								                raise TypeError('update() takes at least 1 argument (0 given)')

								            self = args[0]

								            # Make progressively weaker assumptions about "other"

								            other = ()

								            if len(args) == 2:

								                other = args[1]

								            if isinstance(other, dict):

								                for key in other:

								                    self[key] = other[key]

								            elif hasattr(other, 'keys'):

								                for key in other.keys():

								                    self[key] = other[key]

								            else:

								                for key, value in other:

								                    self[key] = value

								            for key, value in kwds.items():

								                self[key] = value


								        __update = update  # let subclasses override update without breaking __init__


								        __marker = object()


								        def pop(self, key, default=__marker):

								            '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.

								            If key is not found, d is returned if given, otherwise KeyError is raised.


								            '''

								            if key in self:

								                result = self[key]

								                del self[key]

								                return result

								            if default is self.__marker:

								                raise KeyError(key)

								            return default


								        def setdefault(self, key, default=None):

								            'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'

								            if key in self:

								                return self[key]

								            self[key] = default

								            return default


								        def __repr__(self, _repr_running=None):

								            'od.__repr__() <==> repr(od)'

								            if not _repr_running: _repr_running = {}

								            call_key = id(self), _get_ident()

								            if call_key in _repr_running:

								                return '...'

								            _repr_running[call_key] = 1

								            try:

								                if not self:

								                    return '%s()' % (self.__class__.__name__,)

								                return '%s(%r)' % (self.__class__.__name__, self.items())

								            finally:

								                del _repr_running[call_key]


								        def __reduce__(self):

								            'Return state information for pickling'

								            items = [[k, self[k]] for k in self]

								            inst_dict = vars(self).copy()

								            for k in vars(OrderedDict()):

								                inst_dict.pop(k, None)

								            if inst_dict:

								                return (self.__class__, (items,), inst_dict)

								            return self.__class__, (items,)


								        def copy(self):

								            'od.copy() -> a shallow copy of od'

								            return self.__class__(self)


								        @classmethod

								        def fromkeys(cls, iterable, value=None):

								            '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S

								            and values equal to v (which defaults to None).


								            '''

								            d = cls()

								            for key in iterable:

								                d[key] = value

								            return d


								        def __eq__(self, other):

								            '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive

								            while comparison to a regular mapping is order-insensitive.


								            '''

								            if isinstance(other, OrderedDict):

								                return len(self)==len(other) and self.items() == other.items()

								            return dict.__eq__(self, other)


								        def __ne__(self, other):

								            return not self == other


								        # -- the following methods are only used in Python 2.7 --


								        def viewkeys(self):

								            "od.viewkeys() -> a set-like object providing a view on od's keys"

								            return KeysView(self)


								        def viewvalues(self):

								            "od.viewvalues() -> an object providing a view on od's values"

								            return ValuesView(self)


								        def viewitems(self):

								            "od.viewitems() -> a set-like object providing a view on od's items"

								            return ItemsView(self)


								try:

								    from logging.config import BaseConfigurator, valid_ident

								except ImportError: # pragma: no cover

								    IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)


								    def valid_ident(s):

								        m = IDENTIFIER.match(s)

								        if not m:

								            raise ValueError('Not a valid Python identifier: %r' % s)

								        return True


								    # The ConvertingXXX classes are wrappers around standard Python containers,

								    # and they serve to convert any suitable values in the container. The

								    # conversion converts base dicts, lists and tuples to their wrapped

								    # equivalents, whereas strings which match a conversion format are converted

								    # appropriately.

								    #

								    # Each wrapper should have a configurator attribute holding the actual

								    # configurator to use for conversion.


								    class ConvertingDict(dict):

								        """A converting dictionary wrapper."""


								        def __getitem__(self, key):

								            value = dict.__getitem__(self, key)

								            result = self.configurator.convert(value)

								            #If the converted value is different, save for next time

								            if value is not result:

								                self[key] = result

								                if type(result) in (ConvertingDict, ConvertingList,

								                                    ConvertingTuple):

								                    result.parent = self

								                    result.key = key

								            return result


								        def get(self, key, default=None):

								            value = dict.get(self, key, default)

								            result = self.configurator.convert(value)

								            #If the converted value is different, save for next time

								            if value is not result:

								                self[key] = result

								                if type(result) in (ConvertingDict, ConvertingList,

								                                    ConvertingTuple):

								                    result.parent = self

								                    result.key = key

								            return result


								    def pop(self, key, default=None):

								        value = dict.pop(self, key, default)

								        result = self.configurator.convert(value)

								        if value is not result:

								            if type(result) in (ConvertingDict, ConvertingList,

								                                ConvertingTuple):

								                result.parent = self

								                result.key = key

								        return result


								    class ConvertingList(list):

								        """A converting list wrapper."""

								        def __getitem__(self, key):

								            value = list.__getitem__(self, key)

								            result = self.configurator.convert(value)

								            #If the converted value is different, save for next time

								            if value is not result:

								                self[key] = result

								                if type(result) in (ConvertingDict, ConvertingList,

								                                    ConvertingTuple):

								                    result.parent = self

								                    result.key = key

								            return result


								        def pop(self, idx=-1):

								            value = list.pop(self, idx)

								            result = self.configurator.convert(value)

								            if value is not result:

								                if type(result) in (ConvertingDict, ConvertingList,

								                                    ConvertingTuple):

								                    result.parent = self

								            return result


								    class ConvertingTuple(tuple):

								        """A converting tuple wrapper."""

								        def __getitem__(self, key):

								            value = tuple.__getitem__(self, key)

								            result = self.configurator.convert(value)

								            if value is not result:

								                if type(result) in (ConvertingDict, ConvertingList,

								                                    ConvertingTuple):

								                    result.parent = self

								                    result.key = key

								            return result


								    class BaseConfigurator(object):

								        """

								        The configurator base class which defines some useful defaults.

								        """


								        CONVERT_PATTERN = re.compile(r'^(?P<prefix>[a-z]+)://(?P<suffix>.*)$')


								        WORD_PATTERN = re.compile(r'^\s*(\w+)\s*')

								        DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*')

								        INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*')

								        DIGIT_PATTERN = re.compile(r'^\d+$')


								        value_converters = {

								            'ext' : 'ext_convert',

								            'cfg' : 'cfg_convert',

								        }


								        # We might want to use a different one, e.g. importlib

								        importer = staticmethod(__import__)


								        def __init__(self, config):

								            self.config = ConvertingDict(config)

								            self.config.configurator = self


								        def resolve(self, s):

								            """

								            Resolve strings to objects using standard import and attribute

								            syntax.

								            """

								            name = s.split('.')

								            used = name.pop(0)

								            try:

								                found = self.importer(used)

								                for frag in name:

								                    used += '.' + frag

								                    try:

								                        found = getattr(found, frag)

								                    except AttributeError:

								                        self.importer(used)

								                        found = getattr(found, frag)

								                return found

								            except ImportError:

								                e, tb = sys.exc_info()[1:]

								                v = ValueError('Cannot resolve %r: %s' % (s, e))

								                v.__cause__, v.__traceback__ = e, tb

								                raise v


								        def ext_convert(self, value):

								            """Default converter for the ext:// protocol."""

								            return self.resolve(value)


								        def cfg_convert(self, value):

								            """Default converter for the cfg:// protocol."""

								            rest = value

								            m = self.WORD_PATTERN.match(rest)

								            if m is None:

								                raise ValueError("Unable to convert %r" % value)

								            else:

								                rest = rest[m.end():]

								                d = self.config[m.groups()[0]]

								                #print d, rest

								                while rest:

								                    m = self.DOT_PATTERN.match(rest)

								                    if m:

								                        d = d[m.groups()[0]]

								                    else:

								                        m = self.INDEX_PATTERN.match(rest)

								                        if m:

								                            idx = m.groups()[0]

								                            if not self.DIGIT_PATTERN.match(idx):

								                                d = d[idx]

								                            else:

								                                try:

								                                    n = int(idx) # try as number first (most likely)

								                                    d = d[n]

								                                except TypeError:

								                                    d = d[idx]

								                    if m:

								                        rest = rest[m.end():]

								                    else:

								                        raise ValueError('Unable to convert '

								                                         '%r at %r' % (value, rest))

								            #rest should be empty

								            return d


								        def convert(self, value):

								            """

								            Convert values to an appropriate type. dicts, lists and tuples are

								            replaced by their converting alternatives. Strings are checked to

								            see if they have a conversion format and are converted if they do.

								            """

								            if not isinstance(value, ConvertingDict) and isinstance(value, dict):

								                value = ConvertingDict(value)

								                value.configurator = self

								            elif not isinstance(value, ConvertingList) and isinstance(value, list):

								                value = ConvertingList(value)

								                value.configurator = self

								            elif not isinstance(value, ConvertingTuple) and\

								                     isinstance(value, tuple):

								                value = ConvertingTuple(value)

								                value.configurator = self

								            elif isinstance(value, string_types):

								                m = self.CONVERT_PATTERN.match(value)

								                if m:

								                    d = m.groupdict()

								                    prefix = d['prefix']

								                    converter = self.value_converters.get(prefix, None)

								                    if converter:

								                        suffix = d['suffix']

								                        converter = getattr(self, converter)

								                        value = converter(suffix)

								            return value


								        def configure_custom(self, config):

								            """Configure an object with a user-supplied factory."""

								            c = config.pop('()')

								            if not callable(c):

								                c = self.resolve(c)

								            props = config.pop('.', None)

								            # Check for valid identifiers

								            kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])

								            result = c(**kwargs)

								            if props:

								                for name, value in props.items():

								                    setattr(result, name, value)

								            return result


								        def as_tuple(self, value):

								            """Utility function which converts lists to tuples."""

								            if isinstance(value, list):

								                value = tuple(value)

								            return value