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(defa