Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 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 |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 5 | the style of RFC 822. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 6 | |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 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 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 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 for parsing a list of |
| 23 | configuration files, and managing the parsed database. |
| 24 | |
| 25 | methods: |
| 26 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 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 | it's value is the section's name. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 32 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 33 | sections() |
| 34 | return all the configuration section names, sans DEFAULT |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 35 | |
Guido van Rossum | a5a24b7 | 1999-10-04 19:58:22 +0000 | [diff] [blame] | 36 | has_section(section) |
| 37 | return whether the given section exists |
| 38 | |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 39 | has_option(section, option) |
| 40 | return whether the given option exists in the given section |
| 41 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 42 | options(section) |
| 43 | return list of configuration options for the named section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 44 | |
Guido van Rossum | a5a24b7 | 1999-10-04 19:58:22 +0000 | [diff] [blame] | 45 | has_option(section, option) |
| 46 | return whether the given section has the given option |
| 47 | |
Guido van Rossum | c0780ac | 1999-01-30 04:35:47 +0000 | [diff] [blame] | 48 | read(filenames) |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 49 | read and parse the list of named configuration files, given by |
| 50 | name. A single filename is also allowed. Non-existing files |
| 51 | are ignored. |
| 52 | |
| 53 | readfp(fp, filename=None) |
| 54 | read and parse one configuration file, given as a file object. |
| 55 | The filename defaults to fp.name; it is only used in error |
Barry Warsaw | 2539451 | 1999-10-12 16:12:48 +0000 | [diff] [blame] | 56 | messages (if fp has no `name' attribute, the string `<???>' is used). |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 57 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 58 | get(section, option, raw=0, vars=None) |
| 59 | return a string value for the named option. All % interpolations are |
| 60 | expanded in the return values, based on the defaults passed into the |
| 61 | constructor and the DEFAULT section. Additional substitutions may be |
| 62 | provided using the `vars' argument, which must be a dictionary whose |
| 63 | contents override any pre-existing defaults. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 64 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 65 | getint(section, options) |
| 66 | like get(), but convert value to an integer |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 67 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 68 | getfloat(section, options) |
| 69 | like get(), but convert value to a float |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 70 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 71 | getboolean(section, options) |
| 72 | like get(), but convert value to a boolean (currently defined as 0 or |
| 73 | 1, only) |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 74 | |
| 75 | remove_section(section) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 76 | remove the given file section and all its options |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 77 | |
| 78 | remove_option(section, option) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 79 | remove the given option from the given section |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 80 | |
| 81 | set(section, option, value) |
| 82 | set the given option |
| 83 | |
| 84 | write(fp) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 85 | write the configuration state in .ini format |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 86 | """ |
| 87 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 88 | import string |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 89 | import re |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 90 | |
Skip Montanaro | e99d5ea | 2001-01-20 19:54:20 +0000 | [diff] [blame] | 91 | __all__ = ["NoSectionError","DuplicateSectionError","NoOptionError", |
| 92 | "InterpolationError","InterpolationDepthError","ParsingError", |
| 93 | "MissingSectionHeaderError","ConfigParser", |
| 94 | "MAX_INTERPOLATION_DEPTH"] |
| 95 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 96 | DEFAULTSECT = "DEFAULT" |
| 97 | |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 98 | MAX_INTERPOLATION_DEPTH = 10 |
| 99 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 100 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 101 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 102 | # exception classes |
Fred Drake | 7c1e5ad | 2000-12-11 18:13:19 +0000 | [diff] [blame] | 103 | class Error(Exception): |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 104 | def __init__(self, msg=''): |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 105 | self._msg = msg |
Fred Drake | 7c1e5ad | 2000-12-11 18:13:19 +0000 | [diff] [blame] | 106 | Exception.__init__(self, msg) |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 107 | def __repr__(self): |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 108 | return self._msg |
Fred Drake | 7c1e5ad | 2000-12-11 18:13:19 +0000 | [diff] [blame] | 109 | __str__ = __repr__ |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 110 | |
| 111 | class NoSectionError(Error): |
| 112 | def __init__(self, section): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 113 | Error.__init__(self, 'No section: %s' % section) |
| 114 | self.section = section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 115 | |
| 116 | class DuplicateSectionError(Error): |
| 117 | def __init__(self, section): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 118 | Error.__init__(self, "Section %s already exists" % section) |
| 119 | self.section = section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 120 | |
| 121 | class NoOptionError(Error): |
| 122 | def __init__(self, option, section): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 123 | Error.__init__(self, "No option `%s' in section: %s" % |
| 124 | (option, section)) |
| 125 | self.option = option |
| 126 | self.section = section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 127 | |
| 128 | class InterpolationError(Error): |
Barry Warsaw | 6446212 | 1998-08-06 18:48:41 +0000 | [diff] [blame] | 129 | def __init__(self, reference, option, section, rawval): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 130 | Error.__init__(self, |
Barry Warsaw | 6446212 | 1998-08-06 18:48:41 +0000 | [diff] [blame] | 131 | "Bad value substitution:\n" |
| 132 | "\tsection: [%s]\n" |
| 133 | "\toption : %s\n" |
| 134 | "\tkey : %s\n" |
| 135 | "\trawval : %s\n" |
| 136 | % (section, option, reference, rawval)) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 137 | self.reference = reference |
| 138 | self.option = option |
| 139 | self.section = section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 140 | |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 141 | class InterpolationDepthError(Error): |
| 142 | def __init__(self, option, section, rawval): |
| 143 | Error.__init__(self, |
| 144 | "Value interpolation too deeply recursive:\n" |
| 145 | "\tsection: [%s]\n" |
| 146 | "\toption : %s\n" |
| 147 | "\trawval : %s\n" |
| 148 | % (section, option, rawval)) |
| 149 | self.option = option |
| 150 | self.section = section |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 151 | |
| 152 | class ParsingError(Error): |
| 153 | def __init__(self, filename): |
| 154 | Error.__init__(self, 'File contains parsing errors: %s' % filename) |
| 155 | self.filename = filename |
| 156 | self.errors = [] |
| 157 | |
| 158 | def append(self, lineno, line): |
| 159 | self.errors.append((lineno, line)) |
| 160 | self._msg = self._msg + '\n\t[line %2d]: %s' % (lineno, line) |
| 161 | |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 162 | class MissingSectionHeaderError(ParsingError): |
| 163 | def __init__(self, filename, lineno, line): |
| 164 | Error.__init__( |
| 165 | self, |
| 166 | 'File contains no section headers.\nfile: %s, line: %d\n%s' % |
| 167 | (filename, lineno, line)) |
| 168 | self.filename = filename |
| 169 | self.lineno = lineno |
| 170 | self.line = line |
| 171 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 172 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 173 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 174 | class ConfigParser: |
| 175 | def __init__(self, defaults=None): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 176 | self.__sections = {} |
| 177 | if defaults is None: |
| 178 | self.__defaults = {} |
| 179 | else: |
| 180 | self.__defaults = defaults |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 181 | |
| 182 | def defaults(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 183 | return self.__defaults |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 184 | |
| 185 | def sections(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 186 | """Return a list of section names, excluding [DEFAULT]""" |
| 187 | # self.__sections will never have [DEFAULT] in it |
| 188 | return self.__sections.keys() |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 189 | |
| 190 | def add_section(self, section): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 191 | """Create a new section in the configuration. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 192 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 193 | Raise DuplicateSectionError if a section by the specified name |
| 194 | already exists. |
| 195 | """ |
| 196 | if self.__sections.has_key(section): |
| 197 | raise DuplicateSectionError(section) |
| 198 | self.__sections[section] = {} |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 199 | |
| 200 | def has_section(self, section): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 201 | """Indicate whether the named section is present in the configuration. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 202 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 203 | The DEFAULT section is not acknowledged. |
| 204 | """ |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 205 | return section in self.sections() |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 206 | |
| 207 | def options(self, section): |
Guido van Rossum | a5a24b7 | 1999-10-04 19:58:22 +0000 | [diff] [blame] | 208 | """Return a list of option names for the given section name.""" |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 209 | try: |
| 210 | opts = self.__sections[section].copy() |
| 211 | except KeyError: |
| 212 | raise NoSectionError(section) |
| 213 | opts.update(self.__defaults) |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 214 | if opts.has_key('__name__'): |
| 215 | del opts['__name__'] |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 216 | return opts.keys() |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 217 | |
Guido van Rossum | a5a24b7 | 1999-10-04 19:58:22 +0000 | [diff] [blame] | 218 | def has_option(self, section, option): |
| 219 | """Return whether the given section has the given option.""" |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 220 | return option in self.options(section) |
Guido van Rossum | a5a24b7 | 1999-10-04 19:58:22 +0000 | [diff] [blame] | 221 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 222 | def read(self, filenames): |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 223 | """Read and parse a filename or a list of filenames. |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 224 | |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 225 | Files that cannot be opened are silently ignored; this is |
Barry Warsaw | 2539451 | 1999-10-12 16:12:48 +0000 | [diff] [blame] | 226 | designed so that you can specify a list of potential |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 227 | configuration file locations (e.g. current directory, user's |
| 228 | home directory, systemwide directory), and all existing |
| 229 | configuration files in the list will be read. A single |
| 230 | filename may also be given. |
| 231 | """ |
Fred Drake | fd4114e | 2000-05-09 14:46:40 +0000 | [diff] [blame] | 232 | if type(filenames) in [type(''), type(u'')]: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 233 | filenames = [filenames] |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 234 | for filename in filenames: |
| 235 | try: |
| 236 | fp = open(filename) |
| 237 | except IOError: |
| 238 | continue |
| 239 | self.__read(fp, filename) |
Fred Drake | 2438a48 | 1999-10-04 18:11:56 +0000 | [diff] [blame] | 240 | fp.close() |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 241 | |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 242 | def readfp(self, fp, filename=None): |
| 243 | """Like read() but the argument must be a file-like object. |
| 244 | |
| 245 | The `fp' argument must have a `readline' method. Optional |
| 246 | second argument is the `filename', which if not given, is |
| 247 | taken from fp.name. If fp has no `name' attribute, `<???>' is |
| 248 | used. |
| 249 | |
| 250 | """ |
| 251 | if filename is None: |
| 252 | try: |
| 253 | filename = fp.name |
| 254 | except AttributeError: |
| 255 | filename = '<???>' |
| 256 | self.__read(fp, filename) |
| 257 | |
Guido van Rossum | e6506e7 | 1999-01-26 19:29:25 +0000 | [diff] [blame] | 258 | def get(self, section, option, raw=0, vars=None): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 259 | """Get an option value for a given section. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 260 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 261 | All % interpolations are expanded in the return values, based on the |
| 262 | defaults passed into the constructor, unless the optional argument |
| 263 | `raw' is true. Additional substitutions may be provided using the |
| 264 | `vars' argument, which must be a dictionary whose contents overrides |
| 265 | any pre-existing defaults. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 266 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 267 | The section DEFAULT is special. |
| 268 | """ |
| 269 | try: |
| 270 | sectdict = self.__sections[section].copy() |
| 271 | except KeyError: |
| 272 | if section == DEFAULTSECT: |
| 273 | sectdict = {} |
| 274 | else: |
| 275 | raise NoSectionError(section) |
| 276 | d = self.__defaults.copy() |
| 277 | d.update(sectdict) |
Guido van Rossum | e6506e7 | 1999-01-26 19:29:25 +0000 | [diff] [blame] | 278 | # Update with the entry specific variables |
| 279 | if vars: |
| 280 | d.update(vars) |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 281 | option = self.optionxform(option) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 282 | try: |
| 283 | rawval = d[option] |
| 284 | except KeyError: |
| 285 | raise NoOptionError(option, section) |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 286 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 287 | if raw: |
| 288 | return rawval |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 289 | |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 290 | # do the string interpolation |
Guido van Rossum | e6506e7 | 1999-01-26 19:29:25 +0000 | [diff] [blame] | 291 | value = rawval # Make it a pretty variable name |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 292 | depth = 0 |
Guido van Rossum | 72ce858 | 1999-02-12 14:13:10 +0000 | [diff] [blame] | 293 | while depth < 10: # Loop through this until it's done |
| 294 | depth = depth + 1 |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 295 | if value.find("%(") >= 0: |
Guido van Rossum | e6506e7 | 1999-01-26 19:29:25 +0000 | [diff] [blame] | 296 | try: |
| 297 | value = value % d |
| 298 | except KeyError, key: |
| 299 | raise InterpolationError(key, option, section, rawval) |
| 300 | else: |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 301 | break |
| 302 | if value.find("%(") >= 0: |
| 303 | raise InterpolationDepthError(option, section, rawval) |
| 304 | return value |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 305 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 306 | def __get(self, section, conv, option): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 307 | return conv(self.get(section, option)) |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 308 | |
| 309 | def getint(self, section, option): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 310 | return self.__get(section, string.atoi, option) |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 311 | |
| 312 | def getfloat(self, section, option): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 313 | return self.__get(section, string.atof, option) |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 314 | |
| 315 | def getboolean(self, section, option): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 316 | v = self.get(section, option) |
Eric S. Raymond | f296019 | 2001-02-09 05:37:25 +0000 | [diff] [blame] | 317 | val = int(v) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 318 | if val not in (0, 1): |
| 319 | raise ValueError, 'Not a boolean: %s' % v |
| 320 | return val |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 321 | |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 322 | def optionxform(self, optionstr): |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 323 | return optionstr.lower() |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 324 | |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 325 | def has_option(self, section, option): |
| 326 | """Check for the existence of a given option in a given section.""" |
| 327 | if not section or section == "DEFAULT": |
| 328 | return self.__defaults.has_key(option) |
| 329 | elif not self.has_section(section): |
| 330 | return 0 |
| 331 | else: |
Fred Drake | 3c823aa | 2001-02-26 21:55:34 +0000 | [diff] [blame] | 332 | option = self.optionxform(option) |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 333 | return self.__sections[section].has_key(option) |
| 334 | |
| 335 | def set(self, section, option, value): |
| 336 | """Set an option.""" |
| 337 | if not section or section == "DEFAULT": |
| 338 | sectdict = self.__defaults |
| 339 | else: |
| 340 | try: |
| 341 | sectdict = self.__sections[section] |
| 342 | except KeyError: |
| 343 | raise NoSectionError(section) |
Fred Drake | 3c823aa | 2001-02-26 21:55:34 +0000 | [diff] [blame] | 344 | option = self.optionxform(option) |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 345 | sectdict[option] = value |
| 346 | |
| 347 | def write(self, fp): |
| 348 | """Write an .ini-format representation of the configuration state.""" |
| 349 | if self.__defaults: |
| 350 | fp.write("[DEFAULT]\n") |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 351 | for (key, value) in self.__defaults.items(): |
| 352 | fp.write("%s = %s\n" % (key, value)) |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 353 | fp.write("\n") |
| 354 | for section in self.sections(): |
| 355 | fp.write("[" + section + "]\n") |
| 356 | sectdict = self.__sections[section] |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 357 | for (key, value) in sectdict.items(): |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 358 | if key == "__name__": |
| 359 | continue |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 360 | fp.write("%s = %s\n" % (key, value)) |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 361 | fp.write("\n") |
| 362 | |
Thomas Wouters | ff4df6d | 2000-07-21 05:19:59 +0000 | [diff] [blame] | 363 | def remove_option(self, section, option): |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 364 | """Remove an option.""" |
| 365 | if not section or section == "DEFAULT": |
| 366 | sectdict = self.__defaults |
| 367 | else: |
| 368 | try: |
| 369 | sectdict = self.__sections[section] |
| 370 | except KeyError: |
| 371 | raise NoSectionError(section) |
Fred Drake | 3c823aa | 2001-02-26 21:55:34 +0000 | [diff] [blame] | 372 | option = self.optionxform(option) |
Fred Drake | ff4a23b | 2000-12-04 16:29:13 +0000 | [diff] [blame] | 373 | existed = sectdict.has_key(option) |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 374 | if existed: |
Fred Drake | ff4a23b | 2000-12-04 16:29:13 +0000 | [diff] [blame] | 375 | del sectdict[option] |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 376 | return existed |
| 377 | |
Thomas Wouters | ff4df6d | 2000-07-21 05:19:59 +0000 | [diff] [blame] | 378 | def remove_section(self, section): |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 379 | """Remove a file section.""" |
| 380 | if self.__sections.has_key(section): |
| 381 | del self.__sections[section] |
| 382 | return 1 |
| 383 | else: |
| 384 | return 0 |
| 385 | |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 386 | # |
| 387 | # Regular expressions for parsing section headers and options. Note a |
| 388 | # slight semantic change from the previous version, because of the use |
| 389 | # of \w, _ is allowed in section header names. |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 390 | SECTCRE = re.compile( |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 391 | r'\[' # [ |
Fred Drake | d4df94b | 2001-02-14 15:24:17 +0000 | [diff] [blame] | 392 | r'(?P<header>[^]]+)' # very permissive! |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 393 | r'\]' # ] |
| 394 | ) |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 395 | OPTCRE = re.compile( |
Fred Drake | d83bbbf | 2001-02-12 17:18:11 +0000 | [diff] [blame] | 396 | r'(?P<option>[]\-[\w_.*,(){}]+)' # a lot of stuff found by IvL |
Fred Drake | c517b9b | 2000-02-28 20:59:03 +0000 | [diff] [blame] | 397 | r'[ \t]*(?P<vi>[:=])[ \t]*' # any number of space/tab, |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 398 | # followed by separator |
| 399 | # (either : or =), followed |
| 400 | # by any # space/tab |
| 401 | r'(?P<value>.*)$' # everything up to eol |
| 402 | ) |
| 403 | |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 404 | def __read(self, fp, fpname): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 405 | """Parse a sectioned setup file. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 406 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 407 | The sections in setup file contains a title line at the top, |
| 408 | indicated by a name in square brackets (`[]'), plus key/value |
| 409 | options lines, indicated by `name: value' format lines. |
| 410 | Continuation are represented by an embedded newline then |
| 411 | leading whitespace. Blank lines, lines beginning with a '#', |
| 412 | and just about everything else is ignored. |
| 413 | """ |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 414 | cursect = None # None, or a dictionary |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 415 | optname = None |
| 416 | lineno = 0 |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 417 | e = None # None, or an exception |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 418 | while 1: |
| 419 | line = fp.readline() |
| 420 | if not line: |
| 421 | break |
| 422 | lineno = lineno + 1 |
| 423 | # comment or blank line? |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 424 | if line.strip() == '' or line[0] in '#;': |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 425 | continue |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 426 | if line.split()[0].lower() == 'rem' \ |
Fred Drake | c517b9b | 2000-02-28 20:59:03 +0000 | [diff] [blame] | 427 | and line[0] in "rR": # no leading whitespace |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 428 | continue |
| 429 | # continuation line? |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 430 | if line[0] in ' \t' and cursect is not None and optname: |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 431 | value = line.strip() |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 432 | if value: |
Fred Drake | beb6713 | 2001-07-06 17:22:48 +0000 | [diff] [blame] | 433 | k = self.optionxform(optname) |
| 434 | cursect[k] = "%s\n%s" % (cursect[k], value) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 435 | # a section header or option header? |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 436 | else: |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 437 | # is it a section header? |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 438 | mo = self.SECTCRE.match(line) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 439 | if mo: |
| 440 | sectname = mo.group('header') |
| 441 | if self.__sections.has_key(sectname): |
| 442 | cursect = self.__sections[sectname] |
| 443 | elif sectname == DEFAULTSECT: |
| 444 | cursect = self.__defaults |
| 445 | else: |
Barry Warsaw | 6446212 | 1998-08-06 18:48:41 +0000 | [diff] [blame] | 446 | cursect = {'__name__': sectname} |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 447 | self.__sections[sectname] = cursect |
| 448 | # So sections can't start with a continuation line |
| 449 | optname = None |
| 450 | # no section header in the file? |
| 451 | elif cursect is None: |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 452 | raise MissingSectionHeaderError(fpname, lineno, `line`) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 453 | # an option line? |
| 454 | else: |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 455 | mo = self.OPTCRE.match(line) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 456 | if mo: |
Fred Drake | c517b9b | 2000-02-28 20:59:03 +0000 | [diff] [blame] | 457 | optname, vi, optval = mo.group('option', 'vi', 'value') |
Jeremy Hylton | 820314e | 2000-03-03 20:43:57 +0000 | [diff] [blame] | 458 | if vi in ('=', ':') and ';' in optval: |
Fred Drake | c517b9b | 2000-02-28 20:59:03 +0000 | [diff] [blame] | 459 | # ';' is a comment delimiter only if it follows |
| 460 | # a spacing character |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 461 | pos = optval.find(';') |
Fred Drake | c517b9b | 2000-02-28 20:59:03 +0000 | [diff] [blame] | 462 | if pos and optval[pos-1] in string.whitespace: |
| 463 | optval = optval[:pos] |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 464 | optval = optval.strip() |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 465 | # allow empty values |
| 466 | if optval == '""': |
| 467 | optval = '' |
Guido van Rossum | 4126736 | 2000-09-25 14:42:33 +0000 | [diff] [blame] | 468 | cursect[self.optionxform(optname)] = optval |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 469 | else: |
| 470 | # a non-fatal parsing error occurred. set up the |
| 471 | # exception but keep going. the exception will be |
| 472 | # raised at the end of the file and will contain a |
| 473 | # list of all bogus lines |
| 474 | if not e: |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 475 | e = ParsingError(fpname) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 476 | e.append(lineno, `line`) |
| 477 | # if any parsing errors occurred, raise an exception |
| 478 | if e: |
| 479 | raise e |