ConfigObject.delete_key() - Code Metrics - Inspection of "Merge pull request #161 from motom001/call_url-Act..." - motom001/DoorPi - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0dd74a...cac84e )

by Thomas

created 2016-05-23 18:27 UTC

ConfigObject.delete_key() A

↳ Parent: ConfigObject

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
dl	0
loc	10
rs	9.2
c	1
b	0
f	0

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import logging
logger = logging.getLogger(__name__)
logger.debug("%s loaded", __name__)

import os

import ConfigParser
import doorpi

from backward_compatibility import BACKWARD_COMPATIBILITY_KEYS

class ConfigObject():

    __sections = {}
    _config_file = None

    @property
    def all(self): return self.__sections

    @property
    def config_file(self): return self._config_file

    def __init__(self, config, config_file = None):
        logger.debug("__init__")
        self.get_from_config(config)
        self._config_file = config_file

    def __del__(self):
        return self.destroy()

    def destroy(self):
        logger.debug("__del__")
        #DoorPi().event_handler.unregister_source(__name__, True)
        return True

    @staticmethod
    def find_config(configfile = None):
        try:
            open(configfile.name, 'r').close()
            return configfile.name
        except AttributeError: pass
        except IOError: pass

        default_files = [
            str(configfile),
            doorpi.DoorPi().parse_string(str(configfile)),
            os.path.join('!BASEPATH!', 'conf', 'doorpi.ini'),
            os.path.join('!BASEPATH!', 'conf', 'doorpi.cfg')
        ]

        for possible_default_file in default_files:
            try:
                possible_default_file = doorpi.DoorPi().parse_string(possible_default_file)
                open(possible_default_file, 'r').close()
                return possible_default_file
            except: pass

        return None

    @staticmethod
    def load_config(configfile, search_for_defaults = True):
        config = ConfigParser.ConfigParser(allow_no_value = True)
        if search_for_defaults: configfile_name = ConfigObject.find_config(configfile)
        else: configfile_name = configfile

        if not configfile_name:
            logger.error('No valid configfile found - use parameter --configfile "filename" to specify one')
            return ConfigObject(config)

        logger.info("use configfile: %s", configfile_name)

        config.read(configfile_name)
        return ConfigObject(config, configfile_name)

    def save_config(self, configfile = ''):
        if not configfile: configfile = self.config_file
        if not configfile: configfile = self.find_config(configfile)
        if not configfile: configfile = doorpi.DoorPi().parse_string(os.path.join('!BASEPATH!', 'conf', 'doorpi.ini'))

        #if not configfile: return False
        logger.debug("write configfile: %s", configfile)
        try:
            if not os.path.exists(os.path.dirname(configfile)):
                logger.info('Path %s does not exist - creating it now', os.path.dirname(configfile))
                os.makedirs(os.path.dirname(configfile))
            cfgfile = open(configfile,'w')
            config = ConfigParser.ConfigParser(allow_no_value = True)
            for section in sorted(self.__sections.keys()):
                config.add_section(section)
                for key in sorted(self.__sections[section].keys()):
                    config.set(section, key, self.__sections[section][key])
            config.write(cfgfile)
            cfgfile.close()
            logger.info("write configfile was success: %s", configfile)
            return True
        except Exception as exp:
            logger.exception(exp)
            return False

    def get_string_parsed(self, section, key, default = '', log = True):
        raw_string = self.get_string(section, key, default, log)
        parsed_string = doorpi.DoorPi().parse_string(raw_string)
        logger.debug('parse string "%s" to "%s"', raw_string, parsed_string)
        return parsed_string

    def set_value(self, section, key, value, log = True, password = False):
        if section not in self.__sections.keys():
            self.__sections[section] = {}

        password_friendly_value = "*******" if key is 'password' or password else value

        if key not in self.__sections[section].keys():
            if log: logger.debug("create new key %s in section %s with value '%s'",
                                 key, section, password_friendly_value)
        else:
            if log: logger.debug("overwrite key %s in section %s from '%s' to '%s'",
                                 key, section, self.__sections[section][key], password_friendly_value)

        self.__sections[section][key] = value
        return True

    def rename_key(self, section, old_key, new_key, default = '', log = True):
        if log: logging.debug('rename key from %s to %s in section %s', old_key, new_key, section)
        old_value = self.get_string(section, old_key, default, log, store_if_not_exists = False)
        self.set_value(
            section = section,
            key = new_key,
            value = old_value,
            log = log
        )
        self.delete_key(section, old_key, log = log)

    def delete_section(self, section, delete_empty_only = True, log = True):
        if section in self.__sections and len(self.__sections[section]) > 0 and delete_empty_only:
            logger.warning("could not delete section %s, because it's not empty.", section)
            return False

        try:
            if len(self.__sections[section]) > 0 and delete_empty_only:
                raise KeyError('section is not empty')

            self.__sections.pop(section)
            return True
        except KeyError as exp:
            if log: logger.warning('delete section %s failed: %s', section, exp)
            return False

    def delete_key(self, section, key, log = True):
        try:
            if log: logger.info('delete key %s from section %s', key, section)
            self.__sections[section].pop(key)
            self.delete_section(section, log = log)

            return True
        except KeyError as exp:
            if log: logger.warning('delete key %s from section %s failed: %s', key, section, exp)
        return False

    def get_string(self, section, key, default = '', log = True, password = False, store_if_not_exists = True):
        value = None
        try:
            old_section, old_key = BACKWARD_COMPATIBILITY_KEYS[section][key]
            value = self.__sections[old_section][old_key]
            self.delete_key(old_section, old_key, False)
            self.__sections[section][key] = value
            logger.warning('found %s - %s in BACKWARD_COMPATIBILITY_KEYS with %s - %s', section, key, old_section, old_key)
        except KeyError:
            try:
                value = self.__sections[section][key]
            except KeyError:
                pass
        
        if value is None:
            #logger.trace('no value found - use default')
            value = default
            if store_if_not_exists: self.set_value(section, key, default, log, password)

        if key.endswith('password') or password:
            if log: logger.trace("get_string for key %s in section %s (default: %s) returns %s", key, section, default, '*******')
        else:
            if log: logger.trace("get_string for key %s in section %s (default: %s) returns %s", key, section, default, value)
        return value

    def get_float(self, section, key, default = -1, log = True, store_if_not_exists = True):
        value = self.get_string(section, key, str(default), log = False, store_if_not_exists = store_if_not_exists)
        if value is not '': value = float(value)
        else: value = default
        if log: logger.trace("get_integer for key %s in section %s (default: %s) returns %s", key, section, default, value)
        return value

    def get_integer(self, section, key, default = -1, log = True, store_if_not_exists = True):
        value = self.get(section, key, str(default), log = False, store_if_not_exists = store_if_not_exists)
        if value is not '': value = int(value)
        else: value = default
        if log: logger.trace("get_integer for key %s in section %s (default: %s) returns %s", key, section, default, value)
        return value

    def get_boolean(self, section, key, default = False, log = True, store_if_not_exists = True):
        value = self.get(section, key, str(default), log = False, store_if_not_exists = store_if_not_exists)
        value = value.lower() in ['true', 'yes', 'ja', '1']
        if log: logger.trace("get_boolean for key %s in section %s (default: %s) returns %s", key, section, default, value)
        return value

    def get_list(self, section, key, default = [], separator = ',', log = True, store_if_not_exists = True):
        value = self.get(section, key, str(default), log = False, store_if_not_exists = store_if_not_exists)
        if value is not '': value = value.split(separator)
        else: value = default
        if log: logger.trace("get_list for key %s in section %s (default: %s) returns %s", key, section, default, value)
        return value

    def get_sections(self, filter = '', log = True):

        return_list = []
        for section in self.__sections:
            if filter in section: return_list.append(section)
        if log: logger.trace("get_sections returns %s", return_list)
        return return_list

    def get_keys(self, section, filter = '', log = True):

        return_list = []
        if section not in self.__sections:
            logging.warning("section %s not found in configfile", section)
        else:
            for key in self.__sections[section]:
                if filter in key: return_list.append(key)
        if log: logger.trace("get_keys for section %s returns %s", section, return_list)
        return return_list

    def get_from_config(self, config, log = True):
        if log: logger.trace("get_from_config")
        for section in config.sections():
            self.__sections[section] = {}
            for key, value in config.items(section):
                if key.startswith(';') or key.startswith('#'): continue
                self.__sections[section][str(key)] = str(value)

    get = get_string
    get_bool = get_boolean
    get_int = get_integer


1			#!/usr/bin/env python
2			# -- coding: utf-8 --
3
4			import logging
5			logger = logging.getLogger(__name__)
6			logger.debug("%s loaded", __name__)
7
8			import os
9
10			import ConfigParser
11			import doorpi
12
13			from backward_compatibility import BACKWARD_COMPATIBILITY_KEYS
14
15			class ConfigObject():
16
17			__sections = {}
18			_config_file = None
19
20			@property
21			def all(self): return self.__sections
22
23			@property
24			def config_file(self): return self._config_file
25
26			def __init__(self, config, config_file = None):
27			logger.debug("__init__")
28			self.get_from_config(config)
29			self._config_file = config_file
30
31			def __del__(self):
32			return self.destroy()
33
34			def destroy(self):
35			logger.debug("__del__")
36			#DoorPi().event_handler.unregister_source(__name__, True)
37			return True
38
39			@staticmethod
40			def find_config(configfile = None):
41			try:
42			open(configfile.name, 'r').close()
43			return configfile.name
44			except AttributeError: pass
45			except IOError: pass
46
47			default_files = [
48			str(configfile),
49			doorpi.DoorPi().parse_string(str(configfile)),
50			os.path.join('!BASEPATH!', 'conf', 'doorpi.ini'),
51			os.path.join('!BASEPATH!', 'conf', 'doorpi.cfg')
52			]
53
54			for possible_default_file in default_files:
55			try:
56			possible_default_file = doorpi.DoorPi().parse_string(possible_default_file)
57			open(possible_default_file, 'r').close()
58			return possible_default_file
59			except: pass
60
61			return None
62
63			@staticmethod
64			def load_config(configfile, search_for_defaults = True):
65			config = ConfigParser.ConfigParser(allow_no_value = True)
66			if search_for_defaults: configfile_name = ConfigObject.find_config(configfile)
67			else: configfile_name = configfile
68
69			if not configfile_name:
70			logger.error('No valid configfile found - use parameter --configfile "filename" to specify one')
71			return ConfigObject(config)
72
73			logger.info("use configfile: %s", configfile_name)
74
75			config.read(configfile_name)
76			return ConfigObject(config, configfile_name)
77
78			def save_config(self, configfile = ''):
79			if not configfile: configfile = self.config_file
80			if not configfile: configfile = self.find_config(configfile)
81			if not configfile: configfile = doorpi.DoorPi().parse_string(os.path.join('!BASEPATH!', 'conf', 'doorpi.ini'))
82
83			#if not configfile: return False
84			logger.debug("write configfile: %s", configfile)
85			try:
86			if not os.path.exists(os.path.dirname(configfile)):
87			logger.info('Path %s does not exist - creating it now', os.path.dirname(configfile))
88			os.makedirs(os.path.dirname(configfile))
89			cfgfile = open(configfile,'w')
90			config = ConfigParser.ConfigParser(allow_no_value = True)
91			for section in sorted(self.__sections.keys()):
92			config.add_section(section)
93			for key in sorted(self.__sections[section].keys()):
94			config.set(section, key, self.__sections[section][key])
95			config.write(cfgfile)
96			cfgfile.close()
97			logger.info("write configfile was success: %s", configfile)
98			return True
99			except Exception as exp:
100			logger.exception(exp)
101			return False
102
103			def get_string_parsed(self, section, key, default = '', log = True):
104			raw_string = self.get_string(section, key, default, log)
105			parsed_string = doorpi.DoorPi().parse_string(raw_string)
106			logger.debug('parse string "%s" to "%s"', raw_string, parsed_string)
107			return parsed_string
108
109			def set_value(self, section, key, value, log = True, password = False):
110			if section not in self.__sections.keys():
111			self.__sections[section] = {}
112
113			password_friendly_value = "*******" if key is 'password' or password else value
114
115			if key not in self.__sections[section].keys():
116			if log: logger.debug("create new key %s in section %s with value '%s'",
117			key, section, password_friendly_value)
118			else:
119			if log: logger.debug("overwrite key %s in section %s from '%s' to '%s'",
120			key, section, self.__sections[section][key], password_friendly_value)
121
122			self.__sections[section][key] = value
123			return True
124
125			def rename_key(self, section, old_key, new_key, default = '', log = True):
126			if log: logging.debug('rename key from %s to %s in section %s', old_key, new_key, section)
127			old_value = self.get_string(section, old_key, default, log, store_if_not_exists = False)
128			self.set_value(
129			section = section,
130			key = new_key,
131			value = old_value,
132			log = log
133			)
134			self.delete_key(section, old_key, log = log)
135
136			def delete_section(self, section, delete_empty_only = True, log = True):
137			if section in self.__sections and len(self.__sections[section]) > 0 and delete_empty_only:
138			logger.warning("could not delete section %s, because it's not empty.", section)
139			return False
140
141			try:
142			if len(self.__sections[section]) > 0 and delete_empty_only:
143			raise KeyError('section is not empty')
144
145			self.__sections.pop(section)
146			return True
147			except KeyError as exp:
148			if log: logger.warning('delete section %s failed: %s', section, exp)
149			return False
150
151			def delete_key(self, section, key, log = True):
152			try:
153			if log: logger.info('delete key %s from section %s', key, section)
154			self.__sections[section].pop(key)
155			self.delete_section(section, log = log)
156
157			return True
158			except KeyError as exp:
159			if log: logger.warning('delete key %s from section %s failed: %s', key, section, exp)
160			return False
161
162			def get_string(self, section, key, default = '', log = True, password = False, store_if_not_exists = True):
163			value = None
164			try:
165			old_section, old_key = BACKWARD_COMPATIBILITY_KEYS[section][key]
166			value = self.__sections[old_section][old_key]
167			self.delete_key(old_section, old_key, False)
168			self.__sections[section][key] = value
169			logger.warning('found %s - %s in BACKWARD_COMPATIBILITY_KEYS with %s - %s', section, key, old_section, old_key)
170			except KeyError:
171			try:
172			value = self.__sections[section][key]
173			except KeyError:
174			pass
175
176			if value is None:
177			#logger.trace('no value found - use default')
178			value = default
179			if store_if_not_exists: self.set_value(section, key, default, log, password)
180
181			if key.endswith('password') or password:
182			if log: logger.trace("get_string for key %s in section %s (default: %s) returns %s", key, section, default, '*******')
183			else:
184			if log: logger.trace("get_string for key %s in section %s (default: %s) returns %s", key, section, default, value)
185			return value
186
187			def get_float(self, section, key, default = -1, log = True, store_if_not_exists = True):
188			value = self.get_string(section, key, str(default), log = False, store_if_not_exists = store_if_not_exists)
189			if value is not '': value = float(value)
190			else: value = default
191			if log: logger.trace("get_integer for key %s in section %s (default: %s) returns %s", key, section, default, value)
192			return value
193
194			def get_integer(self, section, key, default = -1, log = True, store_if_not_exists = True):
195			value = self.get(section, key, str(default), log = False, store_if_not_exists = store_if_not_exists)
196			if value is not '': value = int(value)
197			else: value = default
198			if log: logger.trace("get_integer for key %s in section %s (default: %s) returns %s", key, section, default, value)
199			return value
200
201			def get_boolean(self, section, key, default = False, log = True, store_if_not_exists = True):
202			value = self.get(section, key, str(default), log = False, store_if_not_exists = store_if_not_exists)
203			value = value.lower() in ['true', 'yes', 'ja', '1']
204			if log: logger.trace("get_boolean for key %s in section %s (default: %s) returns %s", key, section, default, value)
205			return value
206
207			def get_list(self, section, key, default = [], separator = ',', log = True, store_if_not_exists = True):
208			value = self.get(section, key, str(default), log = False, store_if_not_exists = store_if_not_exists)
209			if value is not '': value = value.split(separator)
210			else: value = default
211			if log: logger.trace("get_list for key %s in section %s (default: %s) returns %s", key, section, default, value)
212			return value
213
214			def get_sections(self, filter = '', log = True):
			0 ignored issues – show Bug Best Practice introduced 2015-12-28 07:44 UTC by Report Bug Copy Issue Report This seems to re-define the built-in `filter`. It is generally discouraged to redefine built-ins as this makes code very hard to read. Loading history...
215			return_list = []
216			for section in self.__sections:
217			if filter in section: return_list.append(section)
218			if log: logger.trace("get_sections returns %s", return_list)
219			return return_list
220
221			def get_keys(self, section, filter = '', log = True):
			0 ignored issues – show Bug Best Practice introduced 2015-12-28 07:44 UTC by Report Bug Copy Issue Report This seems to re-define the built-in `filter`. It is generally discouraged to redefine built-ins as this makes code very hard to read. Loading history...
222			return_list = []
223			if section not in self.__sections:
224			logging.warning("section %s not found in configfile", section)
225			else:
226			for key in self.__sections[section]:
227			if filter in key: return_list.append(key)
228			if log: logger.trace("get_keys for section %s returns %s", section, return_list)
229			return return_list
230
231			def get_from_config(self, config, log = True):
232			if log: logger.trace("get_from_config")
233			for section in config.sections():
234			self.__sections[section] = {}
235			for key, value in config.items(section):
236			if key.startswith(';') or key.startswith('#'): continue
237			self.__sections[section][str(key)] = str(value)
238
239			get = get_string
240			get_bool = get_boolean
241			get_int = get_integer
242

motom001 / DoorPi

Push — master ( 0dd74a...cac84e )

ConfigObject.delete_key() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like