/brz/remove-bazaar

# configobj.py

# A config file reader/writer that supports nested sections in config files.

# Copyright (C) 2005-2006 Michael Foord, Nicola Larosa

# E-mail: fuzzyman AT voidspace DOT org DOT uk

#         nico AT tekNico DOT net

# ConfigObj 4

# http://www.voidspace.org.uk/python/configobj.html

# Released subject to the BSD License

# Please see http://www.voidspace.org.uk/python/license.shtml

# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml

# For information about bugfixes, updates and support, please join the

# ConfigObj mailing list:

# http://lists.sourceforge.net/lists/listinfo/configobj-develop

# Comments, suggestions and bug reports welcome.

from __future__ import generators

import sys

INTP_VER = sys.version_info[:2]

if INTP_VER < (2, 2):

    raise RuntimeError("Python v.2.2 or later needed")

import os, re

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

import compiler

""")

from types import StringTypes

from warnings import warn

try:

    from codecs import BOM_UTF8, BOM_UTF16, BOM_UTF16_BE, BOM_UTF16_LE

except ImportError:

    # Python 2.2 does not have these

    # UTF-8

    BOM_UTF8 = '\xef\xbb\xbf'

    # UTF-16, little endian

    BOM_UTF16_LE = '\xff\xfe'

    # UTF-16, big endian

    BOM_UTF16_BE = '\xfe\xff'

    if sys.byteorder == 'little':

        # UTF-16, native endianness

        BOM_UTF16 = BOM_UTF16_LE

    else:

        # UTF-16, native endianness

        BOM_UTF16 = BOM_UTF16_BE

# A dictionary mapping BOM to

# the encoding to decode with, and what to set the

# encoding attribute to.

BOMS = {

    BOM_UTF8: ('utf_8', None),

    BOM_UTF16_BE: ('utf16_be', 'utf_16'),

    BOM_UTF16_LE: ('utf16_le', 'utf_16'),

    BOM_UTF16: ('utf_16', 'utf_16'),

    }

# All legal variants of the BOM codecs.

# TODO: the list of aliases is not meant to be exhaustive, is there a

#   better way ?

BOM_LIST = {

    'utf_16': 'utf_16',

    'u16': 'utf_16',

    'utf16': 'utf_16',

    'utf-16': 'utf_16',

    'utf16_be': 'utf16_be',

    'utf_16_be': 'utf16_be',

    'utf-16be': 'utf16_be',

    'utf16_le': 'utf16_le',

    'utf_16_le': 'utf16_le',

    'utf-16le': 'utf16_le',

    'utf_8': 'utf_8',

    'u8': 'utf_8',

    'utf': 'utf_8',

    'utf8': 'utf_8',

    'utf-8': 'utf_8',

    }

# Map of encodings to the BOM to write.

BOM_SET = {

    'utf_8': BOM_UTF8,

    'utf_16': BOM_UTF16,

    'utf16_be': BOM_UTF16_BE,

    'utf16_le': BOM_UTF16_LE,

    None: BOM_UTF8

    }

__version__ = '4.4.0'

__revision__ = '$Id: configobj.py 156 2006-01-31 14:57:08Z fuzzyman $'

__docformat__ = "restructuredtext en"

__all__ = (

    '__version__',

    'DEFAULT_INDENT_TYPE',

    'DEFAULT_INTERPOLATION',

    'ConfigObjError',

    'NestingError',

    'ParseError',

    'DuplicateError',

    'ConfigspecError',

    'ConfigObj',

    'SimpleVal',

    'InterpolationError',

    'InterpolationLoopError',

    'MissingInterpolationOption',

    'RepeatSectionError',

    'UnreprError',

    'UnknownType',

    '__docformat__',

    'flatten_errors',

)

DEFAULT_INTERPOLATION = 'configparser'

DEFAULT_INDENT_TYPE = '    '

MAX_INTERPOL_DEPTH = 10

OPTION_DEFAULTS = {

    'interpolation': True,

    'raise_errors': False,

    'list_values': True,

    'create_empty': False,

    'file_error': False,

    'configspec': None,

    'stringify': True,

    # option may be set to one of ('', ' ', '\t')

    'indent_type': None,

    'encoding': None,

    'default_encoding': None,

    'unrepr': False,

    'write_empty_values': False,

}

def getObj(s):

    s = "a=" + s

    p = compiler.parse(s)

    return p.getChildren()[1].getChildren()[0].getChildren()[1]

class UnknownType(Exception):

    pass

class Builder:

    def build(self, o):

        m = getattr(self, 'build_' + o.__class__.__name__, None)

        if m is None:

            raise UnknownType(o.__class__.__name__)

        return m(o)

    def build_List(self, o):

        return map(self.build, o.getChildren())

    def build_Const(self, o):

        return o.value

    def build_Dict(self, o):

        d = {}

        i = iter(map(self.build, o.getChildren()))

        for el in i:

            d[el] = i.next()

        return d

    def build_Tuple(self, o):

        return tuple(self.build_List(o))

    def build_Name(self, o):

        if o.name == 'None':

            return None

        if o.name == 'True':

            return True

        if o.name == 'False':

            return False

        # An undefinted Name

        raise UnknownType('Undefined Name')

    def build_Add(self, o):

        real, imag = map(self.build_Const, o.getChildren())

        try:

            real = float(real)

        except TypeError:

            raise UnknownType('Add')

        if not isinstance(imag, complex) or imag.real != 0.0:

            raise UnknownType('Add')

        return real+imag

    def build_Getattr(self, o):

        parent = self.build(o.expr)

        return getattr(parent, o.attrname)

    def build_UnarySub(self, o):

        return -self.build_Const(o.getChildren()[0])

    def build_UnaryAdd(self, o):

        return self.build_Const(o.getChildren()[0])

def unrepr(s):

    if not s:

        return s

    return Builder().build(getObj(s))

def _splitlines(instring):

    """Split a string on lines, without losing line endings or truncating."""

class ConfigObjError(SyntaxError):

    """

    This is the base class for all errors that ConfigObj raises.

    It is a subclass of SyntaxError.

    """

    def __init__(self, message='', line_number=None, line=''):

        self.line = line

        self.line_number = line_number

        self.message = message

        SyntaxError.__init__(self, message)

class NestingError(ConfigObjError):

    """

    This error indicates a level of nesting that doesn't match.

    """

class ParseError(ConfigObjError):

    """

    This error indicates that a line is badly written.

    It is neither a valid ``key = value`` line,

    nor a valid section marker line.

    """

class DuplicateError(ConfigObjError):

    """

    The keyword or section specified already exists.

    """

class ConfigspecError(ConfigObjError):

    """

    An error occured whilst parsing a configspec.

    """

class InterpolationError(ConfigObjError):

    """Base class for the two interpolation errors."""

class InterpolationLoopError(InterpolationError):

    """Maximum interpolation depth exceeded in string interpolation."""

    def __init__(self, option):

        InterpolationError.__init__(

            self,

            'interpolation loop detected in value "%s".' % option)

class RepeatSectionError(ConfigObjError):

    """

    This error indicates additional sections in a section with a

    ``__many__`` (repeated) section.

    """

class MissingInterpolationOption(InterpolationError):

    """A value specified for interpolation was missing."""

    def __init__(self, option):

        InterpolationError.__init__(

            self,

            'missing option "%s" in interpolation.' % option)

class UnreprError(ConfigObjError):

    """An error parsing in unrepr mode."""

class InterpolationEngine(object):

    """

    A helper class to help perform string interpolation.

    This class is an abstract base class; its descendants perform

    the actual work.

    """

    # compiled regexp to use in self.interpolate()

    _KEYCRE = re.compile(r"%\(([^)]*)\)s")

    def __init__(self, section):

        # the Section instance that "owns" this engine

        self.section = section

    def interpolate(self, key, value):

        def recursive_interpolate(key, value, section, backtrail):

            """The function that does the actual work.

            ``value``: the string we're trying to interpolate.

            ``section``: the section in which that string was found

            ``backtrail``: a dict to keep track of where we've been,

            to detect and prevent infinite recursion loops

            This is similar to a depth-first-search algorithm.

            """

            # Have we been here already?

            if backtrail.has_key((key, section.name)):

                # Yes - infinite loop detected

                raise InterpolationLoopError(key)

            # Place a marker on our backtrail so we won't come back here again

            backtrail[(key, section.name)] = 1

            # Now start the actual work

            match = self._KEYCRE.search(value)

            while match:

                # The actual parsing of the match is implementation-dependent,

                # so delegate to our helper function

                k, v, s = self._parse_match(match)

                if k is None:

                    # That's the signal that no further interpolation is needed

                    replacement = v

                else:

                    # Further interpolation may be needed to obtain final value

                    replacement = recursive_interpolate(k, v, s, backtrail)

                # Replace the matched string with its final value

                start, end = match.span()

                value = ''.join((value[:start], replacement, value[end:]))

                new_search_start = start + len(replacement)

                # Pick up the next interpolation key, if any, for next time

                # through the while loop

                match = self._KEYCRE.search(value, new_search_start)

            # Now safe to come back here again; remove marker from backtrail

            del backtrail[(key, section.name)]

            return value

        # Back in interpolate(), all we have to do is kick off the recursive

        # function with appropriate starting values

        value = recursive_interpolate(key, value, self.section, {})

        return value

    def _fetch(self, key):

        """Helper function to fetch values from owning section.

        Returns a 2-tuple: the value, and the section where it was found.

        """

        # switch off interpolation before we try and fetch anything !

        save_interp = self.section.main.interpolation

        self.section.main.interpolation = False

        # Start at section that "owns" this InterpolationEngine

        current_section = self.section

        while True:

            # try the current section first

            val = current_section.get(key)

            if val is not None:

                break

            # try "DEFAULT" next

            val = current_section.get('DEFAULT', {}).get(key)

            if val is not None:

                break

            # move up to parent and try again

            # top-level's parent is itself

            if current_section.parent is current_section:

                # reached top level, time to give up

                break

            current_section = current_section.parent

        # restore interpolation to previous value before returning

        self.section.main.interpolation = save_interp

        if val is None:

            raise MissingInterpolationOption(key)

        return val, current_section

    def _parse_match(self, match):

        """Implementation-dependent helper function.

        Will be passed a match object corresponding to the interpolation

        key we just found (e.g., "%(foo)s" or "$foo"). Should look up that

        key in the appropriate config file section (using the ``_fetch()``

        helper function) and return a 3-tuple: (key, value, section)

        ``key`` is the name of the key we're looking for

        ``value`` is the value found for that key

        ``section`` is a reference to the section where it was found

        ``key`` and ``section`` should be None if no further

        interpolation should be performed on the resulting value

        (e.g., if we interpolated "$$" and returned "$").

        """

        raise NotImplementedError

class ConfigParserInterpolation(InterpolationEngine):

    """Behaves like ConfigParser."""

    _KEYCRE = re.compile(r"%\(([^)]*)\)s")

    def _parse_match(self, match):

        key = match.group(1)

        value, section = self._fetch(key)

        return key, value, section

class TemplateInterpolation(InterpolationEngine):

    """Behaves like string.Template."""

    _delimiter = '$'

    _KEYCRE = re.compile(r"""

        \$(?:

          (?P<escaped>\$)              |   # Two $ signs

          (?P<named>[_a-z][_a-z0-9]*)  |   # $name format

          {(?P<braced>[^}]*)}              # ${name} format

        )

        """, re.IGNORECASE | re.VERBOSE)

    def _parse_match(self, match):

        # Valid name (in or out of braces): fetch value from section

        key = match.group('named') or match.group('braced')

        if key is not None:

            value, section = self._fetch(key)

            return key, value, section

        # Escaped delimiter (e.g., $$): return single delimiter

        if match.group('escaped') is not None:

            # Return None for key and section to indicate it's time to stop

            return None, self._delimiter, None

        # Anything else: ignore completely, just return it unchanged

        return None, match.group(), None

interpolation_engines = {

    'configparser': ConfigParserInterpolation,

    'template': TemplateInterpolation,

}

class Section(dict):

    """

    A dictionary-like object that represents a section in a config file.

    It does string interpolation if the 'interpolation' attribute

    of the 'main' object is set to True.

    Interpolation is tried first from this object, then from the 'DEFAULT'

    section of this object, next from the parent and its 'DEFAULT' section,

    and so on until the main object is reached.

    A Section will behave like an ordered dictionary - following the

    order of the ``scalars`` and ``sections`` attributes.

    You can use this to change the order of members.

    Iteration follows the order: scalars, then sections.

    """

    def __init__(self, parent, depth, main, indict=None, name=None):

        """

        * parent is the section above

        * depth is the depth level of this section

        * main is the main ConfigObj

        * indict is a dictionary to initialise the section with

        """

        if indict is None:

            indict = {}

        dict.__init__(self)

        # used for nesting level *and* interpolation

        self.parent = parent

        # used for the interpolation attribute

        self.main = main

        # level of nesting depth of this Section

        self.depth = depth

        # the sequence of scalar values in this Section

        self.scalars = []

        # the sequence of sections in this Section

        self.sections = []

        # purely for information

        self.name = name

        # for comments :-)

        self.comments = {}

        self.inline_comments = {}

        # for the configspec

        self.configspec = {}

        self._order = []

        self._configspec_comments = {}

        self._configspec_inline_comments = {}

        self._cs_section_comments = {}

        self._cs_section_inline_comments = {}

        # for defaults

        self.defaults = []

        #

        # we do this explicitly so that __setitem__ is used properly

        # (rather than just passing to ``dict.__init__``)

        for entry in indict:

            self[entry] = indict[entry]

    def _interpolate(self, key, value):

        try:

            # do we already have an interpolation engine?

            engine = self._interpolation_engine

        except AttributeError:

            # not yet: first time running _interpolate(), so pick the engine

            name = self.main.interpolation

            if name == True:  # note that "if name:" would be incorrect here

                # backwards-compatibility: interpolation=True means use default

                name = DEFAULT_INTERPOLATION

            name = name.lower()  # so that "Template", "template", etc. all work

            class_ = interpolation_engines.get(name, None)

            if class_ is None:

                # invalid value for self.main.interpolation

                self.main.interpolation = False

                return value

            else:

                # save reference to engine so we don't have to do this again

                engine = self._interpolation_engine = class_(self)

        # let the engine do the actual work

        return engine.interpolate(key, value)

    def __getitem__(self, key):

        """Fetch the item and do string interpolation."""

        val = dict.__getitem__(self, key)

        if self.main.interpolation and isinstance(val, StringTypes):

            return self._interpolate(key, val)

        return val

    def __setitem__(self, key, value, unrepr=False):

        """

        Correctly set a value.

        Making dictionary values Section instances.

        (We have to special case 'Section' instances - which are also dicts)

        Keys must be strings.

        Values need only be strings (or lists of strings) if

        ``main.stringify`` is set.

        `unrepr`` must be set when setting a value to a dictionary, without

        creating a new sub-section.

        """

        if not isinstance(key, StringTypes):

            raise ValueError, 'The key "%s" is not a string.' % key

        # add the comment

        if not self.comments.has_key(key):

            self.comments[key] = []

            self.inline_comments[key] = ''

        # remove the entry from defaults

        if key in self.defaults:

            self.defaults.remove(key)

        #

        if isinstance(value, Section):

            if not self.has_key(key):

                self.sections.append(key)

            dict.__setitem__(self, key, value)

        elif isinstance(value, dict) and not unrepr:

            # First create the new depth level,

            # then create the section

            if not self.has_key(key):

                self.sections.append(key)

            new_depth = self.depth + 1

            dict.__setitem__(

                self,

                key,

                Section(

                    self,

                    new_depth,

                    self.main,

                    indict=value,

                    name=key))

        else:

            if not self.has_key(key):

                self.scalars.append(key)

            if not self.main.stringify:

                if isinstance(value, StringTypes):

                    pass

                elif isinstance(value, (list, tuple)):

                    for entry in value:

                        if not isinstance(entry, StringTypes):

                            raise TypeError, (

                                'Value is not a string "%s".' % entry)

                else:

                    raise TypeError, 'Value is not a string "%s".' % value

            dict.__setitem__(self, key, value)

    def __delitem__(self, key):

        """Remove items from the sequence when deleting."""

        dict. __delitem__(self, key)

        if key in self.scalars:

            self.scalars.remove(key)

        else:

            self.sections.remove(key)

        del self.comments[key]

        del self.inline_comments[key]

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

        """A version of ``get`` that doesn't bypass string interpolation."""

        try:

            return self[key]

        except KeyError:

            return default

    def update(self, indict):

        """

        A version of update that uses our ``__setitem__``.

        """

        for entry in indict:

            self[entry] = indict[entry]

    def pop(self, key, *args):

        """ """

        val = dict.pop(self, key, *args)

        if key in self.scalars:

            del self.comments[key]

            del self.inline_comments[key]

            self.scalars.remove(key)

        elif key in self.sections:

            del self.comments[key]

            del self.inline_comments[key]

            self.sections.remove(key)

        if self.main.interpolation and isinstance(val, StringTypes):

            return self._interpolate(key, val)

        return val

    def popitem(self):

        """Pops the first (key,val)"""

        sequence = (self.scalars + self.sections)

        if not sequence:

            raise KeyError, ": 'popitem(): dictionary is empty'"

        key = sequence[0]

        val =  self[key]

        del self[key]

        return key, val

    def clear(self):

        """

        A version of clear that also affects scalars/sections

        Also clears comments and configspec.

        Leaves other attributes alone :

            depth/main/parent are not affected

        """

        dict.clear(self)

        self.scalars = []

        self.sections = []

        self.comments = {}

        self.inline_comments = {}

        self.configspec = {}

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

        """A version of setdefault that sets sequence if appropriate."""

        try:

            return self[key]

        except KeyError:

            self[key] = default

            return self[key]

    def items(self):

        """ """

        return zip((self.scalars + self.sections), self.values())

    def keys(self):

        """ """

        return (self.scalars + self.sections)

    def values(self):

        """ """

        return [self[key] for key in (self.scalars + self.sections)]

    def iteritems(self):

        """ """

        return iter(self.items())

    def iterkeys(self):

        """ """

        return iter((self.scalars + self.sections))

    __iter__ = iterkeys

    def itervalues(self):

        """ """

        return iter(self.values())

    def __repr__(self):

        return '{%s}' % ', '.join([('%s: %s' % (repr(key), repr(self[key])))

            for key in (self.scalars + self.sections)])

    __str__ = __repr__

    # Extra methods - not in a normal dictionary

    def dict(self):

        """

        Return a deepcopy of self as a dictionary.

        All members that are ``Section`` instances are recursively turned to

        ordinary dictionaries - by calling their ``dict`` method.

        >>> n = a.dict()

        >>> n == a

        1

        >>> n is a

        0

        """

        newdict = {}

        for entry in self:

            this_entry = self[entry]

            if isinstance(this_entry, Section):

                this_entry = this_entry.dict()

            elif isinstance(this_entry, list):

                # create a copy rather than a reference

                this_entry = list(this_entry)

            elif isinstance(this_entry, tuple):

                # create a copy rather than a reference

                this_entry = tuple(this_entry)

            newdict[entry] = this_entry

        return newdict

    def merge(self, indict):

        """

        A recursive update - useful for merging config files.

        >>> a = '''[section1]

        ...     option1 = True

        ...     [[subsection]]

        ...     more_options = False

        ...     # end of file'''.splitlines()

        >>> b = '''# File is user.ini

        ...     [section1]

        ...     option1 = False

        ...     # end of file'''.splitlines()

        >>> c1 = ConfigObj(b)

        >>> c2 = ConfigObj(a)

        >>> c2.merge(c1)

        >>> c2

        {'section1': {'option1': 'False', 'subsection': {'more_options': 'False'}}}

        """

        for key, val in indict.items():

            if (key in self and isinstance(self[key], dict) and

                                isinstance(val, dict)):

                self[key].merge(val)

            else:   

                self[key] = val

    def rename(self, oldkey, newkey):

        """

        Change a keyname to another, without changing position in sequence.

        Implemented so that transformations can be made on keys,

        as well as on values. (used by encode and decode)

        Also renames comments.

        """

        if oldkey in self.scalars:

            the_list = self.scalars

        elif oldkey in self.sections:

            the_list = self.sections

        else:

            raise KeyError, 'Key "%s" not found.' % oldkey

        pos = the_list.index(oldkey)

        #

        val = self[oldkey]

        dict.__delitem__(self, oldkey)

        dict.__setitem__(self, newkey, val)

        the_list.remove(oldkey)

        the_list.insert(pos, newkey)

        comm = self.comments[oldkey]

        inline_comment = self.inline_comments[oldkey]

        del self.comments[oldkey]

        del self.inline_comments[oldkey]

        self.comments[newkey] = comm

        self.inline_comments[newkey] = inline_comment

    def walk(self, function, raise_errors=True,

            call_on_sections=False, **keywargs):

        """

        Walk every member and call a function on the keyword and value.

        Return a dictionary of the return values

        If the function raises an exception, raise the errror

        unless ``raise_errors=False``, in which case set the return value to

        ``False``.

        Any unrecognised keyword arguments you pass to walk, will be pased on

        to the function you pass in.

        Note: if ``call_on_sections`` is ``True`` then - on encountering a

        subsection, *first* the function is called for the *whole* subsection,

        and then recurses into it's members. This means your function must be

        able to handle strings, dictionaries and lists. This allows you

        to change the key of subsections as well as for ordinary members. The

        return value when called on the whole subsection has to be discarded.

        See  the encode and decode methods for examples, including functions.

        .. caution::

            You can use ``walk`` to transform the names of members of a section

            but you mustn't add or delete members.

        >>> config = '''[XXXXsection]

        ... XXXXkey = XXXXvalue'''.splitlines()

        >>> cfg = ConfigObj(config)

        >>> cfg

        {'XXXXsection': {'XXXXkey': 'XXXXvalue'}}