Viewing file: simple_config.py (6.72 KB) -rw-r--r-- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
# -*- coding: utf-8 -*-
# Licensed under the MIT license # http://opensource.org/licenses/mit-license.php
# based on: http://code.activestate.com/recipes/573463/ # Modified by Philippe Normand
# Copyright 2008, Frank Scholz <coherence@beebits.net>
from coherence.extern.et import ET as ElementTree, indent, parse_xml
class ConfigItem(object): """ the base """
class Config(ConfigItem):
def __init__(self,filename,root=None,preamble=False): self.filename = filename self.db = parse_xml(open(self.filename).read()) self.config = self.db = ConvertXmlToDict(self.db.getroot()) self.preamble = '' if preamble == True: self.preamble = """<?xml version="1.0" encoding="utf-8"?>\n""" if root != None: try: self.config = self.config[root] except KeyError: pass self.config.save = self.save
def tostring(self): root = ConvertDictToXml(self.db) tree = ElementTree.ElementTree(root).getroot() indent(tree,0) xml = self.preamble + ElementTree.tostring(tree, encoding='utf-8') return xml
def save(self, new_filename=None): if new_filename != None: self.filename = new_filename xml = self.tostring() f = open(self.filename, 'wb') f.write(xml) f.close()
def get(self,key,default=None): print "get", key if key in self.config: item = self.config[key] try: if item['active'] == 'no': return default return item except (TypeError,KeyError): return item return default
def set(self,key,value): self.config[key] = value
class XmlDictObject(dict,ConfigItem): def __init__(self, initdict=None): if initdict is None: initdict = {} dict.__init__(self, initdict) self._attrs = {}
def __getattr__(self, item): value = self.__getitem__(item) try: if value['active'] == 'no': raise KeyError except (TypeError,KeyError): return value return value
def __setattr__(self, item, value): if item == '_attrs': object.__setattr__(self, item, value) else: self.__setitem__(item, value)
def get(self,key,default=None): try: item = self[key] try: if item['active'] == 'no': return default return item except (TypeError,KeyError): return item except KeyError: pass
return default
def set(self,key,value): self[key] = value
def __str__(self): if self.has_key('_text'): return self.__getitem__('_text') else: return ''
def __repr__(self): return repr(dict(self))
@staticmethod def Wrap(x): if isinstance(x, dict): return XmlDictObject((k, XmlDictObject.Wrap(v)) for (k, v) in x.iteritems()) elif isinstance(x, list): return [XmlDictObject.Wrap(v) for v in x] else: return x
@staticmethod def _UnWrap(x): if isinstance(x, dict): return dict((k, XmlDictObject._UnWrap(v)) for (k, v) in x.iteritems()) elif isinstance(x, list): return [XmlDictObject._UnWrap(v) for v in x] else: return x
def UnWrap(self): return XmlDictObject._UnWrap(self)
def _ConvertDictToXmlRecurse(parent, dictitem): assert type(dictitem) is not type([])
if isinstance(dictitem, dict): for (tag, child) in dictitem.iteritems(): if str(tag) == '_text': parent.text = str(child) ## elif str(tag) == '_attrs': ## for key, value in child.iteritems(): ## parent.set(key, value) elif type(child) is type([]): for listchild in child: elem = ElementTree.Element(tag) parent.append(elem) _ConvertDictToXmlRecurse(elem, listchild) else: if(not isinstance(dictitem, XmlDictObject) and not callable(dictitem)): attrs = dictitem dictitem = XmlDictObject() dictitem._attrs = attrs
if tag in dictitem._attrs: parent.set(tag, child) elif not callable(tag) and not callable(child): elem = ElementTree.Element(tag) parent.append(elem) _ConvertDictToXmlRecurse(elem, child) else: if not callable(dictitem): parent.text = str(dictitem)
def ConvertDictToXml(xmldict): roottag = xmldict.keys()[0] root = ElementTree.Element(roottag) _ConvertDictToXmlRecurse(root, xmldict[roottag]) return root
def _ConvertXmlToDictRecurse(node, dictclass): nodedict = dictclass() ## if node.items(): ## nodedict.update({'_attrs': dict(node.items())})
if len(node.items()) > 0: # if we have attributes, set them attrs = dict(node.items()) nodedict.update(attrs) nodedict._attrs = attrs
for child in node: # recursively add the element's children newitem = _ConvertXmlToDictRecurse(child, dictclass) if nodedict.has_key(child.tag): # found duplicate tag, force a list if type(nodedict[child.tag]) is type([]): # append to existing list nodedict[child.tag].append(newitem) else: # convert to list nodedict[child.tag] = [nodedict[child.tag], newitem] else: # only one, directly set the dictionary nodedict[child.tag] = newitem
if node.text is None: text = '' else: text = node.text.strip()
if len(nodedict) > 0: # if we have a dictionary add the text as a dictionary value (if there is any) if len(text) > 0: nodedict['_text'] = text else: # if we don't have child nodes or attributes, just set the text if node.text is not None: nodedict = node.text.strip()
return nodedict
def ConvertXmlToDict(root,dictclass=XmlDictObject): return dictclass({root.tag: _ConvertXmlToDictRecurse(root, dictclass)})
def main(): c = Config('config.xml',root='config') #print '%r' % c.config
#c.save(new_filename='config.new.xml') print c.config['interface']
#for plugin in c.config.pluginlist.plugin: # if plugin.active != 'no': # print '%r' % plugin
if __name__ == '__main__': main()
|