1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
"""Settings and configuration handlers.
Settings will be loaded from several .conf files
and any user provided settings file.
"""
# pylint: disable=invalid-name
import copy
import os
import re
import logging
import pprint
#import ast
#import netaddr
_LOGGER = logging.getLogger(__name__)
_PARSE_PATTERN = r'(#[A-Z]+)(\(([^(),]+)(,([0-9]+))?\))?'
class Settings(object):
"""Holding class for settings.
"""
def __init__(self):
pass
def _eval_param(self, param):
# pylint: disable=invalid-name
""" Helper function for expansion of references to parameters
"""
if isinstance(param, str):
# evaluate every #PARAM reference inside parameter itself
macros = re.findall(r'#PARAM\((([\w\-]+)(\[[\w\[\]\-\'\"]+\])*)\)', param)
if macros:
for macro in macros:
# pylint: disable=eval-used
try:
tmp_val = str(eval("self.getValue('{}'){}".format(macro[1], macro[2])))
param = param.replace('#PARAM({})'.format(macro[0]), tmp_val)
# silently ignore that option required by PARAM macro can't be evaluated;
# It is possible, that referred parameter will be constructed during runtime
# and re-read later.
except IndexError:
pass
except AttributeError:
pass
return param
elif isinstance(param, (list, tuple)):
tmp_list = []
for item in param:
tmp_list.append(self._eval_param(item))
return tmp_list
elif isinstance(param, dict):
tmp_dict = {}
for (key, value) in param.items():
tmp_dict[key] = self._eval_param(value)
return tmp_dict
else:
return param
def getValue(self, attr):
"""Return a settings item value
"""
if attr in self.__dict__:
master_value = getattr(self, attr)
return self._eval_param(master_value)
else:
raise AttributeError("%r object has no attribute %r" %
(self.__class__, attr))
def hasValue(self, attr):
"""Return true if key exists
"""
if attr in self.__dict__:
return True
return False
def __setattr__(self, name, value):
"""Set a value
"""
# skip non-settings. this should exclude built-ins amongst others
if not name.isupper():
return
# we can assume all uppercase keys are valid settings
super(Settings, self).__setattr__(name, value)
def setValue(self, name, value):
"""Set a value
"""
if name is not None and value is not None:
super(Settings, self).__setattr__(name, value)
def load_from_file(self, path):
"""Update ``settings`` with values found in module at ``path``.
"""
import imp
custom_settings = imp.load_source('custom_settings', path)
for key in dir(custom_settings):
if getattr(custom_settings, key) is not None:
setattr(self, key, getattr(custom_settings, key))
def load_from_dir(self, dir_path):
"""Update ``settings`` with contents of the .conf files at ``path``.
Each file must be named Nfilename.conf, where N is a single or
multi-digit decimal number. The files are loaded in ascending order of
N - so if a configuration item exists in more that one file the setting
in the file with the largest value of N takes precedence.
:param dir_path: The full path to the dir from which to load the .conf
files.
:returns: None
"""
regex = re.compile("^(?P<digit_part>[0-9]+)(?P<alfa_part>[a-z]?)_.*.conf$")
def get_prefix(filename):
"""
Provide a suitable function for sort's key arg
"""
match_object = regex.search(os.path.basename(filename))
return [int(match_object.group('digit_part')),
match_object.group('alfa_part')]
# get full file path to all files & dirs in dir_path
file_paths = os.listdir(dir_path)
file_paths = [os.path.join(dir_path, x) for x in file_paths]
# filter to get only those that are a files, with a leading
# digit and end in '.conf'
file_paths = [x for x in file_paths if os.path.isfile(x) and
regex.search(os.path.basename(x))]
# sort ascending on the leading digits and afla (e.g. 03_, 05a_)
file_paths.sort(key=get_prefix)
# load settings from each file in turn
for filepath in file_paths:
self.load_from_file(filepath)
def load_from_dict(self, conf):
"""
Update ``settings`` with values found in ``conf``.
Unlike the other loaders, this is case insensitive.
"""
for key in conf:
if conf[key] is not None:
if isinstance(conf[key], dict):
# recursively update dict items
setattr(self, key.upper(),
merge_spec(getattr(self, key.upper()), conf[key]))
else:
setattr(self, key.upper(), conf[key])
def restore_from_dict(self, conf):
"""
Restore ``settings`` with values found in ``conf``.
Method will drop all configuration options and restore their
values from conf dictionary
"""
self.__dict__.clear()
tmp_conf = copy.deepcopy(conf)
for key in tmp_conf:
self.setValue(key, tmp_conf[key])
def load_from_env(self):
"""
Update ``settings`` with values found in the environment.
"""
for key in os.environ:
setattr(self, key, os.environ[key])
def __str__(self):
"""Provide settings as a human-readable string.
This can be useful for debug.
Returns:
A human-readable string.
"""
tmp_dict = {}
for key in self.__dict__:
tmp_dict[key] = self.getValue(key)
return pprint.pformat(tmp_dict)
settings = Settings()
def merge_spec(orig, new):
"""Merges ``new`` dict with ``orig`` dict, and returns orig.
This takes into account nested dictionaries. Example:
>>> old = {'foo': 1, 'bar': {'foo': 2, 'bar': 3}}
>>> new = {'foo': 6, 'bar': {'foo': 7}}
>>> merge_spec(old, new)
{'foo': 6, 'bar': {'foo': 7, 'bar': 3}}
You'll notice that ``bar.bar`` is not removed. This is the desired result.
"""
for key in orig:
if key not in new:
continue
# Not allowing derived dictionary types for now
# pylint: disable=unidiomatic-typecheck
if type(orig[key]) == dict:
orig[key] = merge_spec(orig[key], new[key])
else:
orig[key] = new[key]
for key in new:
if key not in orig:
orig[key] = new[key]
return orig
|
