Conf

Complexity

Total Complexity

21

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__str__()	0	5	1
A	defaults()	0	12	4
B	get()	0	28	6
A	set_conf()	0	16	4
A	__repr__()	0	5	1
B	__init__()	0	18	5

# -*- coding: utf-8 -*-
"""Simple configuration file helpers for small configurations in yaml.

.. moduleauthor:: Kenny Freeman <kenny.freeman@gmail.com>

"""
__author__ = 'Kenny Freeman'
__email__ = 'kenny.freeman@gmail.com'
__license__     = "ISCL"
__docformat__   = 'reStructuredText'

import fnmatch
import os.path

import yaml # pip install pyaml

import plumd


def find(dname, ext):
    """Helper to yield a recursive list of the yaml files in a directory.

    :param dname: Path to list files in
    :type name: str
    :param ext: File extension to search for
    :type name: str
    :rtype: list -- a list of of the filenames found or []
    """
    if os.path.isdir(dname):
        try:
            for rdir, sdirs, fnames in os.walk(dname, topdown=True,
                                               onerror=None, followlinks=False):
                for fname in fnmatch.filter(fnames, "*.{0}".format(ext)):
                    yield os.path.join(rdir, fname)
        except AttributeError as e:
            raise plumd.ConfigError("Invalid path: {0} : {1}".format(dname, e))
        except OSError as e:
            raise plumd.ConfigError("OSError: {0} : {1}".format(dname, e))
    else:
        yield None


class Conf(object):
    """Simple key/value configuration helper class for small yaml files.

    :param cfile: Full path to the configuration file to load
    :type name: str
    :raises: ConfigError: if the specified file does not exist
    """

    def __init__(self, cfile):
        """conf constructor.

        :param cfile: Full path to the configuration file to load
        :type name: str
        :rtype: conf -- an instance of conf
        :raises: ConfigError: if the specified file does not exist
        """
        self.conf = {}
        self.path = cfile
        if (not cfile) or (not os.path.isfile(cfile)):
            raise plumd.ConfigError("file {0} does not exist".format(cfile))
        with open(cfile) as fd:
            try:
                self.conf = yaml.safe_load(fd)
            except yaml.scanner.ScannerError as e:
                msg = "invalid: {0} : {1}".format(cfile, e)
                raise plumd.ConfigError(msg)


    def __str__(self):
        """Return a nicely formatted string of our config.
        :rtype: str
        """
        return yaml.dump(self.conf,allow_unicode=False,default_flow_style=False)


    def __repr__(self):
        """Return a nicely formatted string of our config.
        :rtype: str
        """
        return yaml.dump(self.conf,allow_unicode=True,default_flow_style=False)


    def get(self, name, exception=False, default=None, rtype=None):
        """Returns the requested value, the provided default or None.

        raises:
            ConfigError if exception=True and the requested key is not found.

        :param name: The configuration value to lookup and return
        :type name: str
        :param exception: If True raise a ConfigError if the vlaue is not present
        :type exception: bool
        :param default: The default value to return if value is not found
        :rtype: value -- the configured value for the requested name or default
        :raises: ConfigError
        """
        val = default
        if name in self.conf and self.conf[name] is not None:
            val = self.conf[name]
        elif exception:
            msg = "missing {0} in: {1}".format(name, self.path)
            raise plumd.ConfigError(msg)
        if rtype:
            try:
                val = rtype(val)
            except (ValueError, TypeError) as e:
                msg = "{0} from file: {1} is not a(n) {2}, exception: {3}"
                rname = rtype.__name__
                raise plumd.ConfigError(msg.format(name, self.path, rname, e))
        return val


    def set_conf(self, name, val, overwrite=False):
        """Sets the named configuration to the provided value.

        If overwrite is False and the value exists it will be left unchanged.

        :param name: The configuration key to set
        :type name: str
        :param val: The configuration key is set to this value
        :rtype: self -- this object - allows chaining calls
        """
        name = name.strip()
        if name in self.conf and overwrite:
            self.conf[name] = val
        elif name not in self.conf:
            self.conf[name] = val
        return self


    def defaults(self, defconf):
        """Updates any missing configurations with values from defconf.

        :param defconf: dict of default values to set
        :type defconf: dict
        :rtype: self -- this object - allows chaining calls
        """
        for key, val in defconf.items():
            key = key.strip()
            if key not in self.conf or self.conf[key] is None:
                self.conf[key] = val
        return self