ConfigObject.get_string()   F
last analyzed

Complexity

Conditions 9

Size

Total Lines 24

Duplication

Lines 0
Ratio 0 %

Importance

Changes 1
Bugs 0 Features 0
Metric Value
cc 9
dl 0
loc 24
rs 3.4838
c 1
b 0
f 0
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 by Thomas Meissner
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 by Thomas Meissner
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