~bzr-pqm/bzr/bzr.dev

# configobj.py

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

# Copyright (C) 2005-2008 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

compiler = None

# Bzr modification: Disabled import of 'compiler' module

# bzr doesn't use the 'unrepr' feature of configobj, so importing compiler just

# wastes several milliseconds on every single bzr invocation.

#   -- Andrew Bennetts, 2008-10-14

#try:

#    import compiler

#except ImportError:

#    # for IronPython

#    pass

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

    }

def match_utf8(encoding):

    return BOM_LIST.get(encoding.lower()) == 'utf_8'

# Quote strings used for writing values

squot = "'%s'"

dquot = '"%s"'

noquot = "%s"

wspace_plus = ' \r\t\n\v\t\'"'

tsquot = '"""%s"""'

tdquot = "'''%s'''"

try:

    enumerate

except NameError:

    def enumerate(obj):

        """enumerate for Python 2.2."""

        i = -1

        for item in obj:

            i += 1

            yield i, item

try:

    True, False

except NameError:

    True, False = 1, 0

__version__ = '4.5.2'

__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',

    'ReloadError',

    '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

    if compiler is None:

        raise ImportError('compiler module not available')

    p = compiler.parse(s)

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

class UnknownType(Exception):

    pass

class Builder(object):

    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 undefined 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])

_builder = Builder()

def unrepr(s):

    if not s:

        return s

    return _builder.build(getObj(s))

class ConfigObjError(SyntaxError):

    """

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

    It is a subclass of SyntaxError.

    """

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

        self.line = line

        self.line_number = line_number

        self.msg = msg

        SyntaxError.__init__(self, msg)

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 ReloadError(IOError):

    """

    A 'reload' operation failed.

    This exception is a subclass of ``IOError``.

    """

    def __init__(self):

        IOError.__init__(self, 'reload failed, filename is not set.')

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

        # purely for information

        self.name = name

        #

        self._initialise()

        # we do this explicitly so that __setitem__ is used properly

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

        for entry, value in indict.iteritems():

            self[entry] = value

    def _initialise(self):

        # the sequence of scalar values in this Section

        self.scalars = []

        # the sequence of sections in this Section

        self.sections = []

        # 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 = []

        self.default_values = {}

    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):

        """

        'D.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'

        """

        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):

        """D.items() -> list of D's (key, value) pairs, as 2-tuples"""

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

    def keys(self):

        """D.keys() -> list of D's keys"""

        return (self.scalars + self.sections)

    def values(self):

        """D.values() -> list of D's values"""

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

    def iteritems(self):

        """D.iteritems() -> an iterator over the (key, value) items of D"""

        return iter(self.items())

    def iterkeys(self):

        """D.iterkeys() -> an iterator over the keys of D"""

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

    __iter__ = iterkeys

    def itervalues(self):

        """D.itervalues() -> an iterator over the values of D"""