I want to have a config file with my python proggie, satisfying the
following requirements:
1) support key->(value, default)
2) simple and intuitive to read and edit
3) easyly readable into a python datastructure (a dictionary?)
4) not requiring any heavy libraries needed (I am distributing my
proggie as a py2exe executable and do not want to bloat the size)
It's probably reinventing the wheel, but here's one I wrote a while
ago. It might serve as a starting point, if nothing else. The actual
code's quite short - it's all those pesky comments and unit tests
that take up all the room
It's also possible to have .py files imported (I forget how) from a
py2exe program, so you can also go down the python formatted config
file route.
Anthony
--
#!/usr/local/bin/python
# A stab at writing a config script
# We'll assume that # and ; are comment characters
# unless they're in quotes
# to run the unit tests, simply execute this script:
# config.py -v
import sys, os, string
import unittest
class config:
""" A class to store configuration values in a text file, and
read them out.
To use this class, simply declare it:
myconfig = config("config.txt")
it will automatically read in all of the values from config.txt,
and myconfig will then behave roughly like a dictionary:
myconfig['name'] # corresponds to name=... in config.txt
There are also the following functions:
myconfig.keys() # a list of all of the attributes
myconfig.delete('wibble') # delete attribute wibble
myconfig.readconfig() # read in the config file again
myconfig.writeconfig([filename]) # write the config file
# filename is optional
"""
def __init__(self, configfile):
"""Set up the class, and read in all of the values."""
self._info={}
self._file=configfile
if os.access(self._file, os.F_OK) == 1:
# we can read in the config file
self.readconfig()
# A couple of simple functions to make using the class easier
# ie. you can just say configclassinstance['blah']
def __getitem__(self, name):
return self._info[name]
def __setitem__(self, name, value):
self._info[name] = value
def keys(self):
"""return all of the config values."""
return self._info.keys()
def delete(self, item):
"""Delete a key from the config directory."""
if item not in self._info.keys():
raise IndexError, 'Item '+str(item)+' not found in the config.'
else:
del self._info[item]
def readconfig(self):
"""Read in the config file, line by line."""
# First, clear out the old config:
self._info = {}
# Now, open it and read in each line, calling _readconfigline
to parse it
file = open(self._file, 'r')
for line in file.readlines():
self._readconfigline(line)
file.close()
return
def _readconfigline(self,theline):
"""Given a line, parse it and put it into the self.info dictionary."""
theline = string.strip(theline)
if theline=='' or theline[0]=='#' or theline[0]==';':
return # this line is empty or a comment
attribute, value = string.split(theline, '=', 1)
attribute = string.strip(attribute)
value = string.strip(value)
if value[0] == '=':
raise ValueError, "Too many equal signs in "+theline
# First we check for quotes, just to be sure that
# there aren't any nested comment chars in them
value = string.strip(value)
if '"' in value:
if value[0]=='"' and string.count(value, '"') == 2:
value, ignored = string.split(value[1:], '"', 1)
else: # they're playing funny buggers, and gave us
# something like attr=blah"blah"
raise ValueError, "Quotes misplaced in "+theline
else: # no quotes - cut sick!
if '#' in value:
value, ignored = string.split(value, '#', 1)
value = string.strip(value)
if ';' in value:
value, ignored = string.split(value, ';', 1)
value = string.strip(value)
self._info[attribute] = value
def writeconfig(self, filename=""):
"""Write out all of the values in the config to a file."""
if filename=="":
filename = self._file
if os.access(self._file, os.F_OK) == 1:
# We might want to raise an error at this point...
raise IOError, "File "+self._file+" already exists!"
file = open(filename, 'w')
for item in self._info.keys():
file.write(item+'="'+self._info[item]+'"\n')
file.close()
class testItems(unittest.TestCase):
"""Test that config works correctly."""
configtest = config("testconfig.txt")
goodconfiglines = [ # line, attribute, value
['womble=blah', 'womble', 'blah'],
['womble2="blah2"', 'womble2', 'blah2'],
['blah2="wibble" #comment', 'blah2', 'wibble'],
['blah3="wibble2" ;comment', 'blah3', 'wibble2'],
['blah6="####" # A comment', 'blah6', '####'],
['blah7=";;;;" ; A comment', 'blah7', ';;;;'],
['blah10=quotes a go go! ; # # ; ; ##; ;#',
'blah10', 'quotes a go go!'],
['blah5 = "womble5"', 'blah5', 'womble5'],
['blah9=womble72 ; comment!', 'blah9', 'womble72'],
['blah11=" spaces should be preserved! "', 'blah11',
" spaces should be preserved! "],
["blah8=This won't break!", 'blah8', "This
won't break!"],
]
badconfiglines = [ # these config lines should throw a ValueError
'blah11="broken"quotes"',
'blah12="more"broken"quotes"',
'blah13=broken"quotes?"',
'strangequals=="blah"',
'strangeequals2="wibble"="blah"',
]
def testAddLines(self):
"""Test that lines can be added to the config object."""
# First, clear out self.testconfig:
for item in self.configtest.keys():
self.configtest.delete(item)
for item in self.goodconfiglines:
self.configtest._readconfigline(item[0])
self.assertEqual(item[2], self.configtest[item[1]])
def testDelete(self):
"""Test that delete works."""
# First, clear out self.testconfig:
for item in self.configtest.keys():
self.configtest.delete(item)
# Now add and delete
for item in self.goodconfiglines:
self.configtest[item[1]]=item[2]
self.failUnless(self.configtest[item[1]]==item[2])
self.configtest.delete(item[1])
self.failIf(item[2] in self.configtest.keys())
def testConfigKeys(self):
"""Test that items added appear in config.keys()."""
# First, clear out self.testconfig:
for item in self.configtest.keys():
self.configtest.delete(item)
self.failUnless(self.configtest.keys()==[])
# Now add and delete
for item in self.goodconfiglines:
self.configtest[item[1]]=item[2]
self.failUnless(item[1] in self.configtest.keys())
def testConfigLines(self):
"""Test that all of the types of config lines can be read
from a file."""
for item in self.goodconfiglines:
#write the line to a config file
file = open("testconfig.txt", "w")
file.write(item[0])
file.close()
# Now check that it can be read from the file
self.configtest.readconfig()
self.assertEqual(item[2], self.configtest[item[1]])
def testSanityCheck(self):
"""For each item in goodconfiglines, test that it can be
written to a file
and read back unchanged."""
# First, clear out self.testconfig:
for item in self.configtest.keys():
self.configtest.delete(item)
# Now test!
for item in self.goodconfiglines:
self.configtest[item[1]]=item[2]
os.unlink("testconfig.txt")
self.configtest.writeconfig("")
self.configtest.readconfig()
self.assertEqual(item[2],self.configtest[item[1]])
def testBadConfigLines(self):
"""Test that dodgy config lines will throw an exception."""
for item in self.badconfiglines:
self.assertRaises(ValueError,
self.configtest._readconfigline, theline=item)
if __name__ == "__main__":
unittest.main()
