Module p.u.configobj

Part of pida.utils

No module docstring
Line # Kind Name Docs
99 Function enumerate enumerate for Python 2.2.
160 Function getObj Undocumented
167 Class UnknownType Undocumented
170 Class Builder Undocumented
225 Function unrepr Undocumented
230 Function _splitlines Split a string on lines, without losing line endings or truncating.
234 Class ConfigObjError This is the base class for all errors that ConfigObj raises.
245 Class NestingError This error indicates a level of nesting that doesn't match.
250 Class ParseError This error indicates that a line is badly written.
257 Class DuplicateError The keyword or section specified already exists.
262 Class ConfigspecError An error occured whilst parsing a configspec.
267 Class InterpolationError Base class for the two interpolation errors.
270 Class InterpolationLoopError Maximum interpolation depth exceeded in string interpolation.
278 Class RepeatSectionError This error indicates additional sections in a section with a
284 Class MissingInterpolationOption A value specified for interpolation was missing.
292 Class UnreprError An error parsing in unrepr mode.
296 Class InterpolationEngine A helper class to help perform string interpolation.
411 Class ConfigParserInterpolation Behaves like ConfigParser.
421 Class TemplateInterpolation Behaves like string.Template.
450 Class Section A dictionary-like object that represents a section in a config file.
1027 Class ConfigObj An object to read, create, and write config files.
2135 Class SimpleVal A simple validator.
2157 Function flatten_errors An example function that will turn a nested dictionary of results
def enumerate(obj):
enumerate for Python 2.2.
def getObj(s):
Undocumented
def unrepr(s):
Undocumented
def _splitlines(instring):
Split a string on lines, without losing line endings or truncating.
def flatten_errors(cfg, res, levels=None, results=None):
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 = '''
...     option1 = True
...     [section1]
...     option1 = True
...     [section2]
...     another_option = Probably
...     [section3]
...     another_option = True
...     [[section3b]]
...     value = 3
...     value2 = a
...     value3 = 11
...     '''
>>> my_cfg = '''
...     option1 = boolean()
...     option2 = boolean()
...     option3 = boolean(default=Bad_value)
...     [section1]
...     option1 = boolean()
...     option2 = boolean()
...     option3 = boolean(default=Bad_value)
...     [section2]
...     another_option = boolean()
...     [section3]
...     another_option = boolean()
...     [[section3b]]
...     value = integer
...     value2 = integer
...     value3 = integer(0, 10)
...         [[[section3b-sub]]]
...         value = string
...     [section4]
...     another_option = boolean()
...     '''
>>> cs = my_cfg.split('\n')
>>> ini = my_ini.split('\n')
>>> cfg = ConfigObj(ini, configspec=cs)
>>> res = cfg.validate(vtor, preserve_errors=True)
>>> errors = []
>>> for entry in flatten_errors(cfg, res):
...     section_list, key, error = entry
...     section_list.insert(0, '[root]')
...     if key is not None:
...        section_list.append(key)
...     else:
...         section_list.append('[missing]')
...     section_string = ', '.join(section_list)
...     errors.append((section_string, ' = ', error))
>>> errors.sort()
>>> for entry in errors:
...     print entry[0], entry[1], (entry[2] or 0)
[root], option2  =  0
[root], option3  =  the value "Bad_value" is of the wrong type.
[root], section1, option2  =  0
[root], section1, option3  =  the value "Bad_value" is of the wrong type.
[root], section2, another_option  =  the value "Probably" is of the wrong type.
[root], section3, section3b, section3b-sub, [missing]  =  0
[root], section3, section3b, value2  =  the value "a" is of the wrong type.
[root], section3, section3b, value3  =  the value "11" is too big.
[root], section4, [missing]  =  0
API Documentation for PIDA, generated by pydoctor.