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 | |
Walter Dörwald | f0dfc7a | 2003-10-20 14:01:56 +0000 | [diff] [blame] | 22 | ConfigParser -- responsible for parsing a list of |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 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; |
Georg Brandl | 7eb4b7d | 2005-07-22 21:49:32 +0000 | [diff] [blame] | 31 | its 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 | c0780ac | 1999-01-30 04:35:47 +0000 | [diff] [blame] | 45 | read(filenames) |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 46 | read and parse the list of named configuration files, given by |
| 47 | name. A single filename is also allowed. Non-existing files |
Fred Drake | 8290314 | 2004-05-18 04:24:02 +0000 | [diff] [blame] | 48 | are ignored. Return list of successfully read files. |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 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 |
Barry Warsaw | 2539451 | 1999-10-12 16:12:48 +0000 | [diff] [blame] | 53 | messages (if fp has no `name' attribute, the string `<???>' is used). |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 54 | |
Neal Norwitz | f680cc4 | 2002-12-17 01:56:47 +0000 | [diff] [blame] | 55 | get(section, option, raw=False, vars=None) |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 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. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 61 | |
Barry Warsaw | f09f6a5 | 1999-01-26 22:01:37 +0000 | [diff] [blame] | 62 | getint(section, options) |
| 63 | like get(), but convert value to an integer |
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 | getfloat(section, options) |
| 66 | like get(), but convert value to a float |
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 | getboolean(section, options) |
Guido van Rossum | fb06f75 | 2001-10-04 19:58:46 +0000 | [diff] [blame] | 69 | like get(), but convert value to a boolean (currently case |
Neal Norwitz | f680cc4 | 2002-12-17 01:56:47 +0000 | [diff] [blame] | 70 | insensitively defined as 0, false, no, off for False, and 1, true, |
| 71 | yes, on for True). Returns False or True. |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 72 | |
Neal Norwitz | f680cc4 | 2002-12-17 01:56:47 +0000 | [diff] [blame] | 73 | items(section, raw=False, vars=None) |
Fred Drake | 2ca041f | 2002-09-27 15:49:56 +0000 | [diff] [blame] | 74 | return a list of tuples with (name, value) for each option |
| 75 | in the section. |
| 76 | |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 77 | remove_section(section) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 78 | remove the given file section and all its options |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 79 | |
| 80 | remove_option(section, option) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 81 | remove the given option from the given section |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 82 | |
| 83 | set(section, option, value) |
| 84 | set the given option |
| 85 | |
| 86 | write(fp) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 87 | write the configuration state in .ini format |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 88 | """ |
| 89 | |
Raymond Hettinger | e89b8e9 | 2009-03-03 05:00:37 +0000 | [diff] [blame] | 90 | try: |
| 91 | from collections import OrderedDict as _default_dict |
| 92 | except ImportError: |
| 93 | # fallback for setup.py which hasn't yet built _collections |
| 94 | _default_dict = dict |
| 95 | |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 96 | import re |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 97 | |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 98 | __all__ = ["NoSectionError", "DuplicateSectionError", "NoOptionError", |
| 99 | "InterpolationError", "InterpolationDepthError", |
| 100 | "InterpolationSyntaxError", "ParsingError", |
David Goodger | 1cbf206 | 2004-10-03 15:55:09 +0000 | [diff] [blame] | 101 | "MissingSectionHeaderError", |
| 102 | "ConfigParser", "SafeConfigParser", "RawConfigParser", |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 103 | "DEFAULTSECT", "MAX_INTERPOLATION_DEPTH"] |
Skip Montanaro | e99d5ea | 2001-01-20 19:54:20 +0000 | [diff] [blame] | 104 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 105 | DEFAULTSECT = "DEFAULT" |
| 106 | |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 107 | MAX_INTERPOLATION_DEPTH = 10 |
| 108 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 109 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 110 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 111 | # exception classes |
Fred Drake | 7c1e5ad | 2000-12-11 18:13:19 +0000 | [diff] [blame] | 112 | class Error(Exception): |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 113 | """Base class for ConfigParser exceptions.""" |
| 114 | |
Brett Cannon | 229cee2 | 2007-05-05 01:34:02 +0000 | [diff] [blame] | 115 | def _get_message(self): |
| 116 | """Getter for 'message'; needed only to override deprecation in |
| 117 | BaseException.""" |
| 118 | return self.__message |
| 119 | |
| 120 | def _set_message(self, value): |
| 121 | """Setter for 'message'; needed only to override deprecation in |
| 122 | BaseException.""" |
| 123 | self.__message = value |
| 124 | |
| 125 | # BaseException.message has been deprecated since Python 2.6. To prevent |
| 126 | # DeprecationWarning from popping up over this pre-existing attribute, use |
| 127 | # a new property that takes lookup precedence. |
| 128 | message = property(_get_message, _set_message) |
| 129 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 130 | def __init__(self, msg=''): |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 131 | self.message = msg |
Fred Drake | 7c1e5ad | 2000-12-11 18:13:19 +0000 | [diff] [blame] | 132 | Exception.__init__(self, msg) |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 133 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 134 | def __repr__(self): |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 135 | return self.message |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 136 | |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 137 | def __reduce__(self): |
| 138 | return self.__class__, (self.message,) |
| 139 | |
Fred Drake | 7c1e5ad | 2000-12-11 18:13:19 +0000 | [diff] [blame] | 140 | __str__ = __repr__ |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 141 | |
| 142 | class NoSectionError(Error): |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 143 | """Raised when no section matches a requested option.""" |
| 144 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 145 | def __init__(self, section): |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 146 | Error.__init__(self, 'No section: %r' % (section,)) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 147 | self.section = section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 148 | |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 149 | def __reduce__(self): |
| 150 | return self.__class__, (self.section,) |
| 151 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 152 | class DuplicateSectionError(Error): |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 153 | """Raised when a section is multiply-created.""" |
| 154 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 155 | def __init__(self, section): |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 156 | Error.__init__(self, "Section %r already exists" % section) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 157 | self.section = section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 158 | |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 159 | def __reduce__(self): |
| 160 | return self.__class__, (self.section,) |
| 161 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 162 | class NoOptionError(Error): |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 163 | """A requested option was not found.""" |
| 164 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 165 | def __init__(self, option, section): |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 166 | Error.__init__(self, "No option %r in section: %r" % |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 167 | (option, section)) |
| 168 | self.option = option |
| 169 | self.section = section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 170 | |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 171 | def __reduce__(self): |
| 172 | return self.__class__, (self.option, self.section) |
| 173 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 174 | class InterpolationError(Error): |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 175 | """Base class for interpolation-related exceptions.""" |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 176 | |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 177 | def __init__(self, option, section, msg): |
| 178 | Error.__init__(self, msg) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 179 | self.option = option |
| 180 | self.section = section |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 181 | |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 182 | def __reduce__(self): |
| 183 | return self.__class__, (self.option, self.section, self.message) |
| 184 | |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 185 | class InterpolationMissingOptionError(InterpolationError): |
| 186 | """A string substitution required a setting which was not available.""" |
| 187 | |
| 188 | def __init__(self, option, section, rawval, reference): |
| 189 | msg = ("Bad value substitution:\n" |
| 190 | "\tsection: [%s]\n" |
| 191 | "\toption : %s\n" |
| 192 | "\tkey : %s\n" |
| 193 | "\trawval : %s\n" |
| 194 | % (section, option, reference, rawval)) |
| 195 | InterpolationError.__init__(self, option, section, msg) |
| 196 | self.reference = reference |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 197 | self._rawval = rawval |
| 198 | |
| 199 | def __reduce__(self): |
| 200 | return self.__class__, (self.option, self.section, self._rawval, |
| 201 | self.reference) |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 202 | |
| 203 | class InterpolationSyntaxError(InterpolationError): |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 204 | """Raised when the source text into which substitutions are made |
| 205 | does not conform to the required syntax.""" |
Neal Norwitz | ce1d944 | 2002-12-30 23:38:47 +0000 | [diff] [blame] | 206 | |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 207 | class InterpolationDepthError(InterpolationError): |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 208 | """Raised when substitutions are nested too deeply.""" |
| 209 | |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 210 | def __init__(self, option, section, rawval): |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 211 | msg = ("Value interpolation too deeply recursive:\n" |
| 212 | "\tsection: [%s]\n" |
| 213 | "\toption : %s\n" |
| 214 | "\trawval : %s\n" |
| 215 | % (section, option, rawval)) |
| 216 | InterpolationError.__init__(self, option, section, msg) |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 217 | self._rawval = rawval |
| 218 | |
| 219 | def __reduce__(self): |
| 220 | return self.__class__, (self.option, self.section, self._rawval) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 221 | |
| 222 | class ParsingError(Error): |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 223 | """Raised when a configuration file does not follow legal syntax.""" |
| 224 | |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 225 | def __init__(self, filename, _errors=[]): |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 226 | Error.__init__(self, 'File contains parsing errors: %s' % filename) |
| 227 | self.filename = filename |
| 228 | self.errors = [] |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 229 | for lineno, line in _errors: |
| 230 | self.append(lineno, line) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 231 | |
| 232 | def append(self, lineno, line): |
| 233 | self.errors.append((lineno, line)) |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 234 | self.message += '\n\t[line %2d]: %s' % (lineno, line) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 235 | |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 236 | def __reduce__(self): |
| 237 | return self.__class__, (self.filename, self.errors) |
| 238 | |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 239 | class MissingSectionHeaderError(ParsingError): |
Fred Drake | 8d5dd98 | 2002-12-30 23:51:45 +0000 | [diff] [blame] | 240 | """Raised when a key-value pair is found before any section header.""" |
| 241 | |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 242 | def __init__(self, filename, lineno, line): |
| 243 | Error.__init__( |
| 244 | self, |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 245 | 'File contains no section headers.\nfile: %s, line: %d\n%r' % |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 246 | (filename, lineno, line)) |
| 247 | self.filename = filename |
| 248 | self.lineno = lineno |
| 249 | self.line = line |
| 250 | |
Łukasz Langa | 631c258 | 2012-01-20 17:02:08 +0100 | [diff] [blame^] | 251 | def __reduce__(self): |
| 252 | return self.__class__, (self.filename, self.lineno, self.line) |
| 253 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 254 | |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 255 | class RawConfigParser: |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 256 | def __init__(self, defaults=None, dict_type=_default_dict, |
| 257 | allow_no_value=False): |
Martin v. Löwis | a00bcac | 2006-12-03 12:01:53 +0000 | [diff] [blame] | 258 | self._dict = dict_type |
| 259 | self._sections = self._dict() |
| 260 | self._defaults = self._dict() |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 261 | if allow_no_value: |
| 262 | self._optcre = self.OPTCRE_NV |
| 263 | else: |
| 264 | self._optcre = self.OPTCRE |
David Goodger | 68a1abd | 2004-10-03 15:40:25 +0000 | [diff] [blame] | 265 | if defaults: |
| 266 | for key, value in defaults.items(): |
| 267 | self._defaults[self.optionxform(key)] = value |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 268 | |
| 269 | def defaults(self): |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 270 | return self._defaults |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 271 | |
| 272 | def sections(self): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 273 | """Return a list of section names, excluding [DEFAULT]""" |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 274 | # self._sections will never have [DEFAULT] in it |
| 275 | return self._sections.keys() |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 276 | |
| 277 | def add_section(self, section): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 278 | """Create a new section in the configuration. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 279 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 280 | Raise DuplicateSectionError if a section by the specified name |
Facundo Batista | b12f0b5 | 2008-02-23 12:46:10 +0000 | [diff] [blame] | 281 | already exists. Raise ValueError if name is DEFAULT or any of it's |
| 282 | case-insensitive variants. |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 283 | """ |
Facundo Batista | b12f0b5 | 2008-02-23 12:46:10 +0000 | [diff] [blame] | 284 | if section.lower() == "default": |
| 285 | raise ValueError, 'Invalid section name: %s' % section |
| 286 | |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 287 | if section in self._sections: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 288 | raise DuplicateSectionError(section) |
Martin v. Löwis | a00bcac | 2006-12-03 12:01:53 +0000 | [diff] [blame] | 289 | self._sections[section] = self._dict() |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 290 | |
| 291 | def has_section(self, section): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 292 | """Indicate whether the named section is present in the configuration. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 293 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 294 | The DEFAULT section is not acknowledged. |
| 295 | """ |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 296 | return section in self._sections |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 297 | |
| 298 | def options(self, section): |
Guido van Rossum | a5a24b7 | 1999-10-04 19:58:22 +0000 | [diff] [blame] | 299 | """Return a list of option names for the given section name.""" |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 300 | try: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 301 | opts = self._sections[section].copy() |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 302 | except KeyError: |
| 303 | raise NoSectionError(section) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 304 | opts.update(self._defaults) |
Raymond Hettinger | 54f0222 | 2002-06-01 14:18:47 +0000 | [diff] [blame] | 305 | if '__name__' in opts: |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 306 | del opts['__name__'] |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 307 | return opts.keys() |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 308 | |
| 309 | def read(self, filenames): |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 310 | """Read and parse a filename or a list of filenames. |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 311 | |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 312 | Files that cannot be opened are silently ignored; this is |
Barry Warsaw | 2539451 | 1999-10-12 16:12:48 +0000 | [diff] [blame] | 313 | designed so that you can specify a list of potential |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 314 | configuration file locations (e.g. current directory, user's |
| 315 | home directory, systemwide directory), and all existing |
| 316 | configuration files in the list will be read. A single |
| 317 | filename may also be given. |
Fred Drake | 8290314 | 2004-05-18 04:24:02 +0000 | [diff] [blame] | 318 | |
| 319 | Return list of successfully read files. |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 320 | """ |
Walter Dörwald | 65230a2 | 2002-06-03 15:58:32 +0000 | [diff] [blame] | 321 | if isinstance(filenames, basestring): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 322 | filenames = [filenames] |
Fred Drake | 8290314 | 2004-05-18 04:24:02 +0000 | [diff] [blame] | 323 | read_ok = [] |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 324 | for filename in filenames: |
| 325 | try: |
| 326 | fp = open(filename) |
| 327 | except IOError: |
| 328 | continue |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 329 | self._read(fp, filename) |
Fred Drake | 2438a48 | 1999-10-04 18:11:56 +0000 | [diff] [blame] | 330 | fp.close() |
Fred Drake | 8290314 | 2004-05-18 04:24:02 +0000 | [diff] [blame] | 331 | read_ok.append(filename) |
| 332 | return read_ok |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 333 | |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 334 | def readfp(self, fp, filename=None): |
| 335 | """Like read() but the argument must be a file-like object. |
| 336 | |
| 337 | The `fp' argument must have a `readline' method. Optional |
| 338 | second argument is the `filename', which if not given, is |
| 339 | taken from fp.name. If fp has no `name' attribute, `<???>' is |
| 340 | used. |
| 341 | |
| 342 | """ |
| 343 | if filename is None: |
| 344 | try: |
| 345 | filename = fp.name |
| 346 | except AttributeError: |
| 347 | filename = '<???>' |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 348 | self._read(fp, filename) |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 349 | |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 350 | def get(self, section, option): |
| 351 | opt = self.optionxform(option) |
| 352 | if section not in self._sections: |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 353 | if section != DEFAULTSECT: |
| 354 | raise NoSectionError(section) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 355 | if opt in self._defaults: |
| 356 | return self._defaults[opt] |
| 357 | else: |
| 358 | raise NoOptionError(option, section) |
| 359 | elif opt in self._sections[section]: |
| 360 | return self._sections[section][opt] |
| 361 | elif opt in self._defaults: |
| 362 | return self._defaults[opt] |
| 363 | else: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 364 | raise NoOptionError(option, section) |
Fred Drake | 2a37f9f | 2000-09-27 22:43:54 +0000 | [diff] [blame] | 365 | |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 366 | def items(self, section): |
Fred Drake | 2ca041f | 2002-09-27 15:49:56 +0000 | [diff] [blame] | 367 | try: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 368 | d2 = self._sections[section] |
Fred Drake | 2ca041f | 2002-09-27 15:49:56 +0000 | [diff] [blame] | 369 | except KeyError: |
| 370 | if section != DEFAULTSECT: |
| 371 | raise NoSectionError(section) |
Martin v. Löwis | a00bcac | 2006-12-03 12:01:53 +0000 | [diff] [blame] | 372 | d2 = self._dict() |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 373 | d = self._defaults.copy() |
| 374 | d.update(d2) |
Fred Drake | df393bd | 2002-10-25 20:41:30 +0000 | [diff] [blame] | 375 | if "__name__" in d: |
| 376 | del d["__name__"] |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 377 | return d.items() |
Fred Drake | 2ca041f | 2002-09-27 15:49:56 +0000 | [diff] [blame] | 378 | |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 379 | def _get(self, section, conv, option): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 380 | return conv(self.get(section, option)) |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 381 | |
| 382 | def getint(self, section, option): |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 383 | return self._get(section, int, option) |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 384 | |
| 385 | def getfloat(self, section, option): |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 386 | return self._get(section, float, option) |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 387 | |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 388 | _boolean_states = {'1': True, 'yes': True, 'true': True, 'on': True, |
| 389 | '0': False, 'no': False, 'false': False, 'off': False} |
| 390 | |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 391 | def getboolean(self, section, option): |
Tim Peters | e0c446b | 2001-10-18 21:57:37 +0000 | [diff] [blame] | 392 | v = self.get(section, option) |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 393 | if v.lower() not in self._boolean_states: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 394 | raise ValueError, 'Not a boolean: %s' % v |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 395 | return self._boolean_states[v.lower()] |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 396 | |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 397 | def optionxform(self, optionstr): |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 398 | return optionstr.lower() |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 399 | |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 400 | def has_option(self, section, option): |
| 401 | """Check for the existence of a given option in a given section.""" |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 402 | if not section or section == DEFAULTSECT: |
| 403 | option = self.optionxform(option) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 404 | return option in self._defaults |
| 405 | elif section not in self._sections: |
Neal Norwitz | f680cc4 | 2002-12-17 01:56:47 +0000 | [diff] [blame] | 406 | return False |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 407 | else: |
Fred Drake | 3c823aa | 2001-02-26 21:55:34 +0000 | [diff] [blame] | 408 | option = self.optionxform(option) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 409 | return (option in self._sections[section] |
| 410 | or option in self._defaults) |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 411 | |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 412 | def set(self, section, option, value=None): |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 413 | """Set an option.""" |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 414 | if not section or section == DEFAULTSECT: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 415 | sectdict = self._defaults |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 416 | else: |
| 417 | try: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 418 | sectdict = self._sections[section] |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 419 | except KeyError: |
| 420 | raise NoSectionError(section) |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 421 | sectdict[self.optionxform(option)] = value |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 422 | |
| 423 | def write(self, fp): |
| 424 | """Write an .ini-format representation of the configuration state.""" |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 425 | if self._defaults: |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 426 | fp.write("[%s]\n" % DEFAULTSECT) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 427 | for (key, value) in self._defaults.items(): |
Andrew M. Kuchling | 00824ed | 2002-03-08 18:08:47 +0000 | [diff] [blame] | 428 | fp.write("%s = %s\n" % (key, str(value).replace('\n', '\n\t'))) |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 429 | fp.write("\n") |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 430 | for section in self._sections: |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 431 | fp.write("[%s]\n" % section) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 432 | for (key, value) in self._sections[section].items(): |
Brian Curtin | e4334b4 | 2010-07-26 02:30:15 +0000 | [diff] [blame] | 433 | if key == "__name__": |
| 434 | continue |
Fred Drake | a1e627d | 2010-09-03 03:55:50 +0000 | [diff] [blame] | 435 | if (value is not None) or (self._optcre == self.OPTCRE): |
Brian Curtin | e4334b4 | 2010-07-26 02:30:15 +0000 | [diff] [blame] | 436 | key = " = ".join((key, str(value).replace('\n', '\n\t'))) |
| 437 | fp.write("%s\n" % (key)) |
Eric S. Raymond | 417c489 | 2000-07-10 18:11:00 +0000 | [diff] [blame] | 438 | fp.write("\n") |
| 439 | |
Thomas Wouters | ff4df6d | 2000-07-21 05:19:59 +0000 | [diff] [blame] | 440 | def remove_option(self, section, option): |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 441 | """Remove an option.""" |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 442 | if not section or section == DEFAULTSECT: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 443 | sectdict = self._defaults |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 444 | else: |
| 445 | try: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 446 | sectdict = self._sections[section] |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 447 | except KeyError: |
| 448 | raise NoSectionError(section) |
Fred Drake | 3c823aa | 2001-02-26 21:55:34 +0000 | [diff] [blame] | 449 | option = self.optionxform(option) |
Raymond Hettinger | 54f0222 | 2002-06-01 14:18:47 +0000 | [diff] [blame] | 450 | existed = option in sectdict |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 451 | if existed: |
Fred Drake | ff4a23b | 2000-12-04 16:29:13 +0000 | [diff] [blame] | 452 | del sectdict[option] |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 453 | return existed |
| 454 | |
Thomas Wouters | ff4df6d | 2000-07-21 05:19:59 +0000 | [diff] [blame] | 455 | def remove_section(self, section): |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 456 | """Remove a file section.""" |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 457 | existed = section in self._sections |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 458 | if existed: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 459 | del self._sections[section] |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 460 | return existed |
Eric S. Raymond | 649685a | 2000-07-14 14:28:22 +0000 | [diff] [blame] | 461 | |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 462 | # |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 463 | # Regular expressions for parsing section headers and options. |
| 464 | # |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 465 | SECTCRE = re.compile( |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 466 | r'\[' # [ |
Fred Drake | d4df94b | 2001-02-14 15:24:17 +0000 | [diff] [blame] | 467 | r'(?P<header>[^]]+)' # very permissive! |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 468 | r'\]' # ] |
| 469 | ) |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 470 | OPTCRE = re.compile( |
Fred Drake | 176916a | 2002-09-27 16:21:18 +0000 | [diff] [blame] | 471 | r'(?P<option>[^:=\s][^:=]*)' # very permissive! |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 472 | r'\s*(?P<vi>[:=])\s*' # any number of space/tab, |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 473 | # followed by separator |
| 474 | # (either : or =), followed |
| 475 | # by any # space/tab |
| 476 | r'(?P<value>.*)$' # everything up to eol |
| 477 | ) |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 478 | OPTCRE_NV = re.compile( |
| 479 | r'(?P<option>[^:=\s][^:=]*)' # very permissive! |
| 480 | r'\s*(?:' # any number of space/tab, |
| 481 | r'(?P<vi>[:=])\s*' # optionally followed by |
| 482 | # separator (either : or |
| 483 | # =), followed by any # |
| 484 | # space/tab |
| 485 | r'(?P<value>.*))?$' # everything up to eol |
| 486 | ) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 487 | |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 488 | def _read(self, fp, fpname): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 489 | """Parse a sectioned setup file. |
Guido van Rossum | 3d20986 | 1997-12-09 16:10:31 +0000 | [diff] [blame] | 490 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 491 | The sections in setup file contains a title line at the top, |
| 492 | indicated by a name in square brackets (`[]'), plus key/value |
| 493 | options lines, indicated by `name: value' format lines. |
Andrew M. Kuchling | 9050a51 | 2002-11-06 14:51:20 +0000 | [diff] [blame] | 494 | Continuations are represented by an embedded newline then |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 495 | leading whitespace. Blank lines, lines beginning with a '#', |
Andrew M. Kuchling | 9050a51 | 2002-11-06 14:51:20 +0000 | [diff] [blame] | 496 | and just about everything else are ignored. |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 497 | """ |
Brian Curtin | e4334b4 | 2010-07-26 02:30:15 +0000 | [diff] [blame] | 498 | cursect = None # None, or a dictionary |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 499 | optname = None |
| 500 | lineno = 0 |
Brian Curtin | e4334b4 | 2010-07-26 02:30:15 +0000 | [diff] [blame] | 501 | e = None # None, or an exception |
Neal Norwitz | f680cc4 | 2002-12-17 01:56:47 +0000 | [diff] [blame] | 502 | while True: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 503 | line = fp.readline() |
| 504 | if not line: |
| 505 | break |
| 506 | lineno = lineno + 1 |
| 507 | # comment or blank line? |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 508 | if line.strip() == '' or line[0] in '#;': |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 509 | continue |
Fred Drake | 176916a | 2002-09-27 16:21:18 +0000 | [diff] [blame] | 510 | if line.split(None, 1)[0].lower() == 'rem' and line[0] in "rR": |
| 511 | # no leading whitespace |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 512 | continue |
| 513 | # continuation line? |
Fred Drake | c2ff905 | 2002-09-27 15:33:11 +0000 | [diff] [blame] | 514 | if line[0].isspace() and cursect is not None and optname: |
Eric S. Raymond | 9eb54d9 | 2001-02-09 05:19:09 +0000 | [diff] [blame] | 515 | value = line.strip() |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 516 | if value: |
Brian Curtin | e4334b4 | 2010-07-26 02:30:15 +0000 | [diff] [blame] | 517 | cursect[optname].append(value) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 518 | # a section header or option header? |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 519 | else: |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 520 | # is it a section header? |
Guido van Rossum | 9e480ad | 1999-06-17 18:41:42 +0000 | [diff] [blame] | 521 | mo = self.SECTCRE.match(line) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 522 | if mo: |
| 523 | sectname = mo.group('header') |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 524 | if sectname in self._sections: |
| 525 | cursect = self._sections[sectname] |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 526 | elif sectname == DEFAULTSECT: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 527 | cursect = self._defaults |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 528 | else: |
Martin v. Löwis | a00bcac | 2006-12-03 12:01:53 +0000 | [diff] [blame] | 529 | cursect = self._dict() |
| 530 | cursect['__name__'] = sectname |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 531 | self._sections[sectname] = cursect |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 532 | # So sections can't start with a continuation line |
| 533 | optname = None |
| 534 | # no section header in the file? |
| 535 | elif cursect is None: |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 536 | raise MissingSectionHeaderError(fpname, lineno, line) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 537 | # an option line? |
| 538 | else: |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 539 | mo = self._optcre.match(line) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 540 | if mo: |
Fred Drake | c517b9b | 2000-02-28 20:59:03 +0000 | [diff] [blame] | 541 | optname, vi, optval = mo.group('option', 'vi', 'value') |
Brian Curtin | e4334b4 | 2010-07-26 02:30:15 +0000 | [diff] [blame] | 542 | optname = self.optionxform(optname.rstrip()) |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 543 | # This check is fine because the OPTCRE cannot |
| 544 | # match if it would set optval to None |
| 545 | if optval is not None: |
| 546 | if vi in ('=', ':') and ';' in optval: |
| 547 | # ';' is a comment delimiter only if it follows |
| 548 | # a spacing character |
| 549 | pos = optval.find(';') |
| 550 | if pos != -1 and optval[pos-1].isspace(): |
| 551 | optval = optval[:pos] |
| 552 | optval = optval.strip() |
Brian Curtin | e4334b4 | 2010-07-26 02:30:15 +0000 | [diff] [blame] | 553 | # allow empty values |
| 554 | if optval == '""': |
| 555 | optval = '' |
| 556 | cursect[optname] = [optval] |
| 557 | else: |
| 558 | # valueless option handling |
| 559 | cursect[optname] = optval |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 560 | else: |
| 561 | # a non-fatal parsing error occurred. set up the |
| 562 | # exception but keep going. the exception will be |
| 563 | # raised at the end of the file and will contain a |
| 564 | # list of all bogus lines |
| 565 | if not e: |
Guido van Rossum | 6a8d84b | 1999-10-04 18:57:27 +0000 | [diff] [blame] | 566 | e = ParsingError(fpname) |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 567 | e.append(lineno, repr(line)) |
Barry Warsaw | bfa3f6b | 1998-07-01 20:41:12 +0000 | [diff] [blame] | 568 | # if any parsing errors occurred, raise an exception |
| 569 | if e: |
| 570 | raise e |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 571 | |
Brian Curtin | e4334b4 | 2010-07-26 02:30:15 +0000 | [diff] [blame] | 572 | # join the multi-line values collected while reading |
| 573 | all_sections = [self._defaults] |
| 574 | all_sections.extend(self._sections.values()) |
| 575 | for options in all_sections: |
| 576 | for name, val in options.items(): |
| 577 | if isinstance(val, list): |
| 578 | options[name] = '\n'.join(val) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 579 | |
Raymond Hettinger | d57b4d3 | 2011-02-02 08:37:11 +0000 | [diff] [blame] | 580 | import UserDict as _UserDict |
| 581 | |
| 582 | class _Chainmap(_UserDict.DictMixin): |
| 583 | """Combine multiple mappings for successive lookups. |
| 584 | |
| 585 | For example, to emulate Python's normal lookup sequence: |
| 586 | |
| 587 | import __builtin__ |
| 588 | pylookup = _Chainmap(locals(), globals(), vars(__builtin__)) |
| 589 | """ |
| 590 | |
| 591 | def __init__(self, *maps): |
| 592 | self._maps = maps |
| 593 | |
| 594 | def __getitem__(self, key): |
| 595 | for mapping in self._maps: |
| 596 | try: |
| 597 | return mapping[key] |
| 598 | except KeyError: |
| 599 | pass |
| 600 | raise KeyError(key) |
| 601 | |
| 602 | def keys(self): |
| 603 | result = [] |
| 604 | seen = set() |
Raymond Hettinger | 3ea5224 | 2011-08-09 12:07:15 -0700 | [diff] [blame] | 605 | for mapping in self._maps: |
Raymond Hettinger | d57b4d3 | 2011-02-02 08:37:11 +0000 | [diff] [blame] | 606 | for key in mapping: |
| 607 | if key not in seen: |
| 608 | result.append(key) |
| 609 | seen.add(key) |
| 610 | return result |
| 611 | |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 612 | class ConfigParser(RawConfigParser): |
| 613 | |
Neal Norwitz | f680cc4 | 2002-12-17 01:56:47 +0000 | [diff] [blame] | 614 | def get(self, section, option, raw=False, vars=None): |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 615 | """Get an option value for a given section. |
| 616 | |
Georg Brandl | d070cc5 | 2010-08-01 21:06:46 +0000 | [diff] [blame] | 617 | If `vars' is provided, it must be a dictionary. The option is looked up |
| 618 | in `vars' (if provided), `section', and in `defaults' in that order. |
| 619 | |
| 620 | All % interpolations are expanded in the return values, unless the |
| 621 | optional argument `raw' is true. Values for interpolation keys are |
| 622 | looked up in the same manner as the option. |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 623 | |
| 624 | The section DEFAULT is special. |
| 625 | """ |
Raymond Hettinger | d57b4d3 | 2011-02-02 08:37:11 +0000 | [diff] [blame] | 626 | sectiondict = {} |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 627 | try: |
Raymond Hettinger | d57b4d3 | 2011-02-02 08:37:11 +0000 | [diff] [blame] | 628 | sectiondict = self._sections[section] |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 629 | except KeyError: |
| 630 | if section != DEFAULTSECT: |
| 631 | raise NoSectionError(section) |
| 632 | # Update with the entry specific variables |
Raymond Hettinger | d57b4d3 | 2011-02-02 08:37:11 +0000 | [diff] [blame] | 633 | vardict = {} |
David Goodger | 68a1abd | 2004-10-03 15:40:25 +0000 | [diff] [blame] | 634 | if vars: |
| 635 | for key, value in vars.items(): |
Raymond Hettinger | d57b4d3 | 2011-02-02 08:37:11 +0000 | [diff] [blame] | 636 | vardict[self.optionxform(key)] = value |
| 637 | d = _Chainmap(vardict, sectiondict, self._defaults) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 638 | option = self.optionxform(option) |
| 639 | try: |
| 640 | value = d[option] |
| 641 | except KeyError: |
| 642 | raise NoOptionError(option, section) |
| 643 | |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 644 | if raw or value is None: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 645 | return value |
| 646 | else: |
| 647 | return self._interpolate(section, option, value, d) |
| 648 | |
Neal Norwitz | f680cc4 | 2002-12-17 01:56:47 +0000 | [diff] [blame] | 649 | def items(self, section, raw=False, vars=None): |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 650 | """Return a list of tuples with (name, value) for each option |
| 651 | in the section. |
| 652 | |
| 653 | All % interpolations are expanded in the return values, based on the |
| 654 | defaults passed into the constructor, unless the optional argument |
| 655 | `raw' is true. Additional substitutions may be provided using the |
| 656 | `vars' argument, which must be a dictionary whose contents overrides |
| 657 | any pre-existing defaults. |
| 658 | |
| 659 | The section DEFAULT is special. |
| 660 | """ |
| 661 | d = self._defaults.copy() |
| 662 | try: |
| 663 | d.update(self._sections[section]) |
| 664 | except KeyError: |
| 665 | if section != DEFAULTSECT: |
| 666 | raise NoSectionError(section) |
| 667 | # Update with the entry specific variables |
| 668 | if vars: |
David Goodger | 68a1abd | 2004-10-03 15:40:25 +0000 | [diff] [blame] | 669 | for key, value in vars.items(): |
| 670 | d[self.optionxform(key)] = value |
Fred Drake | df393bd | 2002-10-25 20:41:30 +0000 | [diff] [blame] | 671 | options = d.keys() |
| 672 | if "__name__" in options: |
| 673 | options.remove("__name__") |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 674 | if raw: |
Fred Drake | 8c4da53 | 2003-10-21 16:45:00 +0000 | [diff] [blame] | 675 | return [(option, d[option]) |
| 676 | for option in options] |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 677 | else: |
Fred Drake | 8c4da53 | 2003-10-21 16:45:00 +0000 | [diff] [blame] | 678 | return [(option, self._interpolate(section, option, d[option], d)) |
| 679 | for option in options] |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 680 | |
| 681 | def _interpolate(self, section, option, rawval, vars): |
| 682 | # do the string interpolation |
| 683 | value = rawval |
Tim Peters | 230a60c | 2002-11-09 05:08:07 +0000 | [diff] [blame] | 684 | depth = MAX_INTERPOLATION_DEPTH |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 685 | while depth: # Loop through this until it's done |
| 686 | depth -= 1 |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 687 | if value and "%(" in value: |
Fred Drake | bc12b01 | 2004-05-18 02:25:51 +0000 | [diff] [blame] | 688 | value = self._KEYCRE.sub(self._interpolation_replace, value) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 689 | try: |
| 690 | value = value % vars |
Fred Drake | 00dc5a9 | 2002-12-31 06:55:41 +0000 | [diff] [blame] | 691 | except KeyError, e: |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 692 | raise InterpolationMissingOptionError( |
Brett Cannon | 97b1fb6 | 2008-08-02 03:37:50 +0000 | [diff] [blame] | 693 | option, section, rawval, e.args[0]) |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 694 | else: |
| 695 | break |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 696 | if value and "%(" in value: |
Fred Drake | fce6557 | 2002-10-25 18:08:18 +0000 | [diff] [blame] | 697 | raise InterpolationDepthError(option, section, rawval) |
| 698 | return value |
Fred Drake | 0eebd5c | 2002-10-25 21:52:00 +0000 | [diff] [blame] | 699 | |
Fred Drake | bc12b01 | 2004-05-18 02:25:51 +0000 | [diff] [blame] | 700 | _KEYCRE = re.compile(r"%\(([^)]*)\)s|.") |
| 701 | |
| 702 | def _interpolation_replace(self, match): |
| 703 | s = match.group(1) |
| 704 | if s is None: |
| 705 | return match.group() |
| 706 | else: |
| 707 | return "%%(%s)s" % self.optionxform(s) |
| 708 | |
Fred Drake | 0eebd5c | 2002-10-25 21:52:00 +0000 | [diff] [blame] | 709 | |
| 710 | class SafeConfigParser(ConfigParser): |
| 711 | |
| 712 | def _interpolate(self, section, option, rawval, vars): |
| 713 | # do the string interpolation |
| 714 | L = [] |
| 715 | self._interpolate_some(option, L, rawval, section, vars, 1) |
| 716 | return ''.join(L) |
| 717 | |
Georg Brandl | 92a6bae | 2007-03-13 17:43:32 +0000 | [diff] [blame] | 718 | _interpvar_re = re.compile(r"%\(([^)]+)\)s") |
Fred Drake | 0eebd5c | 2002-10-25 21:52:00 +0000 | [diff] [blame] | 719 | |
| 720 | def _interpolate_some(self, option, accum, rest, section, map, depth): |
| 721 | if depth > MAX_INTERPOLATION_DEPTH: |
| 722 | raise InterpolationDepthError(option, section, rest) |
| 723 | while rest: |
| 724 | p = rest.find("%") |
| 725 | if p < 0: |
| 726 | accum.append(rest) |
| 727 | return |
| 728 | if p > 0: |
| 729 | accum.append(rest[:p]) |
| 730 | rest = rest[p:] |
| 731 | # p is no longer used |
| 732 | c = rest[1:2] |
| 733 | if c == "%": |
| 734 | accum.append("%") |
| 735 | rest = rest[2:] |
| 736 | elif c == "(": |
Georg Brandl | 92a6bae | 2007-03-13 17:43:32 +0000 | [diff] [blame] | 737 | m = self._interpvar_re.match(rest) |
Fred Drake | 0eebd5c | 2002-10-25 21:52:00 +0000 | [diff] [blame] | 738 | if m is None: |
Neal Norwitz | 10f3018 | 2003-06-29 04:23:35 +0000 | [diff] [blame] | 739 | raise InterpolationSyntaxError(option, section, |
| 740 | "bad interpolation variable reference %r" % rest) |
Fred Drake | bc12b01 | 2004-05-18 02:25:51 +0000 | [diff] [blame] | 741 | var = self.optionxform(m.group(1)) |
Fred Drake | 0eebd5c | 2002-10-25 21:52:00 +0000 | [diff] [blame] | 742 | rest = rest[m.end():] |
| 743 | try: |
| 744 | v = map[var] |
| 745 | except KeyError: |
Fred Drake | e2c6491 | 2002-12-31 17:23:27 +0000 | [diff] [blame] | 746 | raise InterpolationMissingOptionError( |
| 747 | option, section, rest, var) |
Fred Drake | 0eebd5c | 2002-10-25 21:52:00 +0000 | [diff] [blame] | 748 | if "%" in v: |
| 749 | self._interpolate_some(option, accum, v, |
| 750 | section, map, depth + 1) |
| 751 | else: |
| 752 | accum.append(v) |
| 753 | else: |
| 754 | raise InterpolationSyntaxError( |
Neal Norwitz | 10f3018 | 2003-06-29 04:23:35 +0000 | [diff] [blame] | 755 | option, section, |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 756 | "'%%' must be followed by '%%' or '(', found: %r" % (rest,)) |
David Goodger | 1cbf206 | 2004-10-03 15:55:09 +0000 | [diff] [blame] | 757 | |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 758 | def set(self, section, option, value=None): |
David Goodger | 1cbf206 | 2004-10-03 15:55:09 +0000 | [diff] [blame] | 759 | """Set an option. Extend ConfigParser.set: check for string values.""" |
Fred Drake | cc43b56 | 2010-02-19 05:24:30 +0000 | [diff] [blame] | 760 | # The only legal non-string value if we allow valueless |
| 761 | # options is None, so we need to check if the value is a |
| 762 | # string if: |
| 763 | # - we do not allow valueless options, or |
| 764 | # - we allow valueless options but the value is not None |
| 765 | if self._optcre is self.OPTCRE or value: |
| 766 | if not isinstance(value, basestring): |
| 767 | raise TypeError("option values must be strings") |
Fred Drake | 0a1fa0e | 2010-08-10 13:09:54 +0000 | [diff] [blame] | 768 | if value is not None: |
| 769 | # check for bad percent signs: |
| 770 | # first, replace all "good" interpolations |
| 771 | tmp_value = value.replace('%%', '') |
| 772 | tmp_value = self._interpvar_re.sub('', tmp_value) |
| 773 | # then, check if there's a lone percent sign left |
| 774 | if '%' in tmp_value: |
| 775 | raise ValueError("invalid interpolation syntax in %r at " |
| 776 | "position %d" % (value, tmp_value.find('%'))) |
David Goodger | 1cbf206 | 2004-10-03 15:55:09 +0000 | [diff] [blame] | 777 | ConfigParser.set(self, section, option, value) |