use yaml as storage instead of SafeConfigParser

weboob/config.py

@@ -20,74 +20,50 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 from __future__ import with_statement
 
-from ConfigParser import SafeConfigParser
+import yaml
 
-class Section:
+class ConfigError(Exception): pass
-    def __init__(self, name):
-        self.name = name
-        self.values = {}
-
-    def save(self, parser):
-        section_created = False
-        for key, value in self.values.iteritems():
-            if isinstance(value, Section):
-                value.save(parser)
-            else:
-                if not section_created:
-                    parser.add_section(self.name)
-                    section_created = True
-                parser.set(self.name, key, value)
 
 class Config:
     def __init__(self, path):
         self.path = path
-        self.sections = {}
+        self.values = {}
-
-    def get(self, *args):
-        s = None
-        path = ''
-        for a in args:
-            if path: path += '.'
-            path += a
-            if not s:
-                try:
-                    s = self.sections[a]
-                except KeyError:
-                    s = self.sections[a] = Section(path)
-            else:
-                try:
-                    s = s.values[a]
-                except KeyError:
-                    s = s.values[a] = Section(path)
-
-        return s
 
     def load(self):
-        parser = SafeConfigParser()
+        with open(self.path, 'r') as f:
-        parser.read(self.path)
+            self.values = yaml.load(f)
-        for section in parser.sections():
-            path = section.split('.')
-            s = None
-            name = ''
-            for part in path:
-                if name: name += '.'
-                name += part
 
-                if s:
+    def get(self, *args, **kwargs):
-                    d = s.values
+        create = False
+        if 'create' in kwargs:
+            create = kwargs['create']
+
+        v = self.values
+        for a in args:
+            try:
+                v = v[a]
+            except KeyError:
+                if create:
+                    v = v[a] = {}
                 else:
-                    d = self.sections
+                    raise ConfigError()
+            except TypeError:
+                raise ConfigError()
 
-                if not part in d:
+        return v
-                    d[part] = Section(name)
+
-                s = d[part]
+    def set(self, *args):
-            options = parser.options(section)
+        v = self.values
-            for o in options:
+        for a in args[:-2]:
-                s.values[o] = parser.get(section, o)
+            try:
+                v = v[a]
+            except KeyError:
+                v = v[a] = {}
+            except TypeError:
+                raise ConfigError()
+
+        v[args[-2]] = args[-1]
 
     def save(self):
-        parser = SafeConfigParser()
+        with open(self.path, 'w') as f:
-        for section in self.sections.itervalues():
+            yaml.dump(self.values, f)
-            section.save(parser)
-        with open(self.path, 'wb') as configfile:
-            parser.write(configfile)

weboob/ouiboube.py

@@ -34,16 +34,22 @@ class Weboob:
         self.modules_loader = ModulesLoader()
         self.modules_loader.load()
 
+    def getFrontendConfig(self):
+        return self.config.get('frontends', self.app_name, create=True)
+
+    def getBackendConfig(self, backend_name):
+        return self.config.get('backends', backend_name, create=True)
+
     def loadmodules(self, caps=None, name=None):
         for name, module in self.modules_loader.modules.iteritems():
             if (not caps or module.hasCaps(caps)) and \
                (not name or module.name == name):
-                backend = module.createBackend(self.config.get('backends', module.name))
+                backend = module.createBackend(self.getBackendConfig(module.name))
                 self.backends[module.name] = backend
 
     def loadmodule(self, modname, instname):
         module = self.modules_loader[modname]
-        self.backends[instname] = module.createBackend(self.config.get('backends', instname))
+        self.backends[instname] = module.createBackend(self.getBackendConfig(instname))
 
     def getBackends(self, caps=None):
         if caps is None: