2.1   Files

• configobj.py from Voidspace

  ConfigObj has no external dependencies. This file is sufficient to access all the functionality except Validation.

• configobj.zip from Voidspace

  This also contains validate.py and this document.

• The latest development version can be obtained from the Subversion Repository.

• validate.py from Voidspace

• You can also download configobj.zip from Sourceforge

2.2   Documentation

configobj.zip also contains this document.

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

2.3   Pythonutils

ConfigObj is also part of the Pythonutils set of modules. This contains various other useful modules, and is required by many of the Voidspace Python Projects.

2.4   Development Version

It is sometimes possible to get the latest development version of ConfigObj from the Subversion Repository.

4.1   Reading a Config File

The normal way to read a config file, is to give ConfigObj the 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.

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 :

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   infile

You don't need to specify an infile. If you omit it, an empty ConfigObj will be created. infile can be :

• Nothing. In which case the filename attribute of your ConfigObj will be None. You can set a filename at any time.
• A filename. What happens if the file doesn't already exist is determined by the options file_error and create_empty. The filename will be preserved as the filename attribute. This can be changed at any time.
• A list of lines. Any trailing newlines will be removed from the lines. The filename attribute of your ConfigObj will be None.
• A StringIO instance or file object, or any object with a read method. The filename attribute of your ConfigObj will be None [5].
• A dictionary. You can initialise a ConfigObj from a dictionary [6]. The filename attribute of your ConfigObj will be None. All keys must be strings. In this case, the order of values and sections is arbitrary.

5.2   options

There are various options that control the way ConfigObj behaves. They can be passed in as a dictionary of options, or as keyword arguments. Explicit keyword arguments override the dictionary.

All of the options are available as attributes after the config file has been parsed.

ConfigObj has the following options (with the default values shown) :

• 'raise_errors': False

  When parsing, it is possible that the config file will be badly formed. The default is to parse the whole file and raise a single error at the end. You can set raise_errors = True to have errors raised immediately. See the exceptions section for more details.

  Altering this value after initial parsing has no effect.

• 'list_values': True

  If True (the default) then list values are possible. If False, the values are not parsed for lists.

  If list_values = False then single line values are not quoted or unquoted when reading and writing.

  Changing this value affects whether single line values will be quoted or not when writing.

• 'create_empty': False

  If this value is True and the file specified by infile doesn't exist, ConfigObj will create an empty file. This can be a useful test that the filename makes sense: an impossible filename will cause an error.

  Altering this value after initial parsing has no effect.

• 'file_error': False

  If this value is True and the file specified by infile doesn't exist, ConfigObj will raise an IOError.

  Altering this value after initial parsing has no effect.

• 'interpolation': True

  Whether string interpolation is switched on or not. It is on (True) by default.

  You can set this attribute to change whether string interpolation is done when values are fetched. See the String Interpolation section for more details.

• 'configspec': None

  If you want to use the validation system, you supply a configspec. This is effectively a type of config file that specifies a check for each member. This check can be used to do type conversion as well as check that the value is within your required parameters.

  You provide a configspec in the same way as you do the initial file: a filename, or list of lines, etc. See the validation section for full details on how to use the system.

  When parsed, every section has a configspec with a dictionary of configspec checks for that section.

• 'stringify': True

  If you use the validation scheme, it can do type checking and conversion for you. This means you may want to set members to integers, or other non-string values.

  If 'stringify' is set to True (default) then non-string values will be converted to strings when you write the config file. The validation process converts values from strings to the required type.

  If 'stringify' is set to False, attempting to set a member to a non-string value [7] will raise a TypeError (no type conversion is done by validation).

• 'indent_type': '    '

  Indentation is not significant; it can however be present in the input and output config. Any combination of tabs and spaces may be used: the string will be repeated for each level of indentation. Typical values are: '' (no indentation), '    ' (indentation with four spaces, the default), '\t' (indentation with one tab).

  If this option is not specified, and the ConfigObj is initialised with a dictionary, the indentation used in the output is the default one, that is, four spaces.

  If this option is not specified, and the ConfigObj is initialised with a list of lines or a file, the indentation used in the first indented line is selected and used in all output lines. If no input line is indented, no output line will be either.

  If this option is specified, the option value is used in the output config, overriding the type of indentation in the input config (if any).

• 'encoding': None

  By default ConfigObj does not decode the file/strings you pass it into Unicode [8]. If you want your config file as Unicode (keys and members) you need to provide an encoding to decode the file with. This encoding will also be used to encode the config file when writing.

  You can change the encoding attribute at any time.

  Any characters in your strings that can't be encoded with the specified encoding will raise a UnicodeEncodeError.

  Note

  UTF16 encoded files will automatically be detected and decoded, even if encoding is None.

  This is because it is a 16-bit encoding, and ConfigObj will mangle it (split characters on byte boundaries) if it parses it without decoding.

• 'default_encoding': None

  When using the write method, ConfigObj uses the encoding attribute to encode the Unicode strings. If any members (or keys) have been set as byte strings instead of Unicode, these must first be decoded to Unicode before outputting in the specified encoding.

  default_encoding, if specified, is the encoding used to decode byte strings in the ConfigObj before writing. If this is None, then the Python default encoding (sys.defaultencoding - usually ASCII) is used.

  For most Western European users, a value of latin-1 is sensible.

  default_encoding is only used if an encoding is specified.

  Any characters in byte-strings that can't be decoded using the default_encoding will raise a UnicodeDecodeError.

• 'unrepr': False

  The unrepr option reads and writes files in a different mode. This allows you to store and retrieve the basic Python data-types using config files.

  This uses Python syntax for lists and quoting. See unrepr mode for the full details.

• 'write_empty_values': False

  If write_empty_values is True, empty strings are written as empty values. See Empty Values for more details.

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

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)

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

5.4   Attributes

A ConfigObj has the following attributes :

• indent_type
• interpolate
• 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.

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.

  It is mainly implemented for the encode and decode methods, which provide some Unicode support.

• 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.

• decode

  decode(encoding)

  This method decodes names and values into Unicode objects, using the supplied encoding.

• encode

  encode(encoding)

  This method is the opposite of decode .

  It encodes names and values using the supplied encoding. If any of your names/values are strings rather than Unicode, Python will have to do an implicit decode first. (This method uses sys.defaultencoding for implicit decodes.)

• 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
  

  Note

  In ConfigObj 4.1.0, this method was called istrue. That method is now deprecated and will issue a warning when used. It will go away in a future release.

• 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.

• 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 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

Examples that use the walk method are the encode and decode methods. They both define a function and pass it to walk. Because these functions transform names as well as values (from byte strings to Unicode) they set call_on_sections=True.

To see how they do it, read the source Luke .

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.

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 :

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.

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.

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 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.

If you define another sub-section in a section as well as a __many__ then you will get an error.

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

9.5   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.

9.6   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.7   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 = ''

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.

20.1   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 win configspecs works.

20.2   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.3   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.4   2007/02/04 - Version 4.4.0

Official release of 4.4.0

20.5   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.6   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.7   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.8   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.9   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.10   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.11   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.12   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.13   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.14   2005/12/02 - Version 4.0.2

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

20.15   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.16   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.17   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.18   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.19   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.20   2005/08/25 - Version 4.0.0 beta 2

Amendments to validate.py.

First public release.

20.21   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.22   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.23   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.24   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.25   Origins

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