2.1   Installing

ConfigObj has a source distribution on PyPI. If you unzip the archive you can install it with:

setup.py install

Alternatively, you can install with easy install or pip:

easy_install configobj

2.2   Documentation

configobj.zip also contains this document.

• You can view this document online at the ConfigObj Homepage.

2.3   Development Version

It is sometimes possible to get the latest development version of ConfigObj from the Subversion Repository maintained on the Google Code Homepage.

4.1   Reading a Config File

The normal way to read a config file, is to give ConfigObj the filename :

from configobj import ConfigObj
config = ConfigObj(filename)

You can also pass the config file in as a list of lines, or a StringIO instance, so it doesn't matter where your config data comes from.

You can then access members of your config file as a dictionary. Subsections will also be dictionaries.

from configobj import ConfigObj
config = ConfigObj(filename)
#
value1 = config['keyword1']
value2 = config['keyword2']
#
section1 = config['section1']
value3 = section1['keyword3']
value4 = section1['keyword4']
#
# you could also write
value3 = config['section1']['keyword3']
value4 = config['section1']['keyword4']

4.2   Writing a Config File

Creating a new config file is just as easy as reading one. You can specify a filename when you create the ConfigObj, or do it later [2].

If you don't set a filename, then the write method will return a list of lines instead of writing to file. See the write method for more details.

Here we show creating an empty ConfigObj, setting a filename and some values, and then writing to file :

from configobj import ConfigObj
config = ConfigObj()
config.filename = filename
#
config['keyword1'] = value1
config['keyword2'] = value2
#
config['section1'] = {}
config['section1']['keyword3'] = value3
config['section1']['keyword4'] = value4
#
section2 = {
    'keyword5': value5,
    'keyword6': value6,
    'sub-section': {
        'keyword7': value7
        }
}
config['section2'] = section2
#
config['section3'] = {}
config['section3']['keyword 8'] = [value8, value9, value10]
config['section3']['keyword 9'] = [value11, value12, value13]
#
config.write()

4.3   Config Files

The config files that ConfigObj will read and write are based on the 'INI' format. This means it will read and write files created for ConfigParser [4].

Keywords and values are separated by an '=', and section markers are between square brackets. Keywords, values, and section names can be surrounded by single or double quotes. Indentation is not significant, but can be preserved.

Subsections are indicated by repeating the square brackets in the section marker. You nest levels by using more brackets.

You can have list values by separating items with a comma, and values spanning multiple lines by using triple quotes (single or double).

For full details on all these see the config file format. Here's an example to illustrate:

# This is the 'initial_comment'
# Which may be several lines
keyword1 = value1
'keyword 2' = 'value 2'

[ "section 1" ]
# This comment goes with keyword 3
keyword 3 = value 3
'keyword 4' = value4, value 5, 'value 6'

    [[ sub-section ]]    # an inline comment
    # sub-section is inside "section 1"
    'keyword 5' = 'value 7'
    'keyword 6' = '''A multiline value,
that spans more than one line :-)
The line breaks are included in the value.'''

        [[[ sub-sub-section ]]]
        # sub-sub-section is *in* 'sub-section'
        # which is in 'section 1'
        'keyword 7' = 'value 8'

[section 2]    # an inline comment
keyword8 = "value 9"
keyword9 = value10     # an inline comment
# The 'final_comment'
# Which also may be several lines

5.1   Methods

The ConfigObj is a subclass of an object called Section, which is itself a subclass of dict, the builtin dictionary type. This means it also has all the normal dictionary methods.

In addition, the following Section Methods may be useful :

• 'restore_default'
• 'restore_defaults'
• 'walk'
• 'merge'
• 'dict'
• 'as_bool'
• 'as_float'
• 'as_int'
• 'as_list'

Read about Sections for details of all the methods.

The public methods available on ConfigObj are :

• 'write'
• 'validate'
• 'reset'
• 'reload'

write(file_object=None)

validate(validator, preserve_errors=False, copy=False)

# filename is the config file
# filename2 is the configspec
# (which could also be hardcoded into your program)
config = ConfigObj(filename, configspec=filename2)
#
from validate import Validator
val = Validator()
test = config.validate(val)
if test == True:
    print 'Succeeded.'

from configobj import ConfigObj
configspec = ConfigObj(configspecfilename, encoding='UTF8',
                       list_values=False, _inspec=True)
config = ConfigObj(filename, configspec=configspec)

key1 = integer(0, 30, default=15)
key2 = integer(default=15)
key3 = boolean(default=True)
key4 = option('Hello', 'Goodbye', 'Not Today', default='Not Today')

val = SimpleVal()
test = config.validate(val)
if test is True:
    print 'Succeeded.'

5.2   Attributes

A ConfigObj has the following attributes :

• indent_type
• interpolation
• stringify
• BOM
• initial_comment
• final_comment
• list_values
• encoding
• default_encoding
• unrepr
• write_empty_values
• newlines

It also has the following attributes as a result of parsing. They correspond to options when the ConfigObj was created, but changing them has no effect.

• raise_errors
• create_empty
• file_error

7.1   Section Attributes

• main

  A reference to the main ConfigObj.

• parent

  A reference to the 'parent' section, the section that this section is a member of.

  On the ConfigObj this attribute is a reference to itself. You can use this to walk up the sections, stopping when section.parent is section.

• depth

  The nesting level of the current section.

  If you create a new ConfigObj and add sections, 1 will be added to the depth level between sections.

• defaults

  This attribute is a list of scalars that came from default values. Values that came from defaults aren't written out by the write method. Setting any of these values in the section removes them from the defaults list.

• default_values

  This attribute is a dictionary mapping keys to the default values for the keys. By default it is an empty dictionary and is populated when you validate the ConfigObj.

• scalars, sections

  These attributes are normal lists, representing the order that members, single values and subsections appear in the section. The order will either be the order of the original config file, or the order that you added members.

  The order of members in this lists is the order that write creates in the config file. The scalars list is output before the sections list.

  Adding or removing members also alters these lists. You can manipulate the lists directly to alter the order of members.

  Warning

  If you alter the scalars, sections, or defaults attributes so that they no longer reflect the contents of the section, you will break your ConfigObj.

  See also the rename method.

• comments

  This is a dictionary of comments associated with each member. Each entry is a list of lines. These lines are written out before the member.

• inline_comments

  This is another dictionary of comments associated with each member. Each entry is a string that is put inline with the member.

• configspec

  The configspec attribute is a dictionary mapping scalars to checks. A check defines the expected type and possibly the allowed values for a member.

  The configspec has the same format as a config file, but instead of values it has a specification for the value (which may include a default value). The validate method uses it to check the config file makes sense. If a configspec is passed in when the ConfigObj is created, then it is parsed and broken up to become the configspec attribute of each section.

  If you didn't pass in a configspec, this attribute will be None on the root section (the main ConfigObj).

  You can set the configspec attribute directly on a section.

  See the validation section for full details of how to write configspecs.

• extra_values

  By default an empty list. After validation this is populated with any members of the section that don't appear in the configspec (i.e. they are additional values). Rather than accessing this directly it may be more convenient to get all the extra values in a config file using the get_extra_values function.

  New in ConfigObj 4.7.0.

7.2   Section Methods

• dict

  This method takes no arguments. It returns a deep copy of the section as a dictionary. All subsections will also be dictionaries, and list values will be copies, rather than references to the original [10].

• rename

  rename(oldkey, newkey)

  This method renames a key, without affecting its position in the sequence.

• merge

  merge(indict)

  This method is a recursive update method. It allows you to merge two config files together.

  You would typically use this to create a default ConfigObj and then merge in user settings. This way users only need to specify values that are different from the default.

  For example :

  # def_cfg contains your default config settings
  # user_cfg contains the user settings
  cfg = ConfigObj(def_cfg)
  usr = ConfigObj(user_cfg)
  #
  cfg.merge(usr)
  
  """
  cfg now contains a combination of the default settings and the user
  settings.
  
  The user settings will have overwritten any of the default ones.
  """
  

• walk

  This method can be used to transform values and names. See walking a section for examples and explanation.

• as_bool

  as_bool(key)

  Returns True if the key contains a string that represents True, or is the True object.

  Returns False if the key contains a string that represents False, or is the False object.

  Raises a ValueError if the key contains anything else.

  Strings that represent True are (not case sensitive):

  true, yes, on, 1
  

  Strings that represent False are:

  false, no, off, 0
  

• as_int

  as_int(key)

  This returns the value contained in the specified key as an integer.

  It raises a ValueError if the conversion can't be done.

• as_float

  as_float(key)

  This returns the value contained in the specified key as a float.

  It raises a ValueError if the conversion can't be done.

• as_list

  as_list(key)

  This returns the value contained in the specified key as a list.

  If it isn't a list it will be wrapped as a list so that you can guarantee the returned value will be a list.

• restore_default

  restore_default(key)

  Restore (and return) the 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.

• restore_defaults

  restore_defaults()

  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.

7.3   Walking a Section

walk(function, raise_errors=True,
     call_on_sections=False, **keywargs)

walk is a method of the Section object. This means it is also a method of ConfigObj.

It walks through every member and calls a function on the keyword and value. It walks recursively through subsections.

It returns a dictionary of all the computed values.

If the function raises an exception, the default is to propagate the error, and stop. If raise_errors=False then it sets the return value for that keyword to False instead, and continues. This is similar to the way validation works.

Your function receives the arguments (section, key). The current value is then section[key] [11]. Any unrecognised keyword arguments you pass to walk, are passed on to the function.

Normally walk just recurses into subsections. If you are transforming (or checking) names as well as values, then you want to be able to change the names of sections. In this case set call_on_sections to True. Now, on encountering a sub-section, first the function is called for the whole sub-section, and then it recurses into it's members. This means your function must be able to handle receiving dictionaries as well as strings and lists.

If you are using the return value from walk and call_on_sections, note that walk discards the return value when it calls your function.

7.4   Examples

You can use this for transforming all values in your ConfigObj. For example you might like the nested lists from ConfigObj 3. This was provided by the listquote module. You could switch off the parsing for list values (list_values=False) and use listquote to parse every value.

Another thing you might want to do is use the Python escape codes in your values. You might be used to using \n for line feed and \t for tab. Obviously we'd need to decode strings that come from the config file (using the escape codes). Before writing out we'll need to put the escape codes back in encode.

As an example we'll write a function to use with walk, that encodes or decodes values using the string-escape codec.

The function has to take each value and set the new value. As a bonus we'll create one function that will do decode or encode depending on a keyword argument.

We don't want to work with section names, we're only transforming values, so we can leave call_on_sections as False. This means the two datatypes we have to handle are strings and lists, we can ignore everything else. (We'll treat tuples as lists as well).

We're not using the return values, so it doesn't need to return anything, just change the values if appropriate.

def string_escape(section, key, encode=False):
    """
    A function to encode or decode using the 'string-escape' codec.
    To be passed to the walk method of a ConfigObj.
    By default it decodes.
    To encode, pass in the keyword argument ``encode=True``.
    """
    val = section[key]
    # is it a type we can work with
    # NOTE: for platforms where Python > 2.2
    # you can use basestring instead of (str, unicode)
    if not isinstance(val, (str, unicode, list, tuple)):
        # no !
        return
    elif isinstance(val, (str, unicode)):
        # it's a string !
        if not encode:
            section[key] = val.decode('string-escape')
        else:
            section[key] = val.encode('string-escape')
    else:
        # it must be a list or tuple!
        # we'll be lazy and create a new list
        newval = []
        # we'll check every member of the list
        for entry in val:
            if isinstance(entry, (str, unicode)):
                if not encode:
                    newval.append(entry.decode('string-escape'))
                else:
                   newval.append(entry.encode('string-escape'))
            else:
                newval.append(entry)
        # done !
        section[key] =  newval

# assume we have a ConfigObj called ``config``
#
# To decode
config.walk(string_escape)
#
# To encode.
# Because ``walk`` doesn't recognise the ``encode`` argument
# it passes it to our function.
config.walk(string_escape, encode=True)

Here's a simple example of using walk to transform names and values. One usecase of this would be to create a standard config file with placeholders for section and keynames. You can then use walk to create new config files and change values and member names :

# We use 'XXXX' as a placeholder
config = '''
XXXXkey1 = XXXXvalue1
XXXXkey2 = XXXXvalue2
XXXXkey3 = XXXXvalue3
[XXXXsection1]
XXXXkey1 = XXXXvalue1
XXXXkey2 = XXXXvalue2
XXXXkey3 = XXXXvalue3
[XXXXsection2]
XXXXkey1 = XXXXvalue1
XXXXkey2 = XXXXvalue2
XXXXkey3 = XXXXvalue3
    [[XXXXsection1]]
    XXXXkey1 = XXXXvalue1
    XXXXkey2 = XXXXvalue2
    XXXXkey3 = XXXXvalue3
'''.splitlines()
cfg = ConfigObj(config)
#
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)
print cfg
ConfigObj({'CLIENT1key1': 'CLIENT1value1', 'CLIENT1key2': 'CLIENT1value2',
'CLIENT1key3': 'CLIENT1value3',
'CLIENT1section1': {'CLIENT1key1': 'CLIENT1value1',
    'CLIENT1key2': 'CLIENT1value2', 'CLIENT1key3': 'CLIENT1value3'},
'CLIENT1section2': {'CLIENT1key1': 'CLIENT1value1',
    'CLIENT1key2': 'CLIENT1value2', 'CLIENT1key3': 'CLIENT1value3',
    'CLIENT1section1': {'CLIENT1key1': 'CLIENT1value1',
        'CLIENT1key2': 'CLIENT1value2', 'CLIENT1key3': 'CLIENT1value3'}}})

9.1   configspec

The validate method checks members against an entry in the configspec. Your configspec therefore resembles your config file, with a check for every member.

In order to perform validation you need a Validator object. This has several useful built-in check functions. You can also create your own custom functions and register them with your Validator object.

Each check is the name of one of these functions, including any parameters and keyword arguments. The configspecs look like function calls, and they map to function calls.

The basic datatypes that an un-extended Validator can test for are :

• boolean values (True and False)
• integers (including minimum and maximum values)
• floats (including min and max)
• strings (including min and max length)
• IP addresses (v4 only)

It can also handle lists of these types and restrict a value to being one from a set of options.

An example configspec is going to look something like:

port = integer(0, 100)
user = string(max=25)
mode = option('quiet', 'loud', 'silent')

You can specify default values, and also have the same configspec applied to several sections. This is called repeated sections.

For full details on writing configspecs, please refer to the validate.py documentation.

from configobj import ConfigObj

configspec = ConfigObj(spec_filename, interpolation=False, list_values=False,
                       _inspec=True)
conf = ConfigObj(config_filename, configspec=configspec)

If you need to specify the encoding of your configspec, then you can pass in a ConfigObj instance as your configspec. When you read your configspec file, you must specify list_values=False. If you need to support hashes in configspec values then you must also pass in _inspec=True.

from configobj import ConfigObj
configspec = ConfigObj(configspecfilename, encoding='UTF8',
                       list_values=False, _inspec=True)
config = ConfigObj(filename, configspec=configspec)

9.2   Type Conversion

By default, validation does type conversion. This means that if you specify integer as the check, then calling validate will actually change the value to an integer (so long as the check succeeds).

It also means that when you call the write method, the value will be converted back into a string using the str function.

To switch this off, and leave values as strings after validation, you need to set the stringify attribute to False. If this is the case, attempting to set a value to a non-string will raise an error.

9.3   Default Values

You can set a default value in your check. If the value is missing from the config file then this value will be used instead. This means that your user only has to supply values that differ from the defaults.

If you don't supply a default then for a value to be missing is an error, and this will show in the return value from validate.

Additionally you can set the default to be None. This means the value will be set to None (the object) whichever check is used. (It will be set to '' rather than None if stringify is False). You can use this to easily implement optional values in your config files.

port = integer(0, 100, default=80)
user = string(max=25, default=0)
mode = option('quiet', 'loud', 'silent', default='loud')
nick = string(default=None)

checkname(default=list('val1', 'val2', 'val3'))

9.4   Repeated Sections

Repeated sections are a way of specifying a configspec for a section that should be applied to all unspecified subsections in the same section.

The easiest way of explaining this is to give an example. Suppose you have a config file that describes a dog. That dog has various attributes, but it can also have many fleas. You don't know in advance how many fleas there will be, or what they will be called, but you want each flea validated against the same configspec.

We can define a section called fleas. We want every flea in that section (every sub-section) to have the same configspec applied to it. We do this by defining a single section called __many__.

[dog]
name = string(default=Rover)
age = float(0, 99, default=0)

    [[fleas]]

        [[[__many__]]]
        bloodsucker = boolean(default=True)
        children = integer(default=10000)
        size = option(small, tiny, micro, default=tiny)

Every flea on our dog will now be validated using the __many__ configspec.

__many__ sections can have sub-sections, including their own __many__ sub-sections. Defaults work in the normal way in repeated sections.

9.5   Repeated Values

As well as using __many__ to validate unspecified sections you can use it to validate values. For example, to specify that all values in a section should be integers:

[section]
    __many__ = integer

If you want to use repeated values alongside repeated sections you can call one __many__ and the other ___many___ (with three underscores).

9.6   Copy Mode

Because you can specify default values in your configspec, you can use ConfigObj to write out default config files for your application.

However, normally values supplied from a default in a configspec are not written out by the write method.

To do this, you need to specify copy=True when you call validate. As well as not marking values as default, all the comments in the configspec file will be copied into your ConfigObj instance.

from configobj import ConfigObj
from validate import Validator
vdt = Validator()
config = ConfigObj(configspec='default.ini')
config.filename = 'new_default.ini'
config.validate(vdt, copy=True)
config.write()

If you need to support hashes in the configspec values then you must create it with _inspec=True. This has the side effect of switching off the parsing of inline comments, meaning that they won't be copied into the new config file. (ConfigObj syntax is slightly different from configspec syntax and the parser can't support both inline comments and hashes in configspec values.)

9.7   Validation and Interpolation

String interpolation and validation don't play well together. When validation changes type it sets the value. If the value uses interpolation, then the interpolation reference would normally be overwritten. Calling write would then use the absolute value and the interpolation reference would be lost.

As a compromise - if the value is unchanged by validation then it is not reset. This means strings that pass through validation unmodified will not be overwritten. If validation changes type - the value has to be overwritten, and any interpolation references are lost.

9.8   Extra Values

After validation the extra_values member of every section that is listed in the configspec will be populated with the names of members that are in the config file but not in the configspec.

If you are reporting configuration errors to your user this information can be useful, for example some missing entries may be due to misspelt entries that appear as extra values.

See the get_extra_values function

New in ConfigObj 4.7.0.

9.9   SimpleVal

You may not need a full validation process, but still want to check if all the expected values are present.

Provided as part of the ConfigObj module is the SimpleVal object. This has a dummy test method that always passes.

The only reason a test will fail is if the value is missing. The return value from validate will either be True, meaning all present, or a dictionary with False for all missing values/sections.

To use it, you still need to pass in a valid configspec when you create the ConfigObj, but just set all the values to ''. Then create an instance of SimpleVal and pass it to the validate method.

As a trivial example if you had the following config file:

# config file for an application
port = 80
protocol = http
domain = voidspace
top_level_domain = org.uk

You would write the following configspec:

port = ''
protocol = ''
domain = ''
top_level_domain = ''

config = Configobj(filename, configspec=configspec)
val = SimpleVal()
test = config.validate(val)
if test == True:
    print 'All values present.'
elif test == False:
    print 'No values present!'
else:
    for entry in test:
        if test[entry] == False:
            print '"%s" missing.' % entry

14.1   Example Usage

The output from flatten_errors is a list of tuples.

Here is an example of how you could present this information to the user.

vtor = validate.Validator()
# ini is your config file - cs is the configspec
cfg = ConfigObj(ini, configspec=cs)
res = cfg.validate(vtor, preserve_errors=True)
for entry in flatten_errors(cfg, res):
    # each entry is a tuple
    section_list, key, error = entry
    if key is not None:
       section_list.append(key)
    else:
        section_list.append('[missing section]')
    section_string = ', '.join(section_list)
    if error == False:
        error = 'Missing value or section.'
    print section_string, ' = ', error

15.1   Example Usage

The output from get_extra_values is a list of tuples.

Here is an example of how you could present this information to the user.

vtor = validate.Validator()
# ini is your config file - cs is the configspec
cfg = ConfigObj(ini, configspec=cs)
cfg.validate(vtor, preserve_errors=True)

for sections, name in get_extra_values(cfg):

    # this code gets the extra values themselves
    the_section = cfg
    for section in sections:
        the_section = cfg[section]

    # the_value may be a section or a value
    the_value = the_section[name]

    section_or_value = 'value
    if isinstance(the_value, dict):
        # Sections are subclasses of dict
        section_or_value = 'section'

    section_string = ', '.join(sections) or "top level"
    print 'Extra entry in section: %s. Entry %r is a %s' % (section_string, name, section_or_value)

20.1   2010/02/06 - Version 4.7.1

• Fix bug in options deprecation warning added in 4.7.0

20.2   2010/01/09 - Version 4.7.0

• Minimum supported version of Python is now 2.3
• ~25% performance improvement thanks to Christian Heimes
• String interpolation now works in list value members
• After validation any additional entries not in the configspec are listed in the extra_values section member
• Addition of the get_extra_values function for finding all extra values in a validated ConfigObj instance
• Deprecated the use of the options dictionary in the ConfigObj constructor and added explicit keyword arguments instead. Use **options if you want to initialise a ConfigObj instance from a dictionary
• Constructing a ConfigObj from an existing ConfigObj instance now preserves the order of values and sections from the original instance in the new one
• BUGFIX: Checks that failed validation would not populate default_values and restore_default_value() wouldn't work for those entries
• BUGFIX: clear() now clears 'defaults'
• BUGFIX: empty values in list values were accidentally valid syntax. They now raise a ParseError. e.g. "value = 1, , 2"
• BUGFIX: Change to the result of a call to validate when preserve_errors is True. Previously sections where all values failed validation would return False for the section rather than preserving the errors. False will now only be returned for a section if it is missing
• Distribution includes version 1.0.1 of validate.py
• Removed __revision__ and __docformat__

20.3   2009/04/13 - Version 4.6.0

• Pickling of ConfigObj instances now supported (thanks to Christian Heimes)
• Hashes in confgspecs are now allowed (see note below)
• Replaced use of hasattr (which can swallow exceptions) with getattr
• __many__ in configspecs can refer to scalars (ordinary values) as well as sections
• You can use ___many___ (three underscores!) where you want to use __many__ as well
• You can now have normal sections inside configspec sections that use __many__
• You can now create an empty ConfigObj with a configspec, programmatically set values and then validate
• A section that was supplied as a value (or vice-versa) in the actual config file would cause an exception during validation (the config file is still broken of course, but it is now handled gracefully)
• Added as_list method
• Removed the deprecated istrue, encode and decode methods
• Running test_configobj.py now also runs the doctests in the configobj module

As a consequence of the changes to configspec handling, when you create a ConfigObj instance and provide a configspec, the configspec attribute is only set on the ConfigObj instance - it isn't set on the sections until you validate. You also can't set the configspec attribute to be a dictionary. This wasn't documented but did work previously.

In order to fix the problem with hashes in configspecs I had to turn off the parsing of inline comments in configspecs. This will only affect you if you are using copy=True when validating and expecting inline comments to be copied from the configspec into the ConfigObj instance (all other comments will be copied as usual).

If you create the configspec by passing in a ConfigObj instance (usual way is to pass in a filename or list of lines) then you should pass in _inspec=True to the constructor to allow hashes in values. This is the magic that switches off inline comment parsing.

20.4   2008/06/27 - Version 4.5.3

BUGFIX: fixed a problem with copy=True when validating with configspecs that use __many__ sections.

20.5   2008/02/05 - Version 4.5.2

Distribution updated to include version 0.3.2 of validate. This means that None as a default value in configspecs works.

20.6   2008/02/05 - Version 4.5.1

Distribution updated to include version 0.3.1 of validate. This means that Unicode configspecs now work.

20.7   2008/02/05 - Version 4.5.0

ConfigObj will now guarantee that files will be written terminated with a newline.

ConfigObj will no longer attempt to import the validate module, until/unless you call ConfigObj.validate with preserve_errors=True. This makes it faster to import.

New methods restore_default and restore_defaults. restore_default resets an entry to its default value (and returns that value). restore_defaults resets all entries to their default value. It doesn't modify entries without a default value. You must have validated a ConfigObj (which populates the default_values dictionary) before calling these methods.

BUGFIX: Proper quoting of keys, values and list values that contain hashes (when writing). When list_values=False, values containing hashes are triple quoted.

Added the reload method. This reloads a ConfigObj from file. If the filename attribute is not set then a ReloadError (a new exception inheriting from IOError) is raised.

BUGFIX: Files are read in with 'rb' mode, so that native/non-native line endings work!

Minor efficiency improvement in unrepr mode.

Added missing docstrings for some overidden dictionary methods.

Added the reset method. This restores a ConfigObj to a freshly created state.

Removed old CHANGELOG file.

20.8   2007/02/04 - Version 4.4.0

Official release of 4.4.0

20.9   2006/12/17 - Version 4.3.3-alpha4

By Nicola Larosa

Allowed arbitrary indentation in the indent_type parameter, removed the NUM_INDENT_SPACES and MAX_INTERPOL_DEPTH (a leftover) constants, added indentation tests (including another docutils workaround, sigh), updated the documentation.

By Michael Foord

Made the import of compiler conditional so that ConfigObj can be used with IronPython.

20.10   2006/12/17 - Version 4.3.3-alpha3

By Nicola Larosa

Added a missing self. in the _handle_comment method and a related test, per Sourceforge bug #1523975.

20.11   2006/12/09 - Version 4.3.3-alpha2

By Nicola Larosa

Changed interpolation search strategy, based on this patch by Robin Munn: http://sourceforge.net/mailarchive/message.php?msg_id=17125993

20.12   2006/12/09 - Version 4.3.3-alpha1

By Nicola Larosa

Added Template-style interpolation, with tests, based on this patch by Robin Munn: http://sourceforge.net/mailarchive/message.php?msg_id=17125991 (awful archives, bad Sourceforge, bad).

20.13   2006/06/04 - Version 4.3.2

Changed error handling, if parsing finds a single error then that error will be re-raised. That error will still have an errors and a config attribute.

Fixed bug where '\n' terminated files could be truncated.

Bugfix in unrepr mode, it couldn't handle '#' in values. (Thanks to Philippe Normand for the report.)

As a consequence of this fix, ConfigObj doesn't now keep inline comments in unrepr mode. This is because the parser in the compiler package doesn't keep comments.

Error messages are now more useful. They tell you the number of parsing errors and the line number of the first error. (In the case of multiple errors.)

Line numbers in exceptions now start at 1, not 0.

Errors in unrepr mode are now handled the same way as in the normal mode. The errors stored will be an UnreprError.

20.14   2006/04/29 - Version 4.3.1

Added validate.py back into configobj.zip. (Thanks to Stewart Midwinter)

Updated to validate.py 0.2.2.

Preserve tuples when calling the dict method. (Thanks to Gustavo Niemeyer.)

Changed __repr__ to return a string that contains ConfigObj({ ... }).

Change so that an options dictionary isn't modified by passing it to ConfigObj. (Thanks to Artarious.)

Added ability to handle negative integers in unrepr. (Thanks to Kevin Dangoor.)

20.15   2006/03/24 - Version 4.3.0

Moved the tests and the CHANGELOG (etc) into a separate file. This has reduced the size of configobj.py by about 40%.

Added the unrepr mode to reading and writing config files. Thanks to Kevin Dangoor for this suggestion.

Empty values are now valid syntax. They are read as an empty string ''. (key =, or key = # comment.)

validate now honours the order of the configspec.

Added the copy mode to validate. Thanks to Louis Cordier for this suggestion.

Fixed bug where files written on windows could be given '\r\r\n' line terminators.

Fixed bug where last occurring comment line could be interpreted as the final comment if the last line isn't terminated.

Fixed bug where nested list values would be flattened when write is called. Now sub-lists have a string representation written instead.

Deprecated encode and decode methods instead.

You can now pass in a ConfigObj instance as a configspec (remember to read the configspec file using list_values=False).

Sorted footnotes in the docs.

20.16   2006/02/16 - Version 4.2.0

Removed BOM_UTF8 from __all__.

The BOM attribute has become a boolean. (Defaults to False.) It is only True for the UTF16/UTF8 encodings.

File like objects no longer need a seek attribute.

Full unicode support added. New options/attributes encoding, default_encoding.

ConfigObj no longer keeps a reference to file like objects. Instead the write method takes a file like object as an optional argument. (Which will be used in preference of the filename attribute if that exists as well.)

utf16 files decoded to unicode.

If BOM is True, but no encoding specified, then the utf8 BOM is written out at the start of the file. (It will normally only be True if the utf8 BOM was found when the file was read.)

Thanks to Aaron Bentley for help and testing on the unicode issues.

File paths are not converted to absolute paths, relative paths will remain relative as the filename attribute.

Fixed bug where final_comment wasn't returned if write is returning a list of lines.

Deprecated istrue, replaced it with as_bool.

Added as_int and as_float.

20.17   2005/12/14 - Version 4.1.0

Added merge, a recursive update.

Added preserve_errors to validate and the flatten_errors example function.

Thanks to Matthew Brett for suggestions and helping me iron out bugs.

Fixed bug where a config file is all comment, the comment will now be initial_comment rather than final_comment.

Validation no longer done on the 'DEFAULT' section (only in the root level). This allows interpolation in configspecs.

Also use the new list syntax in validate 0.2.1. (For configspecs).

20.18   2005/12/02 - Version 4.0.2

Fixed bug in create_empty. Thanks to Paul Jimenez for the report.

20.19   2005/11/05 - Version 4.0.1

Fixed bug in Section.walk when transforming names as well as values.

Added the istrue method. (Fetches the boolean equivalent of a string value).

Fixed list_values=False - they are now only quoted/unquoted if they are multiline values.

List values are written as item, item rather than item,item.

20.20   2005/10/17 - Version 4.0.0

ConfigObj 4.0.0 Final

Fixed bug in setdefault. When creating a new section with setdefault the reference returned would be to the dictionary passed in not to the new section. Bug fixed and behaviour documented.

Obscure typo/bug fixed in write. Wouldn't have affected anyone though.

20.21   2005/09/09 - Version 4.0.0 beta 5

Removed PositionError.

Allowed quotes around keys as documented.

Fixed bug with commas in comments. (matched as a list value)

20.22   2005/09/07 - Version 4.0.0 beta 4

Fixed bug in __delitem__. Deleting an item no longer deletes the inline_comments attribute.

Fixed bug in initialising ConfigObj from a ConfigObj.

Changed the mailing list address.

20.23   2005/08/28 - Version 4.0.0 beta 3

Interpolation is switched off before writing out files.

Fixed bug in handling StringIO instances. (Thanks to report from Gustavo Niemeyer.)

Moved the doctests from the __init__ method to a separate function. (For the sake of IDE calltips).

20.24   2005/08/25 - Version 4.0.0 beta 2

Amendments to validate.py.

First public release.

20.25   2005/08/21 - Version 4.0.0 beta 1

Reads nested subsections to any depth.

Multiline values.

Simplified options and methods.

New list syntax.

Faster, smaller, and better parser.

Validation greatly improved. Includes:

• type conversion
• default values
• repeated sections

Improved error handling.

Plus lots of other improvements.

20.26   2004/05/24 - Version 3.0.0

Several incompatible changes: another major overhaul and change. (Lots of improvements though).

Added support for standard config files with sections. This has an entirely new interface: each section is a dictionary of values.

Changed the update method to be called writein: update clashes with a dict method.

Made various attributes keyword arguments, added several.

Configspecs and orderlists have changed a great deal.

Removed support for adding dictionaries: use update instead.

Now subclasses a new class called caselessDict. This should add various dictionary methods that could have caused errors before.

It also preserves the original casing of keywords when writing them back out.

Comments are also saved using a caselessDict.

Using a non-string key will now raise a TypeError rather than converting the key.

Added an exceptions keyword for much better handling of errors.

Made creatempty=False the default.

Now checks indict and any keyword args. Keyword args take precedence over indict.

' ', ':', '=', ',' and '\t' are now all valid dividers where the keyword is unquoted.

ConfigObj now does no type checking against configspec when you set items.

delete and add methods removed (they were unnecessary).

Docs rewritten to include all this gumph and more; actually ConfigObj is really easy to use.

Support for stdout was removed.

A few new methods added.

Charmap is now incorporated into ConfigObj.

20.27   2004/03/14 - Version 2.0.0 beta

Re-written it to subclass dict. My first forays into inheritance and operator overloading.

The config object now behaves like a dictionary.

I've completely broken the interface, but I don't think anyone was really using it anyway.

This new version is much more 'classy'.

It will also read straight from/to a filename and completely parse a config file without you having to supply a config spec.

Uses listparse, so can handle nested list items as values.

No longer has getval and setval methods: use normal dictionary methods, or add and delete.

20.28   2004/01/29 - Version 1.0.5

Version 1.0.5 has a couple of bugfixes as well as a couple of useful additions over previous versions.

Since 1.0.0 the buildconfig function has been moved into this distribution, and the methods reset, verify, getval and setval have been added.

A couple of bugs have been fixed.

20.29   Origins

ConfigObj originated in a set of functions for reading config files in the atlantibots project. The original functions were written by Rob McNeur.