Subversion Repositories radiohdl

###############################################################################

#

# Copyright (C) 2014-2018

# ASTRON (Netherlands Institute for Radio Astronomy) <http://www.astron.nl/>

# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

#

# $Id$

#

###############################################################################

"""Class for accessing the values of a configuration file of RadioHDL.

   The contents of the configuration file consist of a series of key - value

   pairs. These key - value pairs are read from the file and kept in a

   single dictionary of keys and values that can be accessed via .content.

   The format of the configuration file is similar to that of an ini file. For ini

   files Python has the ConfigParser package, but that is not used here because

   we need other parsing rules than the ones implemented in ConfigParser.

   The parsing is done during the allocation of the class.

   Like an ini file the configurationfile can contain one or more sections. The

   first section is common, has no header and always included. The specific

   sections have a header that is marked by [section header]. The square brackets

   '[' and ']' are used to identify the section header. If the 'section header' is

   included in the argument 'sections' of the constructor then the keys of that

   section will be included in the dictionary.

     'sections' = None  --> ignore fileSections to include all sections in

                            the dict.

     'sections' = []    --> empty list to include only the common first

                            section in the dict.

     'sections' = ['section header' ...] -->

                            dedicated list of one or more section header

                            strings to include these specific sections,

                            and also the common first section, in the

                            dict.

   The key and value string in the dictionary file are separated by '='. Hence

   the '=' character can not be used in keys. The '=' can be used in values,

   because subsequent '=' on the same line are part of the value.

   Each key must start on a new line and may not contain whitespace.

   The value string can extend over one or multiple lines.

   Comment in line is supported by preceding it with a '#'. The '#' and the

   text after it on the line are stripped. The remainder of the line before

   the '#' is still interpreted.

   Example:

     # This is a comment section

     # a key starts on a new line and extends until the '='

     # a key and its values are separated by '='

     key=string   # this is a comment and the key is still interpreted

     key=string

     key =string

     key = string

     # a key with multiple values in its string

     key = value value value

     # how the values are separated depends on the dictionary user

     key = value, value, value

     key = value value

     # a key with many values can have its string extend on multiple lines,

     # the newline is replaced by a ' ' and any indent is removed

     key =

     value

     value

     value

     # empty lines and spaces are allowed

     key = value

"""

import os.path

import re

from collections import OrderedDict

__all__ = ['CFG_COMMENT_CHAR', 'CFG_ASSIGNMENT_CHAR', 'ConfigFileException', 'ConfigFile']

CFG_COMMENT_CHAR    = '#'

CFG_ASSIGNMENT_CHAR = '='

class ConfigFileException(Exception):

    "Exception class used in the ConfigFile class"

    pass

class ConfigFile(object):

    """

    :filename      The full filename of the configfile. May contain environment variables.

    :sections      Optional. May contain a list of sections names. The key-value pairs in the other sections

                   are ignored.

    :required_keys Optional. May contain a list of all keys that must exist in the configfile. If one or more

                   of those keys is missing in the configfile an exception is raised.

    """

    _CONFIGFILE_ATTRIBUTES = ['_own_attr_', 'filename', 'location', 'sections', 'required_keys',

                              '__content__', 'section_headers', 'unresolved_refs', 'warnings']

    def __init__(self, filename, sections=None, required_keys=[]):

        """

        Store the dictionaries from all fileName files in rootDir.

        :raise ConfigFileException

        """

        full_filename = os.path.expanduser(os.path.expandvars(filename))

        if not os.path.isfile(full_filename):

            raise ConfigFileException("configfile '%s' not found" % full_filename)

        # Crucial: define dict for storing our (simulated) attributes

        self.__dict__['_own_attr_'] = {}

        self.__content__     = OrderedDict()

        self.filename        = os.path.basename(full_filename)

        self.location        = os.path.dirname(full_filename)

        self.sections        = sections

        self.required_keys   = required_keys

        self.section_headers = []

        self.unresolved_refs = []

        self.warnings        = ''

        # Try to read the configuration file.

        self._read_file()

        # Check if all required keys are available

        for required_key in self.required_keys:

            if required_key not in self.__content__:

                raise ConfigFileException("configfile '%s' missing key '%s'" % (filename, required_key))

    def __getattr__(self, name):

        """

        Catch read-access to attributes to fetch values from the content dictionary.

        :raise AtttributeError

        """

        if name in self._CONFIGFILE_ATTRIBUTES:

            return self.__dict__['_own_attr_'][name]

        if name in self.__dict__['_own_attr_']['__content__']:

            return self.__dict__['_own_attr_']['__content__'][name]

        print('%s object has no attribute %s' % (str(self.__class__.__name__), str(name)))

        if not hasattr(self, name):

            raise AttributeError("%r object has no attribute %r" % (self.__class__.__name__, name))

        return getattr(self, name)

    def __setattr__(self, name, value):

        """

        Catch write-access to attributes to store values in the content dictionary.

        :raise AtttributeError

        """

        if name in self._CONFIGFILE_ATTRIBUTES:

            self.__dict__['_own_attr_'][name] = value

        elif name in self.__dict__['_own_attr_']['__content__']:

            self.__dict__['_own_attr_']['__content__'][name] = value

        else:

            if not hasattr(self, name):

                raise AttributeError("%r object has no attribute %r" % (self.__class__.__name__, name))

            setattr(self, name, value)

    def __getitem__(self, key):

        "Also allow access to the information as item."

        return self.__getattr__(key)

    def __setitem__(self, key, value):

        "Also allow access to the information as item."

        self.__setattr__(key, value)

    def _add_kv_pair(self, key, value, include_in_section):

        """

        Internal function for adding a key-value pair in a neat way.

        """

        # print("add_kv_pair: key={}, value={}\n".format(key, value))

        if not include_in_section:

            return

        if key.find(' ') > 0:

            self.warnings += "Error: Key may not contain spaces: file '{}/{}', key '{}'"\

                             .format(self.location, self.filename, key)

        elif key != '':

            self.__content__[key] = value.strip()       # Update dict with key and value

    def _read_file(self):

        """

        Read the dictionary information the filePathName file.

        The dictionary will contain all key-value pairs as well as a

        'section_headers' key that contains all the sections found in the file

        (regardless if the keys of that section where included in the dict or not).

        :raise ConfigFileException

        """

        include_section = True      # default include all sections

        key             = ''

        value           = ''

        linenr          = 0

        with open("{}/{}".format(self.location, self.filename), 'r') as configfile:

            for line in configfile:

                linenr += 1

                ln = line.split(CFG_COMMENT_CHAR, 1)[0]           # Strip comment from line

                if len(ln) == 0:

                    continue

                section_begin = ln.find('[')                       # Search for [section] header in this line

                section_end   = ln.find(']')

                # section MUST start at first character of the line

                if section_begin == 0 and section_end > 0:

                    self._add_kv_pair(key, value, include_section)  # complete action on current key

                    key = ''

                    value = ''

                    # administrate new section

                    section_header = ln[1:section_end].strip()    # new section header

                    self.section_headers.append(section_header)

                    include_section = True                        # default include this new section

                    if self.sections is not None:

                        if section_header not in self.sections:

                            include_section = False               # skip this section

                else:

                    key_end = ln.find(CFG_ASSIGNMENT_CHAR)        # Search for key in this line

                    if key_end > 0:

                        self._add_kv_pair(key, value, include_section)  # complete action on current key

                        key   = ln[0:key_end].strip()             # start with new key

                        value = ln[key_end+1:].strip()            # and new value

                    else:

                        # no assignment char found, append this line to the current value

                        value += ' '                              # replace newline by space to separate values

                        value += ln.strip()                       # append value

                        if value.strip() != '' and key == '':

                            self.warnings += "Warning: value without a key: file '{}/{}', line {} ({})"\

                                             .format(self.location, self.filename, linenr, value)

                            value = ''

                self._add_kv_pair(key, value, include_section)  # complete action on current key

        if self.warnings != '':

            raise ConfigFileException(self.warnings)

    @property

    def content(self):

        # print(self.__content__)

        "The content of the configfile as ordered dictionary."

        return self.__content__

    @property

    def ID(self):

        "Returns uniq ID (string) to identify this particular file. Fullfilename is used."

        return "{}/{}".format(self.location, self.filename)

    def resolve_key_references(self):

        """

        Replaces in all values the references to keys (<key>) with the value of that key.

        Note that this operation is irreversable.

        """

        ref_pattern = r"<(.+?)>"

        prog = re.compile(ref_pattern)

        # print('__content__={}'.format(self.__content__.items()))

        # loop over all items of the dict

        for key, value in list(self.__content__.items()):

            # any reference in the value?

            matchlist = list(set(prog.findall(value)))

            for reference in matchlist:

                if reference in list(self.__content__.keys()):

                    self.__content__[key] = re.sub("<{}>".format(reference), self.__content__[reference], value)

                    value = self.__content__[key]

                else:

                    self.unresolved_refs.append("<{}>".format(reference))

        return len(self.unresolved_refs) == 0

    def get_value(self, key, must_exist=False):

        """

        Get the value of a key. If the key does not exist and that is allowed 'None' is returned, in case the

        key should have been there an exception is raised.

        """

        if key in self.__content__:

            return self.__content__[key]

        if must_exist:

            raise ConfigFileException("Key '%s' does not exist in configfile %s/%s." % (key, self.location, self.filename))

        return None