~bzr-pqm/bzr/bzr.dev

# configobj.py

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

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

"""

    >>> z = ConfigObj()

    >>> z['a'] = 'a'

    >>> z['sect'] = {

    ...    'subsect': {

    ...         'a': 'fish',

    ...         'b': 'wobble',

    ...     },

    ...     'member': 'value',

    ... }

    >>> x = ConfigObj(z.write())

    >>> z == x

    1

"""

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 types import StringTypes

from warnings import warn

from codecs import BOM_UTF8, BOM_UTF16, BOM_UTF16_BE, BOM_UTF16_LE

# 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

    }

try:

    from validate import VdtMissingValue

except ImportError:

    VdtMissingValue = None

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.2.0beta2'

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

__docformat__ = "restructuredtext en"

# NOTE: Does it make sense to have the following in __all__ ?

# NOTE: DEFAULT_INDENT_TYPE, NUM_INDENT_SPACES, MAX_INTERPOL_DEPTH

# NOTE: If used as from configobj import...

# NOTE: They are effectively read only

__all__ = (

    '__version__',

    'DEFAULT_INDENT_TYPE',

    'NUM_INDENT_SPACES',

    'MAX_INTERPOL_DEPTH',

    'ConfigObjError',

    'NestingError',

    'ParseError',

    'DuplicateError',

    'ConfigspecError',

    'ConfigObj',

    'SimpleVal',

    'InterpolationError',

    'InterpolationDepthError',

    'MissingInterpolationOption',

    'RepeatSectionError',

    '__docformat__',

    'flatten_errors',

)

DEFAULT_INDENT_TYPE = ' '

NUM_INDENT_SPACES = 4

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,

}

class ConfigObjError(SyntaxError):

    """

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

    It is a subclass of SyntaxError.

    >>> raise ConfigObjError

    Traceback (most recent call last):

    ConfigObjError

    """

    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.

    >>> raise NestingError

    Traceback (most recent call last):

    NestingError

    """

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.

    >>> raise ParseError

    Traceback (most recent call last):

    ParseError

    """

class DuplicateError(ConfigObjError):

    """

    The keyword or section specified already exists.

    >>> raise DuplicateError

    Traceback (most recent call last):

    DuplicateError

    """

class ConfigspecError(ConfigObjError):

    """

    An error occured whilst parsing a configspec.

    >>> raise ConfigspecError

    Traceback (most recent call last):

    ConfigspecError

    """

class InterpolationError(ConfigObjError):

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

class InterpolationDepthError(InterpolationError):

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

    def __init__(self, option):

        """

        >>> raise InterpolationDepthError('yoda')

        Traceback (most recent call last):

        InterpolationDepthError: max interpolation depth exceeded in value "yoda".

        """

        InterpolationError.__init__(

            self,

            'max interpolation depth exceeded in value "%s".' % option)

class RepeatSectionError(ConfigObjError):

    """

    This error indicates additional sections in a section with a

    ``__many__`` (repeated) section.

    >>> raise RepeatSectionError

    Traceback (most recent call last):

    RepeatSectionError

    """

class MissingInterpolationOption(InterpolationError):

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

    def __init__(self, option):

        """

        >>> raise MissingInterpolationOption('yoda')

        Traceback (most recent call last):

        MissingInterpolationOption: missing option "yoda" in interpolation.

        """

        InterpolationError.__init__(

            self,

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

class Section(dict):

    """

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

    It does string interpolation if the 'interpolate' attribute

    of the 'main' object is set to True.

    Interpolation is tried first from the 'DEFAULT' section of this object,

    next from the 'DEFAULT' section of the parent, lastly the main object.

    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.

    """

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

    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 = {}

        # 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, value):

        """Nicked from ConfigParser."""

        depth = MAX_INTERPOL_DEPTH

        # loop through this until it's done

        while depth:

            depth -= 1

            if value.find("%(") != -1:

                value = self._KEYCRE.sub(self._interpolation_replace, value)

            else:

                break

        else:

            raise InterpolationDepthError(value)

        return value

    def _interpolation_replace(self, match):

        """ """

        s = match.group(1)

        if s is None:

            return match.group()

        else:

            # switch off interpolation before we try and fetch anything !

            self.main.interpolation = False

            # try the 'DEFAULT' member of *this section* first

            val = self.get('DEFAULT', {}).get(s)

            # try the 'DEFAULT' member of the *parent section* next

            if val is None:

                val = self.parent.get('DEFAULT', {}).get(s)

            # last, try the 'DEFAULT' member of the *main section*

            if val is None:

                val = self.main.get('DEFAULT', {}).get(s)

            self.main.interpolation = True

            if val is None:

                raise MissingInterpolationOption(s)

            return val

    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(val)

        return val

    def __setitem__(self, key, value):

        """

        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.

        """

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

            # 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(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, tuple)):

                # create a copy rather than a reference

                this_entry = list(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'}}

        >>> def transform(section, key):

        ...     val = section[key]

        ...     newkey = key.replace('XXXX', 'CLIENT1')

        ...     section.rename(key, newkey)

        ...     if isinstance(val, (tuple, list, dict)):

        ...         pass

        ...     else:

        ...         val = val.replace('XXXX', 'CLIENT1')

        ...         section[newkey] = val

        >>> cfg.walk(transform, call_on_sections=True)

        {'CLIENT1section': {'CLIENT1key': None}}

        >>> cfg

        {'CLIENT1section': {'CLIENT1key': 'CLIENT1value'}}

        """

        out = {}

        # scalars first

        for i in range(len(self.scalars)):

            entry = self.scalars[i]

            try:

                val = function(self, entry, **keywargs)

                # bound again in case name has changed

                entry = self.scalars[i]

                out[entry] = val

            except Exception:

                if raise_errors:

                    raise

                else:

                    entry = self.scalars[i]

                    out[entry] = False

        # then sections

        for i in range(len(self.sections)):

            entry = self.sections[i]

            if call_on_sections:

                try:

                    function(self, entry, **keywargs)

                except Exception:

                    if raise_errors:

                        raise

                    else:

                        entry = self.sections[i]

                        out[entry] = False

                # bound again in case name has changed

                entry = self.sections[i]

            # previous result is discarded

            out[entry] = self[entry].walk(

                function,

                raise_errors=raise_errors,

                call_on_sections=call_on_sections,

                **keywargs)

        return out

    def decode(self, encoding):

        """

        Decode all strings and values to unicode, using the specified encoding.

        Works with subsections and list values.

        Uses the ``walk`` method.

        Testing ``encode`` and ``decode``.

        >>> m = ConfigObj(a)

        >>> m.decode('ascii')

        >>> def testuni(val):

        ...     for entry in val:

        ...         if not isinstance(entry, unicode):

        ...             print >> sys.stderr, type(entry)

        ...             raise AssertionError, 'decode failed.'

        ...         if isinstance(val[entry], dict):

        ...             testuni(val[entry])

        ...         elif not isinstance(val[entry], unicode):

        ...             raise AssertionError, 'decode failed.'

        >>> testuni(m)

        >>> m.encode('ascii')

        >>> a == m

        1

        """

        def decode(section, key, encoding=encoding):

            """ """

            val = section[key]

            if isinstance(val, (list, tuple)):

                newval = []

                for entry in val:

                    newval.append(entry.decode(encoding))

            elif isinstance(val, dict):

                newval = val

            else:

                newval = val.decode(encoding)

            newkey = key.decode(encoding)

            section.rename(key, newkey)

            section[newkey] = newval

        # using ``call_on_sections`` allows us to modify section names

        self.walk(decode, call_on_sections=True)

    def encode(self, encoding):

        """

        Encode all strings and values from unicode,

        using the specified encoding.

        Works with subsections and list values.

        Uses the ``walk`` method.

        """

        def encode(section, key, encoding=encoding):

            """ """

            val = section[key]

            if isinstance(val, (list, tuple)):

                newval = []

                for entry in val:

                    newval.append(entry.encode(encoding))

            elif isinstance(val, dict):

                newval = val

            else:

                newval = val.encode(encoding)

            newkey = key.encode(encoding)

            section.rename(key, newkey)

            section[newkey] = newval

        self.walk(encode, call_on_sections=True)

    def istrue(self, key):

        """A deprecated version of ``as_bool``."""

        warn('use of ``istrue`` is deprecated. Use ``as_bool`` method '

                'instead.', DeprecationWarning)

        return self.as_bool(key)

    def as_bool(self, key):

        """

        Accepts a key as input. The corresponding value must be a string or

        the objects (``True`` or 1) or (``False`` or 0). We allow 0 and 1 to

        retain compatibility with Python 2.2.

        If the string is one of  ``True``, ``On``, ``Yes``, or ``1`` it returns 

        ``True``.

        If the string is one of  ``False``, ``Off``, ``No``, or ``0`` it returns 

        ``False``.

        ``as_bool`` is not case sensitive.

        Any other input will raise a ``ValueError``.

        >>> a = ConfigObj()

        >>> a['a'] = 'fish'

        >>> a.as_bool('a')

        Traceback (most recent call last):

        ValueError: Value "fish" is neither True nor False

        >>> a['b'] = 'True'

        >>> a.as_bool('b')

        1

        >>> a['b'] = 'off'

        >>> a.as_bool('b')

        0

        """

        val = self[key]

        if val == True:

            return True

        elif val == False:

            return False

        else:

            try:

                if not isinstance(val, StringTypes):

                    raise KeyError

                else:

                    return self.main._bools[val.lower()]

            except KeyError:

                raise ValueError('Value "%s" is neither True nor False' % val)

    def as_int(self, key):

        """

        A convenience method which coerces the specified value to an integer.

        If the value is an invalid literal for ``int``, a ``ValueError`` will

        be raised.

        >>> a = ConfigObj()

        >>> a['a'] = 'fish'

        >>> a.as_int('a')

        Traceback (most recent call last):

        ValueError: invalid literal for int(): fish

        >>> a['b'] = '1'

        >>> a.as_int('b')

        1

        >>> a['b'] = '3.2'

        >>> a.as_int('b')

        Traceback (most recent call last):

        ValueError: invalid literal for int(): 3.2

        """

        return int(self[key])

    def as_float(self, key):

        """

        A convenience method which coerces the specified value to a float.

        If the value is an invalid literal for ``float``, a ``ValueError`` will

        be raised.

        >>> a = ConfigObj()

        >>> a['a'] = 'fish'

        >>> a.as_float('a')

        Traceback (most recent call last):

        ValueError: invalid literal for float(): fish

        >>> a['b'] = '1'

        >>> a.as_float('b')

        1.0

        >>> a['b'] = '3.2'

        >>> a.as_float('b')

        3.2000000000000002

        """

        return float(self[key])

class ConfigObj(Section):

    """

    An object to read, create, and write config files.

    Testing with duplicate keys and sections.

    >>> c = '''

    ... [hello]

    ... member = value

    ... [hello again]

    ... member = value

    ... [ "hello" ]

    ... member = value

    ... '''

    >>> ConfigObj(c.split('\\n'), raise_errors = True)

    Traceback (most recent call last):

    DuplicateError: Duplicate section name at line 5.

    >>> d = '''

    ... [hello]

    ... member = value

    ... [hello again]

    ... member1 = value

    ... member2 = value

    ... 'member1' = value

    ... [ "and again" ]

    ... member = value

    ... '''

    >>> ConfigObj(d.split('\\n'), raise_errors = True)

    Traceback (most recent call last):

    DuplicateError: Duplicate keyword name at line 6.

    """

    _keyword = re.compile(r'''^ # line start