API Reference for Enthought Tool Suite 2.7.1

Variables

• BOM_LIST

  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 = { Const('utf_16') : Const('utf_16'), Const('u16') : Const('utf_16'), Const('utf16') : Const('utf_16'), Const('utf-16') : Const('utf_16'), Const('utf16_be') : Const('utf16_be'), Const('utf_16_be') : Const('utf16_be'), Const('utf-16be') : Const('utf16_be'), Const('utf16_le') : Const('utf16_le'), Const('utf_16_le') : Const('utf16_le'), Const('utf-16le') : Const('utf16_le'), Const('utf_8') : Const('utf_8'), Const('u8') : Const('utf_8'), Const('utf') : Const('utf_8'), Const('utf8') : Const('utf_8'), Const('utf-8') : Const('utf_8') }
  
  

• BOM_SET

  Map of encodings to the BOM to write.

  BOM_SET = { Const('utf_8') : Name('BOM_UTF8'), Const('utf_16') : Name('BOM_UTF16'), Const('utf16_be') : Name('BOM_UTF16_BE'), Const('utf16_le') : Name('BOM_UTF16_LE'), Name('None') : Name('BOM_UTF8') }
  
  

• BOMS

  A dictionary mapping BOM to the encoding to decode with, and what to set the encoding attribute to.

  BOMS = { Name('BOM_UTF8') : Tuple([Const('utf_8'), Name('None')]), Name('BOM_UTF16_BE') : Tuple([Const('utf16_be'), Const('utf_16')]), Name('BOM_UTF16_LE') : Tuple([Const('utf16_le'), Const('utf_16')]), Name('BOM_UTF16') : Tuple([Const('utf_16'), Const('utf_16')]) }
  
  

• compiler

  compiler = None
  
  

• DEFAULT_INDENT_TYPE

  DEFAULT_INDENT_TYPE = '    '
  
  

• DEFAULT_INTERPOLATION

  DEFAULT_INTERPOLATION = 'configparser'
  
  

• interpolation_engines

  interpolation_engines = { Const('configparser') : Name('ConfigParserInterpolation'), Const('template') : Name('TemplateInterpolation') }
  
  

• INTP_VER

  INTP_VER = sys.version_info[:2
  
  

• MAX_INTERPOL_DEPTH

  MAX_INTERPOL_DEPTH = 10
  
  

• OPTION_DEFAULTS

  OPTION_DEFAULTS = { Const('interpolation') : Name('True'), Const('raise_errors') : Name('False'), Const('list_values') : Name('True'), Const('create_empty') : Name('False'), Const('file_error') : Name('False'), Const('configspec') : Name('None'), Const('stringify') : Name('True'), Const('indent_type') : Name('None'), Const('encoding') : Name('None'), Const('default_encoding') : Name('None'), Const('unrepr') : Name('False'), Const('write_empty_values') : Name('False') }
  
  

Classes

• Builder
• ConfigObj - An object to read, create, and write config files.
• ConfigObjError - This is the base class for all errors that ConfigObj raises
• ConfigParserInterpolation - Behaves like ConfigParser.
• ConfigspecError - An error occured whilst parsing a configspec.
• DuplicateError - The keyword or section specified already exists.
• InterpolationEngine - A helper class to help perform string interpolation
• InterpolationError - Base class for the two interpolation errors.
• InterpolationLoopError - Maximum interpolation depth exceeded in string interpolation.
• MissingInterpolationOption - A value specified for interpolation was missing.
• NestingError - This error indicates a level of nesting that doesn't match.
• ParseError - This error indicates that a line is badly written
• RepeatSectionError - This error indicates additional sections in a section with a __many__ (repeated) section.
• Section - A dictionary-like object that represents a section in a config file
• SimpleVal - A simple validator
• TemplateInterpolation - Behaves like string.Template.
• UnknownType
• UnreprError - An error parsing in unrepr mode.

Function summary

• flatten_errors(cfg, res, levels = None, results = None)
• getObj(s)
• unrepr(s)

Functions

• 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
  

• getObj(s)
• unrepr(s)

Imported Names

Copyright © 2002-2008 Enthought, Inc.