/usr/share/pyshared/pebl/config.py is in python-pebl 1.0.2-2+b1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 | """Classes and functions for specifying and working with parameters."""
from __future__ import with_statement
import sys
import os.path
from ConfigParser import ConfigParser
from itertools import groupby
from time import asctime
from operator import attrgetter
from pebl.util import unzip, as_list
#
# Global list of parameters
#
_parameters = {}
#
# Validator Factories (they return validator functions)
#
def between(min, max):
"""Returns validator that checks whether value is between min and max."""
v = lambda x: x >= min and x <= max
v.__doc__ = "Parameter value should be between %d and %d." % (min,max)
return v
def oneof(*values):
"""Returns validator that checks whether value is in approved list."""
v = lambda x: x in values
v.__doc__ = "Parameter value should be one of {%s}." % ', '.join(values)
return v
def atleast(min):
"""Returns validator that checks whether value is > min."""
v = lambda x: x >= min
v.__doc__ = "Parameter value should be at least %d." % min
return v
def atmost(max):
"""Returns validator that checks whether value is < max."""
v = lambda x: x <= max
v.__doc__ = "Parameter value should be at most %d." % max
return v
def fileexists():
"""Returns validator that checks whether value is an existing file."""
v = lambda x: os.path.exists(x) and os.path.isfile(x)
v.__doc__ = "Parameter value should be a file that exists."
return v
#
# Parameter classes
#
def default_validator(x):
return True
class Parameter:
"""Classes for configuration parameters."""
datatype = None
def __init__(self, name, description, validator=default_validator, default=None):
nameparts = name.split('.')
if len(nameparts) is not 2:
raise Exception("Parameter name has to be of the form 'section.name'")
self.name = name.lower()
self.section, self.option = nameparts
self.description = description
self.validator = validator
self.value = self.default = default
self.source = None
# add self to the parameter registry
_parameters[self.name] = self
class StringParameter(Parameter): datatype=str
class IntParameter(Parameter): datatype=int
class FloatParameter(Parameter): datatype=float
#
# Functions for {get/set/read/write/list}ing parameters
#
def set(name, value, source='config.set'):
"""Set a parameter value.
- name should be of the form "section.name".
- value can be a string which will be casted to the required datatype.
- source specifies where this parameter value was specified (config file,
command line, interactive shell, etc).
"""
name = name.lower()
if name not in _parameters:
msg = "Parameter %s is unknown." % name
raise KeyError(msg)
param = _parameters[name]
# try coercing value to required data type
try:
value = param.datatype(value)
except ValueError, e:
msg = "Cannot convert value to required datatype: %s" % e.message
raise Exception(msg)
# try validating
try:
valid = param.validator(value)
except:
msg = "Validator for parameter %s caused an error while validating" + \
"value %s"
raise Exception(msg % (name, value))
if not valid:
raise Exception("Value %s is not valid for parameter %s. %s" % \
(value, name, param.validator.__doc__ or 'error unknown'))
param.value = value
param.source = source
def get(name):
"""Returns value of parameter.
Raises KeyError if parameter not found.
Examples::
from pebl import config
config.get('data.filename')
config.get('result.format')
The value returned could be the default value or the latest value set using
config.set or config.read
"""
name = name.lower()
if name in _parameters:
return _parameters[name].value
else:
raise KeyError("Parameter %s not found." % name)
def read(filename):
"""Reads parameter from config file.
Config files should conform to the format specified in the ConfigParser
module from Python's standard library. A Parameter's name has two parts:
the section and the option name. These correspond to 'section' and
'option' as defined in ConfigParser.
For example, parameter 'foo.bar' would be specified in the config file as::
[foo]
bar = 5
"""
config = ConfigParser()
config.read(filename)
errors = []
for section in config.sections():
for option,value in config.items(section):
name = "%s.%s" % (section, option)
try:
set(name, value, "config file %s" % filename)
except Exception, e:
errors.append(str(e))
if errors:
errheader = "%d errors encountered:" % len(errors)
raise Exception("\n".join([errheader] + errors))
def write(filename, include_defaults=False):
"""Writes parameters to config file.
If include_default is True, writes all parameters. Else, only writes
parameters that were specifically set (via config file, command line, etc).
"""
config = ConfigParser()
params = _parameters.values() if include_defaults \
else [p for p in _parameters.values() if p.source]
for param in params:
config.set(param.section, param.option, param.value)
with file(filename, 'w') as f:
config.write(f)
def parameters(section=None):
"""Returns list of parameters.
If section is specified, returns parameters for that section only.
section can be a section name or a search string to use with
string.startswith(..)
"""
if section:
return [p for p in _parameters.values() if p.name.startswith(section)]
else:
return _parameters.values()
def paramdocs(section=None, section_header=False):
lines = []
params = sorted(parameters(section), key=attrgetter('name'))
lines += [".. Autogenerated by pebl.config.paramdocs at %s\n\n" % asctime()]
for section, options in groupby(params, lambda p:p.section):
if section_header:
lines += ["%s\n%s\n\n" % (section, '-'*len(section))]
lines += [".. confparam:: %s\n\n\t%s\n\tdefault=%s\n\n" %
(o.name,
o.description,
'None' if o.default is None else o.default)
for o in options]
return ''.join(lines)
def configobj(params):
"""Given a list of parameters, returns a ConfigParser object.
This function can be used to convert a list of parameters to a config
object which can then be written to file.
"""
if isinstance(params, list):
params = dict((p.name, p.value) for p in params)
configobj = ConfigParser()
for key,value in params.items():
section,name = key.strip().split('.')
if section not in configobj.sections():
configobj.add_section(section)
configobj.set(section, name, value)
return configobj
def setparams(obj, options):
"""Sets attributes of self based on options and pebl.config."""
for p in getattr(obj, '_params', []):
setattr(obj, p.option, options.get(p.option, get(p.name)))
|