~bzr-pqm/bzr/bzr.dev

 

 

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

            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:

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

 

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

        """

        raise NotImplementedError()

 

 

class ConfigParserInterpolation(InterpolationEngine):

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.

    """

 

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

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

        """

        A version of clear that also affects scalars/sections

        Also clears comments and configspec.

        Leaves other attributes alone :

            depth/main/parent are not affected

        """

    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

    def merge(self, indict):

        """

        A recursive update - useful for merging config files.

        >>> a = '''[section1]

        ...     option1 = True

        ...     [[subsection]]

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

                                isinstance(val, dict)):

                self[key].merge(val)

                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:

            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)

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

        """

        Encode all strings and values from unicode,

        using the specified encoding.

        Works with subsections and list values.

        Uses the ``walk`` method.

        """

        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.

        ``True``.

        ``False``.

        ``as_bool`` is not case sensitive.

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

        >>> a = ConfigObj()

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

        >>> a.as_bool('a')

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

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

    def restore_default(self, key):

        """

        Restore (and return) default value for the specified key.

        This method will only work for a ConfigObj that was created

        with a configspec and has been validated.

        If there is no default value for this key, ``KeyError`` is raised.

        """

        default = self.default_values[key]

            self.defaults.append(key)

        return default

 

    def restore_defaults(self):

        """

        Recursively restore default values to all members

        that have them.

        This method will only work for a ConfigObj that was created

        with a configspec and has been validated.

        It doesn't delete or modify entries without default values.

        """

        for key in self.default_values:

            self.restore_default(key)

        for section in self.sections:

            self[section].restore_defaults()

 

    def __init__(self, infile=None, options=None, **kwargs):

        """

        Parse a config file or create a config file object.

        ``ConfigObj(infile=None, options=None, **kwargs)``

        """

        # init the superclass

        Section.__init__(self, self, 0, self)

        if infile is None:

            infile = []

        if options is None:

            options = {}

        else:

            options = dict(options)

        # keyword arguments take precedence over an options dictionary

        options.update(kwargs)

        defaults = OPTION_DEFAULTS.copy()

        # TODO: check the values too.

        for entry in options:

            if entry not in defaults:

                raise TypeError('Unrecognised option "%s".' % entry)

        # Add any explicit options to the defaults

        defaults.update(options)

        self._initialise(defaults)

        configspec = defaults['configspec']

        self._original_configspec = configspec

        self._load(infile, configspec)

    def _load(self, infile, configspec):

        if isinstance(infile, StringTypes):

            self.filename = infile

                    h.write('')

                    h.close()

                infile = []

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

            infile = list(infile)

        elif isinstance(infile, dict):

            # initialise self

            # the Section class handles creating subsections

            if isinstance(infile, ConfigObj):

                # get a copy of our ConfigObj

                infile = infile.dict()

            for entry in infile:

                self[entry] = infile[entry]

            del self._errors

            if configspec is not None:

                self._handle_configspec(configspec)

            else:

                self.configspec = None

            return

        elif getattr(infile, 'read', None) is not None:

            # This supports file like objects

            infile = infile.read() or []

            # in case it's not an 8 bit encoding

        else:

            raise TypeError('infile must be a filename, file like object, or list of lines.')

        if infile:

            # don't do it for the empty ConfigObj

            infile = self._handle_bom(infile)

                break

 

            infile = [line.rstrip('\r\n') for line in infile]

        self._parse(infile)

        # if we had any errors, now is the time to raise them

        if self._errors:

            raise error

        # delete private attributes

        del self._errors

        if configspec is None:

            self.configspec = None

        else:

            self._handle_configspec(configspec)

    def _initialise(self, options=None):

        if options is None:

            options = OPTION_DEFAULTS

        # initialise a few variables

        self.filename = None

        self._errors = []

        self.newlines = None

        self.write_empty_values = options['write_empty_values']

        self.unrepr = options['unrepr']

        self.initial_comment = []

        self.final_comment = []

        self.configspec = {}

        # Clear section attributes as well

        Section._initialise(self)

    def __repr__(self):

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

    def _handle_bom(self, infile):

        """

        Handle any BOM, and decode if necessary.

        If an encoding is specified, that *must* be used - but the BOM should

        still be removed (and the BOM attribute set).

        (If the encoding is wrongly specified, then a BOM for an alternative

        encoding won't be discovered or removed.)

        If an encoding is not specified, UTF8 or UTF16 BOM will be detected and

        removed. The BOM attribute will be set. UTF16 will be decoded to

        unicode.

        NOTE: This method must not be called with an empty ``infile``.

        Specifying the *wrong* encoding is likely to cause a

        ``UnicodeDecodeError``.

        ``infile`` must always be returned as a list of lines, but may be

        passed in as a single string.

        """

            # the encoding specified doesn't have one

            # just decode

            return self._decode(infile, self.encoding)

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

            line = infile[0]

        else:

                        ##self.BOM = True

                        # Don't need to remove BOM

                        return self._decode(infile, encoding)

                # If we get this far, will *probably* raise a DecodeError

                # As it doesn't appear to start with a BOM

                return self._decode(infile, self.encoding)

            # Must be UTF8

            BOM = BOM_SET[enc]

            if not line.startswith(BOM):

                return self._decode(infile, self.encoding)

            newline = line[len(BOM):]

            # BOM removed

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

                infile[0] = newline

                infile = newline

            self.BOM = True

            return self._decode(infile, self.encoding)

        # No encoding specified - so we need to check for UTF8/UTF16

        for BOM, (encoding, final_encoding) in BOMS.items():

            if not line.startswith(BOM):

                        return infile

                # UTF16 - have to decode

                return self._decode(infile, encoding)

        # No BOM discovered and no encoding specified, just return

        if isinstance(infile, StringTypes):

            # infile read from a file will be a single string

    def _decode(self, infile, encoding):

        """

        Decode infile to unicode. Using the specified encoding.

        if is a string, it also needs converting to a list.

        """

        if isinstance(infile, StringTypes):

        temp_list_values = self.list_values

        if self.unrepr:

            self.list_values = False

        comment_list = []

        done_start = False

        this_section = self

        maxline = len(infile) - 1

        cur_index = -1

        reset_comment = False

        while cur_index < maxline:

            if reset_comment:

                comment_list = []

                reset_comment = False

                comment_list.append(line)

                continue

            if not done_start:

                # preserve initial comment

                self.initial_comment = comment_list

                comment_list = []

                done_start = True

            reset_comment = True

            # first we check if it's a section marker

            mat = self._sectionmarker.match(line)

                    self._handle_error("Cannot compute the section depth at line %s.",

                                       NestingError, infile, cur_index)

                    continue

                if cur_depth < this_section.depth:

                    # the new section is dropping back to a previous level

                    try:

                else:

                    self._handle_error("Section too nested at line %s.",

                                       NestingError, infile, cur_index)

                sect_name = self._unquote(sect_name)

                if parent.has_key(sect_name):

                    self._handle_error('Duplicate section name at line %s.',

                                       DuplicateError, infile, cur_index)

                    continue

                # create the new section

                this_section = Section(

                    parent,

        """

        Given a section and a depth level, walk back through the sections

        parents to see if the depth level matches a previous section.

        Return a reference to the right section,

        or raise a SyntaxError.

        """

    def _handle_error(self, text, ErrorClass, infile, cur_index):

        """

        Handle an error according to the error settings.

        Either raise the error or store it.

        The error will have occured at ``cur_index``

        """

    def _quote(self, value, multiline=True):

        """

        Return a safely quoted version of a value.

        Raise a ConfigObjError if the value cannot be safely quoted.

        If multiline is ``True`` (default) then use triple quotes

        if necessary.

        Don't quote values that don't need it.

        Recursively quote members of a list and return a comma joined list.

        Multiline is ``False`` for lists.

        Obey list syntax for empty and single member lists.

        If ``list_values=False`` then the value is only quoted if it contains

        a ``\n`` (is multiline) or '#'.

        If ``write_empty_values`` is set, and the value is an empty string, it

        won't be quoted.

        """

            # Only if multiline is set, so that it is used for values not

            # keys, and not values that are part of a list

            return ''

        if multiline and isinstance(value, (list, tuple)):

            if not value:

                return ','

 

        if not value:

            return '""'

        no_lists_no_quotes = not self.list_values and '\n' not in value and '#' not in value

        need_triple = multiline and ((("'" in value) and ('"' in value)) or ('\n' in value ))

        hash_triple_quote = multiline and not need_triple and ("'" in value) and ('"' in value) and ('#' in value)

        check_for_single = (no_lists_no_quotes or not need_triple) and not hash_triple_quote

        if check_for_single:

            if not self.list_values:

                # we don't quote if ``list_values=False``

        else:

            # if value has '\n' or "'" *and* '"', it will need triple quotes

            quot = self._get_triple_quote(value)

        if quot == noquot and '#' in value and self.list_values:

            quot = self._get_single_quote(value)

        return quot % value

    def _get_single_quote(self, value):

        if ("'" in value) and ('"' in value):

            raise ConfigObjError('Value "%s" cannot be safely quoted.' % value)

        else:

            quot = dquot

        return quot

    def _get_triple_quote(self, value):

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

            raise ConfigObjError('Value "%s" cannot be safely quoted.' % value)

        if value.find('"""') == -1:

            quot = tdquot

        else:

        return quot

 

 

 

    def _handle_configspec(self, configspec):

        """Parse the configspec."""

        #        correct settings ? (i.e. ``list_values=False``)

        if not isinstance(configspec, ConfigObj):

            try:

                raise ConfigspecError('Parsing configspec failed: %s' % e)

            except IOError, e:

                raise IOError('Reading configspec failed: %s' % e)

        self._set_configspec_value(configspec, self)

 

 

            if len(configspec.sections) > 1:

                # FIXME: can we supply any useful information here ?

                raise RepeatSectionError()

        if getattr(configspec, 'initial_comment', None) is not None:

            section._configspec_initial_comment = configspec.initial_comment

            section._configspec_final_comment = configspec.final_comment

            section._configspec_BOM = configspec.BOM

            section._configspec_newlines = configspec.newlines

            section._configspec_indent_type = configspec.indent_type

        for entry in configspec.scalars:

            section._configspec_comments[entry] = configspec.comments[entry]

            section._configspec_inline_comments[entry] = configspec.inline_comments[entry]

            section.configspec[entry] = configspec[entry]

            section._order.append(entry)

        for entry in configspec.sections:

            if entry == '__many__':

                continue

            section._cs_section_comments[entry] = configspec.comments[entry]

            section._cs_section_inline_comments[entry] = configspec.inline_comments[entry]

            if not section.has_key(entry):

            section_keys = configspec.sections

            scalar_keys = configspec.scalars

        except AttributeError:

                                if isinstance(configspec[entry], dict)]

                                if not isinstance(configspec[entry], dict)]

        if '__many__' in section_keys and len(section_keys) > 1:

            # FIXME: can we supply any useful information here ?

            raise RepeatSectionError()

        scalars = {}

        sections = {}

        for entry in scalar_keys:

                scalars[entry] = val

                continue

            sections[entry] = val

        section.configspec = scalars

        for entry in sections:

            if not section.has_key(entry):

    def write(self, outfile=None, section=None):

        """

        Write the current ConfigObj as a file

        tekNico: FIXME: use StringIO instead of real files

        >>> filename = a.filename

        >>> a.filename = 'test.ini'

        >>> a.write()

        if self.indent_type is None:

            # this can be true if initialised from a dictionary

            self.indent_type = DEFAULT_INDENT_TYPE

        out = []

        cs = self._a_to_u('#')

        csp = self._a_to_u('# ')

                if stripped_line and not stripped_line.startswith(cs):

                    line = csp + line

                out.append(line)

        indent_string = self.indent_type * section.depth

        for entry in (section.scalars + section.sections):

            if entry in section.defaults:

                out.append(indent_string + comment_line)

            this_entry = section[entry]

            comment = self._handle_comment(section.inline_comments[entry])

            if isinstance(this_entry, dict):

                # a section

                out.append(self._write_marker(

                    entry,

                    this_entry,

                    comment))

        if section is self:

            for line in self.final_comment:

                line = self._decode_element(line)

                    line = csp + line

                out.append(line)

            self.interpolation = int_val

        if section is not self:

            return out

        if (self.filename is None) and (outfile is None):

            # output a list of lines

            # might need to encode

                    out.append('')

                out[0] = BOM_UTF8 + out[0]

            return out

        # Turn the list to a string, joined with correct newlines

        newline = self.newlines or os.linesep

        output = self._a_to_u(newline).join(out)

        if self.BOM and ((self.encoding is None) or match_utf8(self.encoding)):

            # Add the UTF8 BOM

            output = BOM_UTF8 + output

        if not output.endswith(newline):

            output += newline

        if outfile is not None:

                 section=None):

        """

        Test the ConfigObj against a configspec.

        It uses the ``validator`` object from *validate.py*.

        To run ``validate`` on the current ConfigObj, call: ::

            test = config.validate(validator)

        (Normally having previously passed in the configspec when the ConfigObj

        was created - you can dynamically assign a dictionary of checks to the

        ``configspec`` attribute of a section though).

        It returns ``True`` if everything passes, or a dictionary of

        pass/fails (True/False). If every member of a subsection passes, it

        will just have the value ``True``. (It also returns ``False`` if all

        members fail).

        In addition, it converts the values from strings to their native

        types if their checks pass (and ``stringify`` is set).

        If ``preserve_errors`` is ``True`` (``False`` is default) then instead

        of a marking a fail with a ``False``, it will preserve the actual

        exception object. This can contain info about the reason for failure.

        For example the ``VdtValueTooSmallError`` indicates that the value

        supplied was too small. If a value (or section) is missing it will

        still be marked as ``False``.

        You must have the validate module to use ``preserve_errors=True``.

        You can then use the ``flatten_errors`` function to turn your nested

        results dictionary into a flattened list of failures - useful for

        displaying meaningful error messages.

            section.BOM = section._configspec_BOM

            section.newlines = section._configspec_newlines

            section.indent_type = section._configspec_indent_type

        if '__many__' in section.configspec:

            many = spec_section['__many__']

            # dynamically assign the configspecs

                    ret_false = False

                ret_true = False

            else:

                    section.default_values.pop(entry, None)

                    # For Python 2.2 compatibility

                    try:

                        del section.default_values[entry]

                    except KeyError:

                        pass

                if getattr(validator, 'get_default_value', None) is not None:

                        section.default_values[entry] = validator.get_default_value(spec_section[entry])

                    except KeyError:

                        # No default

                        pass

                ret_false = False

                out[entry] = True

                if self.stringify or missing:

        self.configspec = None

        # Just to be sure ;-)

        self._original_configspec = None

    def reload(self):

        """

        Reload a ConfigObj from file.

        This method raises a ``ReloadError`` if the ConfigObj doesn't have

        a filename attribute pointing to a file.

        """

            if entry == 'configspec':

                continue

            current_options[entry] = getattr(self, entry)

        configspec = self._original_configspec

        current_options['configspec'] = configspec

        self.clear()

        self._initialise(current_options)

        self._load(filename, configspec)

 

 

class SimpleVal(object):

    """

    A simple validator.

    Can be used to check that all members expected are present.

    To use it, provide a configspec with all your members in (the value given

    will be ignored). Pass an instance of ``SimpleVal`` to the ``validate``

    method of your ``ConfigObj``. ``validate`` will return ``True`` if all

    members are present, or a dictionary with True/False meaning

    present/missing. (Whole missing sections will be replaced with ``False``)

    """

    def __init__(self):

        self.baseErrorClass = ConfigObjError

    def check(self, check, member, missing=False):

        """A dummy check method, always returns the value unchanged."""

        if missing:

    """

    An example function that will turn a nested dictionary of results

    (as returned by ``ConfigObj.validate``) into a flat list.

    ``cfg`` is the ConfigObj instance being checked, ``res`` is the results

    dictionary returned by ``validate``.

    (This is a recursive function, so you shouldn't use the ``levels`` or

    ``results`` arguments - they are used by the function.

    Returns a list of keys that failed. Each member of the list is a tuple :

    ::

        ([list of sections...], key, result)

    If ``validate`` was called with ``preserve_errors=False`` (the default)

    then ``result`` will always be ``False``.

 

    *list of sections* is a flattened list of sections that the key was found

    in.

    If the section was missing then key will be ``None``.

    If the value (or section) was missing then ``result`` will be ``False``.

    If ``validate`` was called with ``preserve_errors=True`` and a value

    was present, but failed the check, then ``result`` will be the exception

    object returned. You can use this as a string that describes the failure.

    For example *The value "3" is of the wrong type*.

    >>> import validate

    >>> vtor = validate.Validator()

    >>> my_ini = '''