From 2c78c40c9bfae22d1501022b2e52cf938b5a957e Mon Sep 17 00:00:00 2001
From: Frederic Lepied <flepied@mandriva.com>
Date: Wed, 7 Dec 2005 10:06:33 +0000
Subject: Initial revision

---
 RepSys/ConfigParser.py | 398 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 398 insertions(+)
 create mode 100644 RepSys/ConfigParser.py

(limited to 'RepSys/ConfigParser.py')

diff --git a/RepSys/ConfigParser.py b/RepSys/ConfigParser.py
new file mode 100644
index 0000000..0f219b9
--- /dev/null
+++ b/RepSys/ConfigParser.py
@@ -0,0 +1,398 @@
+"""
+This is a heavily hacked version of ConfigParser to keep the order in 
+which options and sections are read, and allow multiple options with
+the same key.
+"""
+from __future__ import generators
+import string, types
+import re
+
+__all__ = ["NoSectionError","DuplicateSectionError","NoOptionError",
+           "InterpolationError","InterpolationDepthError","ParsingError",
+           "MissingSectionHeaderError","ConfigParser",
+           "MAX_INTERPOLATION_DEPTH"]
+
+DEFAULTSECT = "DEFAULT"
+
+MAX_INTERPOLATION_DEPTH = 10
+
+# exception classes
+class Error(Exception):
+    def __init__(self, msg=''):
+        self._msg = msg
+        Exception.__init__(self, msg)
+    def __repr__(self):
+        return self._msg
+    __str__ = __repr__
+
+class NoSectionError(Error):
+    def __init__(self, section):
+        Error.__init__(self, 'No section: %s' % section)
+        self.section = section
+
+class DuplicateSectionError(Error):
+    def __init__(self, section):
+        Error.__init__(self, "Section %s already exists" % section)
+        self.section = section
+
+class NoOptionError(Error):
+    def __init__(self, option, section):
+        Error.__init__(self, "No option `%s' in section: %s" %
+                       (option, section))
+        self.option = option
+        self.section = section
+
+class InterpolationError(Error):
+    def __init__(self, reference, option, section, rawval):
+        Error.__init__(self,
+                       "Bad value substitution:\n"
+                       "\tsection: [%s]\n"
+                       "\toption : %s\n"
+                       "\tkey    : %s\n"
+                       "\trawval : %s\n"
+                       % (section, option, reference, rawval))
+        self.reference = reference
+        self.option = option
+        self.section = section
+
+class InterpolationDepthError(Error):
+    def __init__(self, option, section, rawval):
+        Error.__init__(self,
+                       "Value interpolation too deeply recursive:\n"
+                       "\tsection: [%s]\n"
+                       "\toption : %s\n"
+                       "\trawval : %s\n"
+                       % (section, option, rawval))
+        self.option = option
+        self.section = section
+
+class ParsingError(Error):
+    def __init__(self, filename):
+        Error.__init__(self, 'File contains parsing errors: %s' % filename)
+        self.filename = filename
+        self.errors = []
+
+    def append(self, lineno, line):
+        self.errors.append((lineno, line))
+        self._msg = self._msg + '\n\t[line %2d]: %s' % (lineno, line)
+
+class MissingSectionHeaderError(ParsingError):
+    def __init__(self, filename, lineno, line):
+        Error.__init__(
+            self,
+            'File contains no section headers.\nfile: %s, line: %d\n%s' %
+            (filename, lineno, line))
+        self.filename = filename
+        self.lineno = lineno
+        self.line = line
+
+class ConfigParser:
+    def __init__(self, defaults=None):
+        # Options are stored in __sections_list like this:
+        # [(sectname, [(optname, optval), ...]), ...]
+        self.__sections_list = []
+        self.__sections_dict = {}
+        if defaults is None:
+            self.__defaults = {}
+        else:
+            self.__defaults = defaults
+
+    def defaults(self):
+        return self.__defaults
+
+    def sections(self):
+        return self.__sections_dict.keys()
+
+    def has_section(self, section):
+        return self.__sections_dict.has_key(section)
+
+    def options(self, section):
+        self.__sections_dict[section]
+        try:
+            opts = self.__sections_dict[section].keys()
+        except KeyError:
+            raise NoSectionError(section)
+        return self.__defaults.keys()+opts
+
+    def read(self, filenames):
+        if type(filenames) in types.StringTypes:
+            filenames = [filenames]
+        for filename in filenames:
+            try:
+                fp = open(filename)
+            except IOError:
+                continue
+            self.__read(fp, filename)
+            fp.close()
+
+    def readfp(self, fp, filename=None):
+        if filename is None:
+            try:
+                filename = fp.name
+            except AttributeError:
+                filename = '<???>'
+        self.__read(fp, filename)
+
+    def set(self, section, option, value):
+        if self.__sections_dict.has_key(section):
+            sectdict = self.__sections_dict[section]
+            sectlist = []
+            self.__sections_list.append((section, sectlist))
+        elif section == DEFAULTSECT:
+            sectdict = self.__defaults
+            sectlist = None
+        else:
+            sectdict = {}
+            self.__sections_dict[section] = sectdict
+            sectlist = []
+            self.__sections_list.append((section, sectlist))
+        xform = self.optionxform(option)
+        sectdict[xform] = value
+        if sectlist is not None:
+            sectlist.append([xform, value])
+
+    def get(self, section, option, raw=0, vars=None):
+        d = self.__defaults.copy()
+        try:
+            d.update(self.__sections_dict[section])
+        except KeyError:
+            if section != DEFAULTSECT:
+                raise NoSectionError(section)
+        if vars:
+            d.update(vars)
+        option = self.optionxform(option)
+        try:
+            rawval = d[option]
+        except KeyError:
+            raise NoOptionError(option, section)
+        if raw:
+            return rawval
+        return self.__interpolate(rawval, d)
+
+    def getall(self, section, option, raw=0, vars=None):
+        option = self.optionxform(option)
+        values = []
+        d = self.__defaults.copy()
+        if section != DEFAULTSECT:
+            for sectname, options in self.__sections_list:
+                if sectname == section:
+                    for optname, value in options:
+                        if optname == option:
+                            values.append(value)
+                        d[optname] = value
+        if raw:
+            return values
+        if vars:
+            d.update(vars)
+        for i in len(values):
+            values[i] = self.__interpolate(values[i], d)
+        return values
+
+    def walk(self, section, option=None, raw=0, vars=None):
+        # Build dictionary for interpolation
+        try:
+            d = self.__sections_dict[section].copy()
+        except KeyError:
+            if section == DEFAULTSECT:
+                d = {}
+            else:
+                raise NoSectionError(section)
+        d.update(self.__defaults)
+        if vars:
+            d.update(vars)
+
+        # Start walking
+        if option:
+            option = self.optionxform(option)
+        if section != DEFAULTSECT:
+            for sectname, options in self.__sections_list:
+                if sectname == section:
+                    for optname, value in options:
+                        if not option or optname == option:
+                            if not raw:
+                                value = self.__interpolate(value, d)
+                            yield (optname, value)
+
+    def __interpolate(self, value, vars):
+        rawval = value
+        depth = 0
+        while depth < 10:
+            depth = depth + 1
+            if value.find("%(") >= 0:
+                try:
+                    value = value % vars
+                except KeyError, key:
+                    raise InterpolationError(key, option, section, rawval)
+            else:
+                break
+        if value.find("%(") >= 0:
+            raise InterpolationDepthError(option, section, rawval)
+        return value
+
+    def __get(self, section, conv, option):
+        return conv(self.get(section, option))
+
+    def getint(self, section, option):
+        return self.__get(section, string.atoi, option)
+
+    def getfloat(self, section, option):
+        return self.__get(section, string.atof, option)
+
+    def getboolean(self, section, option):
+        states = {'1': 1, 'yes': 1, 'true': 1, 'on': 1,
+                  '0': 0, 'no': 0, 'false': 0, 'off': 0}
+        v = self.get(section, option)
+        if not states.has_key(v.lower()):
+            raise ValueError, 'Not a boolean: %s' % v
+        return states[v.lower()]
+
+    def optionxform(self, optionstr):
+        #return optionstr.lower()
+        return optionstr
+
+    def has_option(self, section, option):
+        """Check for the existence of a given option in a given section."""
+        if not section or section == "DEFAULT":
+            return self.__defaults.has_key(option)
+        elif not self.has_section(section):
+            return 0
+        else:
+            option = self.optionxform(option)
+            return self.__sections_dict[section].has_key(option)
+
+    SECTCRE = re.compile(r'\[(?P<header>[^]]+)\]')
+    OPTCRE = re.compile(r'(?P<option>\S+)\s*(?P<vi>[:=])\s*(?P<value>.*)$')
+
+    def __read(self, fp, fpname):
+        cursectdict = None                            # None, or a dictionary
+        optname = None
+        lineno = 0
+        e = None                                  # None, or an exception
+        while 1:
+            line = fp.readline()
+            if not line:
+                break
+            lineno = lineno + 1
+            # comment or blank line?
+            if line.strip() == '' or line[0] in '#;':
+                continue
+            if line.split()[0].lower() == 'rem' \
+               and line[0] in "rR":      # no leading whitespace
+                continue
+            # continuation line?
+            if line[0] in ' \t' and cursectdict is not None and optname:
+                value = line.strip()
+                if value:
+                    k = self.optionxform(optname)
+                    cursectdict[k] = "%s\n%s" % (cursectdict[k], value)
+                    cursectlist[-1][1] = "%s\n%s" % (cursectlist[-1][1], value)
+            # a section header or option header?
+            else:
+                # is it a section header?
+                mo = self.SECTCRE.match(line)
+                if mo:
+                    sectname = mo.group('header')
+                    if self.__sections_dict.has_key(sectname):
+                        cursectdict = self.__sections_dict[sectname]
+                        cursectlist = []
+                        self.__sections_list.append((sectname, cursectlist))
+                    elif sectname == DEFAULTSECT:
+                        cursectdict = self.__defaults
+                        cursectlist = None
+                    else:
+                        cursectdict = {}
+                        self.__sections_dict[sectname] = cursectdict
+                        cursectlist = []
+                        self.__sections_list.append((sectname, cursectlist))
+                    # So sections can't start with a continuation line
+                    optname = None
+                # no section header in the file?
+                elif cursectdict is None:
+                    raise MissingSectionHeaderError(fpname, lineno, `line`)
+                # an option line?
+                else:
+                    mo = self.OPTCRE.match(line)
+                    if mo:
+                        optname, vi, optval = mo.group('option', 'vi', 'value')
+                        if vi in ('=', ':') and ';' in optval:
+                            # ';' is a comment delimiter only if it follows
+                            # a spacing character
+                            pos = optval.find(';')
+                            if pos and optval[pos-1] in string.whitespace:
+                                optval = optval[:pos]
+                        optval = optval.strip()
+                        # allow empty values
+                        if optval == '""':
+                            optval = ''
+                        xform = self.optionxform(optname)
+                        cursectdict[xform] = optval
+                        if cursectlist is not None:
+                            cursectlist.append([xform, optval])
+                    else:
+                        # a non-fatal parsing error occurred.  set up the
+                        # exception but keep going. the exception will be
+                        # raised at the end of the file and will contain a
+                        # list of all bogus lines
+                        if not e:
+                            e = ParsingError(fpname)
+                        e.append(lineno, `line`)
+        # if any parsing errors occurred, raise an exception
+        if e:
+            raise e
+
+# Here we wrap this hacked ConfigParser into something more useful
+# for us.
+
+import os
+
+class Config:
+    def __init__(self):
+        self._config = ConfigParser()
+        conffiles = []
+        conffiles.append("/etc/repsys.conf")
+        repsys_conf = os.environ.get("REPSYS_CONF")
+        if repsys_conf:
+            conffiles.append(repsys_conf)
+        conffiles.append(os.path.expanduser("~/.repsys/config"))
+        for file in conffiles:
+            if os.path.isfile(file):
+                self._config.read(file)
+
+    def sections(self):
+        try:
+            return self._config.sections()
+        except Error:
+            return []
+
+    def options(self, section):
+        try:
+            return self._config.options(section)
+        except Error:
+            return []
+
+    def set(self, section, option, value):
+        return self._config.set(section, option, value)
+    
+    def walk(self, section):
+        return self._config.walk(section)
+
+    def get(self, section, option, default=None):
+        try:
+            return self._config.get(section, option)
+        except Error:
+            return default
+    
+    def getint(self, section, option, default=None):
+        ret = self.get(section, option, default)
+        if type(ret) == type(""):
+            return int(ret)
+            
+    def getbool(self, section, option, default=None):
+        ret = self.get(section, option, default)
+        states = {'1': 1, 'yes': 1, 'true': 1, 'on': 1,
+                  '0': 0, 'no': 0, 'false': 0, 'off': 0}
+        if type(ret) == type("") and states.has_key(ret.lower()):
+            return states[ret.lower()]
+        return default
+
+# vim:ts=4:sw=4:et
-- 
cgit v1.2.1