| 1 | """Configuration file parser.
|
|---|
| 2 |
|
|---|
| 3 | A setup file consists of sections, lead by a "[section]" header,
|
|---|
| 4 | and followed by "name: value" entries, with continuations and such in
|
|---|
| 5 | the style of RFC 822.
|
|---|
| 6 |
|
|---|
| 7 | The option values can contain format strings which refer to other values in
|
|---|
| 8 | the same section, or values in a special [DEFAULT] section.
|
|---|
| 9 |
|
|---|
| 10 | For example:
|
|---|
| 11 |
|
|---|
| 12 | something: %(dir)s/whatever
|
|---|
| 13 |
|
|---|
| 14 | would resolve the "%(dir)s" to the value of dir. All reference
|
|---|
| 15 | expansions are done late, on demand.
|
|---|
| 16 |
|
|---|
| 17 | Intrinsic defaults can be specified by passing them into the
|
|---|
| 18 | ConfigParser constructor as a dictionary.
|
|---|
| 19 |
|
|---|
| 20 | class:
|
|---|
| 21 |
|
|---|
| 22 | ConfigParser -- responsible for parsing a list of
|
|---|
| 23 | configuration files, and managing the parsed database.
|
|---|
| 24 |
|
|---|
| 25 | methods:
|
|---|
| 26 |
|
|---|
| 27 | __init__(defaults=None)
|
|---|
| 28 | create the parser and specify a dictionary of intrinsic defaults. The
|
|---|
| 29 | keys must be strings, the values must be appropriate for %()s string
|
|---|
| 30 | interpolation. Note that `__name__' is always an intrinsic default;
|
|---|
| 31 | its value is the section's name.
|
|---|
| 32 |
|
|---|
| 33 | sections()
|
|---|
| 34 | return all the configuration section names, sans DEFAULT
|
|---|
| 35 |
|
|---|
| 36 | has_section(section)
|
|---|
| 37 | return whether the given section exists
|
|---|
| 38 |
|
|---|
| 39 | has_option(section, option)
|
|---|
| 40 | return whether the given option exists in the given section
|
|---|
| 41 |
|
|---|
| 42 | options(section)
|
|---|
| 43 | return list of configuration options for the named section
|
|---|
| 44 |
|
|---|
| 45 | read(filenames)
|
|---|
| 46 | read and parse the list of named configuration files, given by
|
|---|
| 47 | name. A single filename is also allowed. Non-existing files
|
|---|
| 48 | are ignored. Return list of successfully read files.
|
|---|
| 49 |
|
|---|
| 50 | readfp(fp, filename=None)
|
|---|
| 51 | read and parse one configuration file, given as a file object.
|
|---|
| 52 | The filename defaults to fp.name; it is only used in error
|
|---|
| 53 | messages (if fp has no `name' attribute, the string `<???>' is used).
|
|---|
| 54 |
|
|---|
| 55 | get(section, option, raw=False, vars=None)
|
|---|
| 56 | return a string value for the named option. All % interpolations are
|
|---|
| 57 | expanded in the return values, based on the defaults passed into the
|
|---|
| 58 | constructor and the DEFAULT section. Additional substitutions may be
|
|---|
| 59 | provided using the `vars' argument, which must be a dictionary whose
|
|---|
| 60 | contents override any pre-existing defaults.
|
|---|
| 61 |
|
|---|
| 62 | getint(section, options)
|
|---|
| 63 | like get(), but convert value to an integer
|
|---|
| 64 |
|
|---|
| 65 | getfloat(section, options)
|
|---|
| 66 | like get(), but convert value to a float
|
|---|
| 67 |
|
|---|
| 68 | getboolean(section, options)
|
|---|
| 69 | like get(), but convert value to a boolean (currently case
|
|---|
| 70 | insensitively defined as 0, false, no, off for False, and 1, true,
|
|---|
| 71 | yes, on for True). Returns False or True.
|
|---|
| 72 |
|
|---|
| 73 | items(section, raw=False, vars=None)
|
|---|
| 74 | return a list of tuples with (name, value) for each option
|
|---|
| 75 | in the section.
|
|---|
| 76 |
|
|---|
| 77 | remove_section(section)
|
|---|
| 78 | remove the given file section and all its options
|
|---|
| 79 |
|
|---|
| 80 | remove_option(section, option)
|
|---|
| 81 | remove the given option from the given section
|
|---|
| 82 |
|
|---|
| 83 | set(section, option, value)
|
|---|
| 84 | set the given option
|
|---|
| 85 |
|
|---|
| 86 | write(fp)
|
|---|
| 87 | write the configuration state in .ini format
|
|---|
| 88 | """
|
|---|
| 89 |
|
|---|
| 90 | import re
|
|---|
| 91 |
|
|---|
| 92 | __all__ = ["NoSectionError", "DuplicateSectionError", "NoOptionError",
|
|---|
| 93 | "InterpolationError", "InterpolationDepthError",
|
|---|
| 94 | "InterpolationSyntaxError", "ParsingError",
|
|---|
| 95 | "MissingSectionHeaderError",
|
|---|
| 96 | "ConfigParser", "SafeConfigParser", "RawConfigParser",
|
|---|
| 97 | "DEFAULTSECT", "MAX_INTERPOLATION_DEPTH"]
|
|---|
| 98 |
|
|---|
| 99 | DEFAULTSECT = "DEFAULT"
|
|---|
| 100 |
|
|---|
| 101 | MAX_INTERPOLATION_DEPTH = 10
|
|---|
| 102 |
|
|---|
| 103 |
|
|---|
| 104 |
|
|---|
| 105 | # exception classes
|
|---|
| 106 | class Error(Exception):
|
|---|
| 107 | """Base class for ConfigParser exceptions."""
|
|---|
| 108 |
|
|---|
| 109 | def _get_message(self):
|
|---|
| 110 | """Getter for 'message'; needed only to override deprecation in
|
|---|
| 111 | BaseException."""
|
|---|
| 112 | return self.__message
|
|---|
| 113 |
|
|---|
| 114 | def _set_message(self, value):
|
|---|
| 115 | """Setter for 'message'; needed only to override deprecation in
|
|---|
| 116 | BaseException."""
|
|---|
| 117 | self.__message = value
|
|---|
| 118 |
|
|---|
| 119 | # BaseException.message has been deprecated since Python 2.6. To prevent
|
|---|
| 120 | # DeprecationWarning from popping up over this pre-existing attribute, use
|
|---|
| 121 | # a new property that takes lookup precedence.
|
|---|
| 122 | message = property(_get_message, _set_message)
|
|---|
| 123 |
|
|---|
| 124 | def __init__(self, msg=''):
|
|---|
| 125 | self.message = msg
|
|---|
| 126 | Exception.__init__(self, msg)
|
|---|
| 127 |
|
|---|
| 128 | def __repr__(self):
|
|---|
| 129 | return self.message
|
|---|
| 130 |
|
|---|
| 131 | __str__ = __repr__
|
|---|
| 132 |
|
|---|
| 133 | class NoSectionError(Error):
|
|---|
| 134 | """Raised when no section matches a requested option."""
|
|---|
| 135 |
|
|---|
| 136 | def __init__(self, section):
|
|---|
| 137 | Error.__init__(self, 'No section: %r' % (section,))
|
|---|
| 138 | self.section = section
|
|---|
| 139 |
|
|---|
| 140 | class DuplicateSectionError(Error):
|
|---|
| 141 | """Raised when a section is multiply-created."""
|
|---|
| 142 |
|
|---|
| 143 | def __init__(self, section):
|
|---|
| 144 | Error.__init__(self, "Section %r already exists" % section)
|
|---|
| 145 | self.section = section
|
|---|
| 146 |
|
|---|
| 147 | class NoOptionError(Error):
|
|---|
| 148 | """A requested option was not found."""
|
|---|
| 149 |
|
|---|
| 150 | def __init__(self, option, section):
|
|---|
| 151 | Error.__init__(self, "No option %r in section: %r" %
|
|---|
| 152 | (option, section))
|
|---|
| 153 | self.option = option
|
|---|
| 154 | self.section = section
|
|---|
| 155 |
|
|---|
| 156 | class InterpolationError(Error):
|
|---|
| 157 | """Base class for interpolation-related exceptions."""
|
|---|
| 158 |
|
|---|
| 159 | def __init__(self, option, section, msg):
|
|---|
| 160 | Error.__init__(self, msg)
|
|---|
| 161 | self.option = option
|
|---|
| 162 | self.section = section
|
|---|
| 163 |
|
|---|
| 164 | class InterpolationMissingOptionError(InterpolationError):
|
|---|
| 165 | """A string substitution required a setting which was not available."""
|
|---|
| 166 |
|
|---|
| 167 | def __init__(self, option, section, rawval, reference):
|
|---|
| 168 | msg = ("Bad value substitution:\n"
|
|---|
| 169 | "\tsection: [%s]\n"
|
|---|
| 170 | "\toption : %s\n"
|
|---|
| 171 | "\tkey : %s\n"
|
|---|
| 172 | "\trawval : %s\n"
|
|---|
| 173 | % (section, option, reference, rawval))
|
|---|
| 174 | InterpolationError.__init__(self, option, section, msg)
|
|---|
| 175 | self.reference = reference
|
|---|
| 176 |
|
|---|
| 177 | class InterpolationSyntaxError(InterpolationError):
|
|---|
| 178 | """Raised when the source text into which substitutions are made
|
|---|
| 179 | does not conform to the required syntax."""
|
|---|
| 180 |
|
|---|
| 181 | class InterpolationDepthError(InterpolationError):
|
|---|
| 182 | """Raised when substitutions are nested too deeply."""
|
|---|
| 183 |
|
|---|
| 184 | def __init__(self, option, section, rawval):
|
|---|
| 185 | msg = ("Value interpolation too deeply recursive:\n"
|
|---|
| 186 | "\tsection: [%s]\n"
|
|---|
| 187 | "\toption : %s\n"
|
|---|
| 188 | "\trawval : %s\n"
|
|---|
| 189 | % (section, option, rawval))
|
|---|
| 190 | InterpolationError.__init__(self, option, section, msg)
|
|---|
| 191 |
|
|---|
| 192 | class ParsingError(Error):
|
|---|
| 193 | """Raised when a configuration file does not follow legal syntax."""
|
|---|
| 194 |
|
|---|
| 195 | def __init__(self, filename):
|
|---|
| 196 | Error.__init__(self, 'File contains parsing errors: %s' % filename)
|
|---|
| 197 | self.filename = filename
|
|---|
| 198 | self.errors = []
|
|---|
| 199 |
|
|---|
| 200 | def append(self, lineno, line):
|
|---|
| 201 | self.errors.append((lineno, line))
|
|---|
| 202 | self.message += '\n\t[line %2d]: %s' % (lineno, line)
|
|---|
| 203 |
|
|---|
| 204 | class MissingSectionHeaderError(ParsingError):
|
|---|
| 205 | """Raised when a key-value pair is found before any section header."""
|
|---|
| 206 |
|
|---|
| 207 | def __init__(self, filename, lineno, line):
|
|---|
| 208 | Error.__init__(
|
|---|
| 209 | self,
|
|---|
| 210 | 'File contains no section headers.\nfile: %s, line: %d\n%r' %
|
|---|
| 211 | (filename, lineno, line))
|
|---|
| 212 | self.filename = filename
|
|---|
| 213 | self.lineno = lineno
|
|---|
| 214 | self.line = line
|
|---|
| 215 |
|
|---|
| 216 |
|
|---|
| 217 | class RawConfigParser:
|
|---|
| 218 | def __init__(self, defaults=None, dict_type=dict):
|
|---|
| 219 | self._dict = dict_type
|
|---|
| 220 | self._sections = self._dict()
|
|---|
| 221 | self._defaults = self._dict()
|
|---|
| 222 | if defaults:
|
|---|
| 223 | for key, value in defaults.items():
|
|---|
| 224 | self._defaults[self.optionxform(key)] = value
|
|---|
| 225 |
|
|---|
| 226 | def defaults(self):
|
|---|
| 227 | return self._defaults
|
|---|
| 228 |
|
|---|
| 229 | def sections(self):
|
|---|
| 230 | """Return a list of section names, excluding [DEFAULT]"""
|
|---|
| 231 | # self._sections will never have [DEFAULT] in it
|
|---|
| 232 | return self._sections.keys()
|
|---|
| 233 |
|
|---|
| 234 | def add_section(self, section):
|
|---|
| 235 | """Create a new section in the configuration.
|
|---|
| 236 |
|
|---|
| 237 | Raise DuplicateSectionError if a section by the specified name
|
|---|
| 238 | already exists. Raise ValueError if name is DEFAULT or any of it's
|
|---|
| 239 | case-insensitive variants.
|
|---|
| 240 | """
|
|---|
| 241 | if section.lower() == "default":
|
|---|
| 242 | raise ValueError, 'Invalid section name: %s' % section
|
|---|
| 243 |
|
|---|
| 244 | if section in self._sections:
|
|---|
| 245 | raise DuplicateSectionError(section)
|
|---|
| 246 | self._sections[section] = self._dict()
|
|---|
| 247 |
|
|---|
| 248 | def has_section(self, section):
|
|---|
| 249 | """Indicate whether the named section is present in the configuration.
|
|---|
| 250 |
|
|---|
| 251 | The DEFAULT section is not acknowledged.
|
|---|
| 252 | """
|
|---|
| 253 | return section in self._sections
|
|---|
| 254 |
|
|---|
| 255 | def options(self, section):
|
|---|
| 256 | """Return a list of option names for the given section name."""
|
|---|
| 257 | try:
|
|---|
| 258 | opts = self._sections[section].copy()
|
|---|
| 259 | except KeyError:
|
|---|
| 260 | raise NoSectionError(section)
|
|---|
| 261 | opts.update(self._defaults)
|
|---|
| 262 | if '__name__' in opts:
|
|---|
| 263 | del opts['__name__']
|
|---|
| 264 | return opts.keys()
|
|---|
| 265 |
|
|---|
| 266 | def read(self, filenames):
|
|---|
| 267 | """Read and parse a filename or a list of filenames.
|
|---|
| 268 |
|
|---|
| 269 | Files that cannot be opened are silently ignored; this is
|
|---|
| 270 | designed so that you can specify a list of potential
|
|---|
| 271 | configuration file locations (e.g. current directory, user's
|
|---|
| 272 | home directory, systemwide directory), and all existing
|
|---|
| 273 | configuration files in the list will be read. A single
|
|---|
| 274 | filename may also be given.
|
|---|
| 275 |
|
|---|
| 276 | Return list of successfully read files.
|
|---|
| 277 | """
|
|---|
| 278 | if isinstance(filenames, basestring):
|
|---|
| 279 | filenames = [filenames]
|
|---|
| 280 | read_ok = []
|
|---|
| 281 | for filename in filenames:
|
|---|
| 282 | try:
|
|---|
| 283 | fp = open(filename)
|
|---|
| 284 | except IOError:
|
|---|
| 285 | continue
|
|---|
| 286 | self._read(fp, filename)
|
|---|
| 287 | fp.close()
|
|---|
| 288 | read_ok.append(filename)
|
|---|
| 289 | return read_ok
|
|---|
| 290 |
|
|---|
| 291 | def readfp(self, fp, filename=None):
|
|---|
| 292 | """Like read() but the argument must be a file-like object.
|
|---|
| 293 |
|
|---|
| 294 | The `fp' argument must have a `readline' method. Optional
|
|---|
| 295 | second argument is the `filename', which if not given, is
|
|---|
| 296 | taken from fp.name. If fp has no `name' attribute, `<???>' is
|
|---|
| 297 | used.
|
|---|
| 298 |
|
|---|
| 299 | """
|
|---|
| 300 | if filename is None:
|
|---|
| 301 | try:
|
|---|
| 302 | filename = fp.name
|
|---|
| 303 | except AttributeError:
|
|---|
| 304 | filename = '<???>'
|
|---|
| 305 | self._read(fp, filename)
|
|---|
| 306 |
|
|---|
| 307 | def get(self, section, option):
|
|---|
| 308 | opt = self.optionxform(option)
|
|---|
| 309 | if section not in self._sections:
|
|---|
| 310 | if section != DEFAULTSECT:
|
|---|
| 311 | raise NoSectionError(section)
|
|---|
| 312 | if opt in self._defaults:
|
|---|
| 313 | return self._defaults[opt]
|
|---|
| 314 | else:
|
|---|
| 315 | raise NoOptionError(option, section)
|
|---|
| 316 | elif opt in self._sections[section]:
|
|---|
| 317 | return self._sections[section][opt]
|
|---|
| 318 | elif opt in self._defaults:
|
|---|
| 319 | return self._defaults[opt]
|
|---|
| 320 | else:
|
|---|
| 321 | raise NoOptionError(option, section)
|
|---|
| 322 |
|
|---|
| 323 | def items(self, section):
|
|---|
| 324 | try:
|
|---|
| 325 | d2 = self._sections[section]
|
|---|
| 326 | except KeyError:
|
|---|
| 327 | if section != DEFAULTSECT:
|
|---|
| 328 | raise NoSectionError(section)
|
|---|
| 329 | d2 = self._dict()
|
|---|
| 330 | d = self._defaults.copy()
|
|---|
| 331 | d.update(d2)
|
|---|
| 332 | if "__name__" in d:
|
|---|
| 333 | del d["__name__"]
|
|---|
| 334 | return d.items()
|
|---|
| 335 |
|
|---|
| 336 | def _get(self, section, conv, option):
|
|---|
| 337 | return conv(self.get(section, option))
|
|---|
| 338 |
|
|---|
| 339 | def getint(self, section, option):
|
|---|
| 340 | return self._get(section, int, option)
|
|---|
| 341 |
|
|---|
| 342 | def getfloat(self, section, option):
|
|---|
| 343 | return self._get(section, float, option)
|
|---|
| 344 |
|
|---|
| 345 | _boolean_states = {'1': True, 'yes': True, 'true': True, 'on': True,
|
|---|
| 346 | '0': False, 'no': False, 'false': False, 'off': False}
|
|---|
| 347 |
|
|---|
| 348 | def getboolean(self, section, option):
|
|---|
| 349 | v = self.get(section, option)
|
|---|
| 350 | if v.lower() not in self._boolean_states:
|
|---|
| 351 | raise ValueError, 'Not a boolean: %s' % v
|
|---|
| 352 | return self._boolean_states[v.lower()]
|
|---|
| 353 |
|
|---|
| 354 | def optionxform(self, optionstr):
|
|---|
| 355 | return optionstr.lower()
|
|---|
| 356 |
|
|---|
| 357 | def has_option(self, section, option):
|
|---|
| 358 | """Check for the existence of a given option in a given section."""
|
|---|
| 359 | if not section or section == DEFAULTSECT:
|
|---|
| 360 | option = self.optionxform(option)
|
|---|
| 361 | return option in self._defaults
|
|---|
| 362 | elif section not in self._sections:
|
|---|
| 363 | return False
|
|---|
| 364 | else:
|
|---|
| 365 | option = self.optionxform(option)
|
|---|
| 366 | return (option in self._sections[section]
|
|---|
| 367 | or option in self._defaults)
|
|---|
| 368 |
|
|---|
| 369 | def set(self, section, option, value):
|
|---|
| 370 | """Set an option."""
|
|---|
| 371 | if not section or section == DEFAULTSECT:
|
|---|
| 372 | sectdict = self._defaults
|
|---|
| 373 | else:
|
|---|
| 374 | try:
|
|---|
| 375 | sectdict = self._sections[section]
|
|---|
| 376 | except KeyError:
|
|---|
| 377 | raise NoSectionError(section)
|
|---|
| 378 | sectdict[self.optionxform(option)] = value
|
|---|
| 379 |
|
|---|
| 380 | def write(self, fp):
|
|---|
| 381 | """Write an .ini-format representation of the configuration state."""
|
|---|
| 382 | if self._defaults:
|
|---|
| 383 | fp.write("[%s]\n" % DEFAULTSECT)
|
|---|
| 384 | for (key, value) in self._defaults.items():
|
|---|
| 385 | fp.write("%s = %s\n" % (key, str(value).replace('\n', '\n\t')))
|
|---|
| 386 | fp.write("\n")
|
|---|
| 387 | for section in self._sections:
|
|---|
| 388 | fp.write("[%s]\n" % section)
|
|---|
| 389 | for (key, value) in self._sections[section].items():
|
|---|
| 390 | if key != "__name__":
|
|---|
| 391 | fp.write("%s = %s\n" %
|
|---|
| 392 | (key, str(value).replace('\n', '\n\t')))
|
|---|
| 393 | fp.write("\n")
|
|---|
| 394 |
|
|---|
| 395 | def remove_option(self, section, option):
|
|---|
| 396 | """Remove an option."""
|
|---|
| 397 | if not section or section == DEFAULTSECT:
|
|---|
| 398 | sectdict = self._defaults
|
|---|
| 399 | else:
|
|---|
| 400 | try:
|
|---|
| 401 | sectdict = self._sections[section]
|
|---|
| 402 | except KeyError:
|
|---|
| 403 | raise NoSectionError(section)
|
|---|
| 404 | option = self.optionxform(option)
|
|---|
| 405 | existed = option in sectdict
|
|---|
| 406 | if existed:
|
|---|
| 407 | del sectdict[option]
|
|---|
| 408 | return existed
|
|---|
| 409 |
|
|---|
| 410 | def remove_section(self, section):
|
|---|
| 411 | """Remove a file section."""
|
|---|
| 412 | existed = section in self._sections
|
|---|
| 413 | if existed:
|
|---|
| 414 | del self._sections[section]
|
|---|
| 415 | return existed
|
|---|
| 416 |
|
|---|
| 417 | #
|
|---|
| 418 | # Regular expressions for parsing section headers and options.
|
|---|
| 419 | #
|
|---|
| 420 | SECTCRE = re.compile(
|
|---|
| 421 | r'\[' # [
|
|---|
| 422 | r'(?P<header>[^]]+)' # very permissive!
|
|---|
| 423 | r'\]' # ]
|
|---|
| 424 | )
|
|---|
| 425 | OPTCRE = re.compile(
|
|---|
| 426 | r'(?P<option>[^:=\s][^:=]*)' # very permissive!
|
|---|
| 427 | r'\s*(?P<vi>[:=])\s*' # any number of space/tab,
|
|---|
| 428 | # followed by separator
|
|---|
| 429 | # (either : or =), followed
|
|---|
| 430 | # by any # space/tab
|
|---|
| 431 | r'(?P<value>.*)$' # everything up to eol
|
|---|
| 432 | )
|
|---|
| 433 |
|
|---|
| 434 | def _read(self, fp, fpname):
|
|---|
| 435 | """Parse a sectioned setup file.
|
|---|
| 436 |
|
|---|
| 437 | The sections in setup file contains a title line at the top,
|
|---|
| 438 | indicated by a name in square brackets (`[]'), plus key/value
|
|---|
| 439 | options lines, indicated by `name: value' format lines.
|
|---|
| 440 | Continuations are represented by an embedded newline then
|
|---|
| 441 | leading whitespace. Blank lines, lines beginning with a '#',
|
|---|
| 442 | and just about everything else are ignored.
|
|---|
| 443 | """
|
|---|
| 444 | cursect = None # None, or a dictionary
|
|---|
| 445 | optname = None
|
|---|
| 446 | lineno = 0
|
|---|
| 447 | e = None # None, or an exception
|
|---|
| 448 | while True:
|
|---|
| 449 | line = fp.readline()
|
|---|
| 450 | if not line:
|
|---|
| 451 | break
|
|---|
| 452 | lineno = lineno + 1
|
|---|
| 453 | # comment or blank line?
|
|---|
| 454 | if line.strip() == '' or line[0] in '#;':
|
|---|
| 455 | continue
|
|---|
| 456 | if line.split(None, 1)[0].lower() == 'rem' and line[0] in "rR":
|
|---|
| 457 | # no leading whitespace
|
|---|
| 458 | continue
|
|---|
| 459 | # continuation line?
|
|---|
| 460 | if line[0].isspace() and cursect is not None and optname:
|
|---|
| 461 | value = line.strip()
|
|---|
| 462 | if value:
|
|---|
| 463 | cursect[optname] = "%s\n%s" % (cursect[optname], value)
|
|---|
| 464 | # a section header or option header?
|
|---|
| 465 | else:
|
|---|
| 466 | # is it a section header?
|
|---|
| 467 | mo = self.SECTCRE.match(line)
|
|---|
| 468 | if mo:
|
|---|
| 469 | sectname = mo.group('header')
|
|---|
| 470 | if sectname in self._sections:
|
|---|
| 471 | cursect = self._sections[sectname]
|
|---|
| 472 | elif sectname == DEFAULTSECT:
|
|---|
| 473 | cursect = self._defaults
|
|---|
| 474 | else:
|
|---|
| 475 | cursect = self._dict()
|
|---|
| 476 | cursect['__name__'] = sectname
|
|---|
| 477 | self._sections[sectname] = cursect
|
|---|
| 478 | # So sections can't start with a continuation line
|
|---|
| 479 | optname = None
|
|---|
| 480 | # no section header in the file?
|
|---|
| 481 | elif cursect is None:
|
|---|
| 482 | raise MissingSectionHeaderError(fpname, lineno, line)
|
|---|
| 483 | # an option line?
|
|---|
| 484 | else:
|
|---|
| 485 | mo = self.OPTCRE.match(line)
|
|---|
| 486 | if mo:
|
|---|
| 487 | optname, vi, optval = mo.group('option', 'vi', 'value')
|
|---|
| 488 | if vi in ('=', ':') and ';' in optval:
|
|---|
| 489 | # ';' is a comment delimiter only if it follows
|
|---|
| 490 | # a spacing character
|
|---|
| 491 | pos = optval.find(';')
|
|---|
| 492 | if pos != -1 and optval[pos-1].isspace():
|
|---|
| 493 | optval = optval[:pos]
|
|---|
| 494 | optval = optval.strip()
|
|---|
| 495 | # allow empty values
|
|---|
| 496 | if optval == '""':
|
|---|
| 497 | optval = ''
|
|---|
| 498 | optname = self.optionxform(optname.rstrip())
|
|---|
| 499 | cursect[optname] = optval
|
|---|
| 500 | else:
|
|---|
| 501 | # a non-fatal parsing error occurred. set up the
|
|---|
| 502 | # exception but keep going. the exception will be
|
|---|
| 503 | # raised at the end of the file and will contain a
|
|---|
| 504 | # list of all bogus lines
|
|---|
| 505 | if not e:
|
|---|
| 506 | e = ParsingError(fpname)
|
|---|
| 507 | e.append(lineno, repr(line))
|
|---|
| 508 | # if any parsing errors occurred, raise an exception
|
|---|
| 509 | if e:
|
|---|
| 510 | raise e
|
|---|
| 511 |
|
|---|
| 512 |
|
|---|
| 513 | class ConfigParser(RawConfigParser):
|
|---|
| 514 |
|
|---|
| 515 | def get(self, section, option, raw=False, vars=None):
|
|---|
| 516 | """Get an option value for a given section.
|
|---|
| 517 |
|
|---|
| 518 | All % interpolations are expanded in the return values, based on the
|
|---|
| 519 | defaults passed into the constructor, unless the optional argument
|
|---|
| 520 | `raw' is true. Additional substitutions may be provided using the
|
|---|
| 521 | `vars' argument, which must be a dictionary whose contents overrides
|
|---|
| 522 | any pre-existing defaults.
|
|---|
| 523 |
|
|---|
| 524 | The section DEFAULT is special.
|
|---|
| 525 | """
|
|---|
| 526 | d = self._defaults.copy()
|
|---|
| 527 | try:
|
|---|
| 528 | d.update(self._sections[section])
|
|---|
| 529 | except KeyError:
|
|---|
| 530 | if section != DEFAULTSECT:
|
|---|
| 531 | raise NoSectionError(section)
|
|---|
| 532 | # Update with the entry specific variables
|
|---|
| 533 | if vars:
|
|---|
| 534 | for key, value in vars.items():
|
|---|
| 535 | d[self.optionxform(key)] = value
|
|---|
| 536 | option = self.optionxform(option)
|
|---|
| 537 | try:
|
|---|
| 538 | value = d[option]
|
|---|
| 539 | except KeyError:
|
|---|
| 540 | raise NoOptionError(option, section)
|
|---|
| 541 |
|
|---|
| 542 | if raw:
|
|---|
| 543 | return value
|
|---|
| 544 | else:
|
|---|
| 545 | return self._interpolate(section, option, value, d)
|
|---|
| 546 |
|
|---|
| 547 | def items(self, section, raw=False, vars=None):
|
|---|
| 548 | """Return a list of tuples with (name, value) for each option
|
|---|
| 549 | in the section.
|
|---|
| 550 |
|
|---|
| 551 | All % interpolations are expanded in the return values, based on the
|
|---|
| 552 | defaults passed into the constructor, unless the optional argument
|
|---|
| 553 | `raw' is true. Additional substitutions may be provided using the
|
|---|
| 554 | `vars' argument, which must be a dictionary whose contents overrides
|
|---|
| 555 | any pre-existing defaults.
|
|---|
| 556 |
|
|---|
| 557 | The section DEFAULT is special.
|
|---|
| 558 | """
|
|---|
| 559 | d = self._defaults.copy()
|
|---|
| 560 | try:
|
|---|
| 561 | d.update(self._sections[section])
|
|---|
| 562 | except KeyError:
|
|---|
| 563 | if section != DEFAULTSECT:
|
|---|
| 564 | raise NoSectionError(section)
|
|---|
| 565 | # Update with the entry specific variables
|
|---|
| 566 | if vars:
|
|---|
| 567 | for key, value in vars.items():
|
|---|
| 568 | d[self.optionxform(key)] = value
|
|---|
| 569 | options = d.keys()
|
|---|
| 570 | if "__name__" in options:
|
|---|
| 571 | options.remove("__name__")
|
|---|
| 572 | if raw:
|
|---|
| 573 | return [(option, d[option])
|
|---|
| 574 | for option in options]
|
|---|
| 575 | else:
|
|---|
| 576 | return [(option, self._interpolate(section, option, d[option], d))
|
|---|
| 577 | for option in options]
|
|---|
| 578 |
|
|---|
| 579 | def _interpolate(self, section, option, rawval, vars):
|
|---|
| 580 | # do the string interpolation
|
|---|
| 581 | value = rawval
|
|---|
| 582 | depth = MAX_INTERPOLATION_DEPTH
|
|---|
| 583 | while depth: # Loop through this until it's done
|
|---|
| 584 | depth -= 1
|
|---|
| 585 | if "%(" in value:
|
|---|
| 586 | value = self._KEYCRE.sub(self._interpolation_replace, value)
|
|---|
| 587 | try:
|
|---|
| 588 | value = value % vars
|
|---|
| 589 | except KeyError, e:
|
|---|
| 590 | raise InterpolationMissingOptionError(
|
|---|
| 591 | option, section, rawval, e.args[0])
|
|---|
| 592 | else:
|
|---|
| 593 | break
|
|---|
| 594 | if "%(" in value:
|
|---|
| 595 | raise InterpolationDepthError(option, section, rawval)
|
|---|
| 596 | return value
|
|---|
| 597 |
|
|---|
| 598 | _KEYCRE = re.compile(r"%\(([^)]*)\)s|.")
|
|---|
| 599 |
|
|---|
| 600 | def _interpolation_replace(self, match):
|
|---|
| 601 | s = match.group(1)
|
|---|
| 602 | if s is None:
|
|---|
| 603 | return match.group()
|
|---|
| 604 | else:
|
|---|
| 605 | return "%%(%s)s" % self.optionxform(s)
|
|---|
| 606 |
|
|---|
| 607 |
|
|---|
| 608 | class SafeConfigParser(ConfigParser):
|
|---|
| 609 |
|
|---|
| 610 | def _interpolate(self, section, option, rawval, vars):
|
|---|
| 611 | # do the string interpolation
|
|---|
| 612 | L = []
|
|---|
| 613 | self._interpolate_some(option, L, rawval, section, vars, 1)
|
|---|
| 614 | return ''.join(L)
|
|---|
| 615 |
|
|---|
| 616 | _interpvar_re = re.compile(r"%\(([^)]+)\)s")
|
|---|
| 617 |
|
|---|
| 618 | def _interpolate_some(self, option, accum, rest, section, map, depth):
|
|---|
| 619 | if depth > MAX_INTERPOLATION_DEPTH:
|
|---|
| 620 | raise InterpolationDepthError(option, section, rest)
|
|---|
| 621 | while rest:
|
|---|
| 622 | p = rest.find("%")
|
|---|
| 623 | if p < 0:
|
|---|
| 624 | accum.append(rest)
|
|---|
| 625 | return
|
|---|
| 626 | if p > 0:
|
|---|
| 627 | accum.append(rest[:p])
|
|---|
| 628 | rest = rest[p:]
|
|---|
| 629 | # p is no longer used
|
|---|
| 630 | c = rest[1:2]
|
|---|
| 631 | if c == "%":
|
|---|
| 632 | accum.append("%")
|
|---|
| 633 | rest = rest[2:]
|
|---|
| 634 | elif c == "(":
|
|---|
| 635 | m = self._interpvar_re.match(rest)
|
|---|
| 636 | if m is None:
|
|---|
| 637 | raise InterpolationSyntaxError(option, section,
|
|---|
| 638 | "bad interpolation variable reference %r" % rest)
|
|---|
| 639 | var = self.optionxform(m.group(1))
|
|---|
| 640 | rest = rest[m.end():]
|
|---|
| 641 | try:
|
|---|
| 642 | v = map[var]
|
|---|
| 643 | except KeyError:
|
|---|
| 644 | raise InterpolationMissingOptionError(
|
|---|
| 645 | option, section, rest, var)
|
|---|
| 646 | if "%" in v:
|
|---|
| 647 | self._interpolate_some(option, accum, v,
|
|---|
| 648 | section, map, depth + 1)
|
|---|
| 649 | else:
|
|---|
| 650 | accum.append(v)
|
|---|
| 651 | else:
|
|---|
| 652 | raise InterpolationSyntaxError(
|
|---|
| 653 | option, section,
|
|---|
| 654 | "'%%' must be followed by '%%' or '(', found: %r" % (rest,))
|
|---|
| 655 |
|
|---|
| 656 | def set(self, section, option, value):
|
|---|
| 657 | """Set an option. Extend ConfigParser.set: check for string values."""
|
|---|
| 658 | if not isinstance(value, basestring):
|
|---|
| 659 | raise TypeError("option values must be strings")
|
|---|
| 660 | # check for bad percent signs:
|
|---|
| 661 | # first, replace all "good" interpolations
|
|---|
| 662 | tmp_value = value.replace('%%', '')
|
|---|
| 663 | tmp_value = self._interpvar_re.sub('', tmp_value)
|
|---|
| 664 | # then, check if there's a lone percent sign left
|
|---|
| 665 | percent_index = tmp_value.find('%')
|
|---|
| 666 | if percent_index != -1:
|
|---|
| 667 | raise ValueError("invalid interpolation syntax in %r at "
|
|---|
| 668 | "position %d" % (value, percent_index))
|
|---|
| 669 | ConfigParser.set(self, section, option, value)
|
|---|
