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
|
# Copyright (c) 2016 Weitian LI <liweitianux@live.com>
# MIT license
"""
Custom checkers to further validate the configurations.
NOTE
----
These functions further check the configurations as a whole, which means
one config option may be checked against its context.
Therefore, they are very different to the checker functions used in the
``validate.Validator``.
"""
import os
from ..errors import ConfigError
def _check_missing(configs, keys):
"""Check whether the required config is provided by the user."""
results = {}
if isinstance(keys, str):
keys = [keys, ]
for key in keys:
if not configs.getn(key):
results[key] = "Value required but missing"
return results
def _check_existence(configs, keys):
"""Check whether the file/directory corresponding to the config exists."""
if isinstance(keys, str):
keys = [keys, ]
results = {}
for key in keys:
res = _check_missing(configs, key)
if res == {}:
# Both "key" and "dir_key" are valid
path = configs.get_path(key)
if not os.path.exists(path):
res[key] = 'File/directory not exist: "%s"' % path
results.update(res)
return results
def _is_power2(n):
"""Check a number whether a power of 2"""
# Credit: https://stackoverflow.com/a/29489026/4856091
return (n and not (n & (n-1)))
def check_common(configs):
"""Check the "[common]" section of the configurations."""
results = {}
# "common/nside" must be a power of 2
key = "common/nside"
if not _is_power2(configs.getn(key)):
results[key] = "not a power of 2"
# "common/lmax" must be greater than "common/lmin"
key = "common/lmax"
if configs.getn(key) <= configs.getn("common/lmin"):
results[key] = "not greater than 'common/lmin'"
# Check enabled components
key = "common/components"
if len(configs.getn(key)) == 0:
results[key] = "no components enabled/selected"
return results
def check_frequency(configs):
"""Check the "[frequency]" section of the configurations."""
results = {}
if configs.getn("frequency/type") == "custom":
results.update(_check_missing(configs, "frequency/frequencies"))
elif configs.getn("frequency/type") == "calc":
results.update(
_check_missing(configs, ["frequency/start",
"frequency/stop",
"frequency/step"])
)
return results
def check_output(configs):
"""Check the "[output]" section of the configurations."""
results = {}
if configs.getn("output/combine"):
results.update(_check_missing(configs, "output/output_dir"))
return results
def check_galactic_synchrotron(configs):
"""Check the "[galactic][synchrotron]" section of the configurations."""
comp = "galactic/synchrotron"
comp_enabled = configs.getn("common/components")
results = {}
if comp in comp_enabled:
# Only validate the configs if this component is enabled
results.update(
_check_missing(configs, [comp+"/template_freq",
comp+"/template_unit"])
)
results.update(
_check_existence(configs, [comp+"/template", comp+"/indexmap"])
)
if configs.getn(comp+"/save"):
results.update(_check_missing(configs, comp+"/output_dir"))
return results
def check_galactic_freefree(configs):
"""Check the "[galactic][freefree]" section of the configurations."""
comp = "galactic/freefree"
comp_enabled = configs.getn("common/components")
results = {}
if comp in comp_enabled:
# Only validate the configs if this component is enabled
results.update(
_check_missing(configs, [comp+"/halphamap_unit",
comp+"/dustmap_unit"])
)
results.update(
_check_existence(configs, [comp+"/halphamap", comp+"/dustmap"])
)
if configs.getn(comp+"/save"):
results.update(_check_missing(configs, comp+"/output_dir"))
return results
def check_galactic_snr(configs):
"""Check the "[galactic][snr]" section of the configurations."""
comp = "galactic/snr"
comp_enabled = configs.getn("common/components")
results = {}
if comp in comp_enabled:
# Only validate the configs if this component is enabled
results.update(
_check_existence(configs, comp+"/catalog")
)
if configs.getn(comp+"/save"):
results.update(_check_missing(configs, comp+"/output_dir"))
return results
# Available checkers to validate the configurations
_CHECKERS = [
check_common,
check_frequency,
check_output,
check_galactic_synchrotron,
check_galactic_freefree,
check_galactic_snr,
]
def check_configs(configs, raise_exception=True, checkers=_CHECKERS):
"""Check/validate the whole configurations through all the supplied
checker functions.
These checker functions may check one config option against its context
if necessary to determine whether it has a valid value.
Parameters
----------
configs : `ConfigManager` instance
An ``ConfigManager`` instance contains both default and user
configurations.
raise_exception : bool, optional
Whether raise a ``ConfigError`` exception if there is any invalid
config options?
checkers : list of functions, optional
List of checker functions through which the configurations
will be checked.
Returns
-------
result : bool
``True`` if the configurations pass all checker functions.
errors : dict
An dictionary containing the details about the invalid config options,
with the keys identifying the config options and values indicating
the error message.
If above ``result=True``, then this is an empty dictionary ``{}``.
Raises
------
ConfigError
If any config option failed to pass any of the checkers, a
``ConfigError`` with details is raised.
"""
errors = {}
for checker in checkers:
errors.update(checker(configs))
#
if errors == {}:
result = True
else:
result = False
if raise_exception:
msg = "\n".join(['Config "{key}": {val}'.format(key=key, val=val)
for key, val in errors.items()])
raise ConfigError(msg)
return (result, errors)
|
