"NoOptionError", "InterpolationError", "InterpolationDepthError",

"InterpolationMissingOptionError", "InterpolationSyntaxError",

"ParsingError", "MissingSectionHeaderError",

"ConfigParser", "SafeConfigParser", "RawConfigParser",

"Interpolation", "BasicInterpolation", "ExtendedInterpolation",

"LegacyInterpolation", "SectionProxy", "ConverterMapping",

"""Base class for ConfigParser exceptions."""

def __init__(self, msg=''):

self.message = msg

Exception.__init__(self, msg)

def __repr__(self):

return self.message

"""Raised when no section matches a requested option."""

def __init__(self, section):

Error.__init__(self, 'No section: %r' % (section,))

self.section = section

"""Raised when a section is repeated in an input source.

def __init__(self, section, source=None, lineno=None):

msg = [repr(section), " already exists"]

if source is not None:

message = ["While reading from ", repr(source)]

if lineno is not None:

message.append(" [line {0:2d}]".format(lineno))

message.append(": section ")

message.extend(msg)

msg = message

else:

msg.insert(0, "Section ")

Error.__init__(self, "".join(msg))

self.section = section

self.source = source

self.lineno = lineno

"""Raised by strict parsers when an option is repeated in an input source.

def __init__(self, section, option, source=None, lineno=None):

msg = [repr(option), " in section ", repr(section),

" already exists"]

if source is not None:

message = ["While reading from ", repr(source)]

if lineno is not None:

message.append(" [line {0:2d}]".format(lineno))

message.append(": option ")

message.extend(msg)

msg = message

else:

msg.insert(0, "Option ")

Error.__init__(self, "".join(msg))

self.section = section

self.option = option

self.source = source

self.lineno = lineno

"""A requested option was not found."""

def __init__(self, option, section):

Error.__init__(self, "No option %r in section: %r" %

(option, section))

self.option = option

self.section = section

"""Base class for interpolation-related exceptions."""

def __init__(self, option, section, msg):

Error.__init__(self, msg)

self.option = option

self.section = section

"""A string substitution required a setting which was not available."""

def __init__(self, option, section, rawval, reference):

msg = ("Bad value substitution: option {!r} in section {!r} contains "

"an interpolation key {!r} which is not a valid option name. "

"Raw value: {!r}".format(option, section, reference, rawval))

InterpolationError.__init__(self, option, section, msg)

self.reference = reference

"""Raised when the source text contains invalid syntax.

"""Raised when substitutions are nested too deeply."""

def __init__(self, option, section, rawval):

msg = ("Recursion limit exceeded in value substitution: option {!r} "

"in section {!r} contains an interpolation key which "

"cannot be substituted in {} steps. Raw value: {!r}"

"".format(option, section, MAX_INTERPOLATION_DEPTH,

rawval))

InterpolationError.__init__(self, option, section, msg)

"""Raised when a configuration file does not follow legal syntax."""

def __init__(self, source=None, filename=None):

# Exactly one of `source'/`filename' arguments has to be given.

# `filename' kept for compatibility.

if filename and source:

raise ValueError("Cannot specify both `filename' and `source'. "

"Use `source'.")

elif not filename and not source:

raise ValueError("Required argument `source' not given.")

elif filename:

source = filename

Error.__init__(self, 'Source contains parsing errors: %r' % source)

self.source = source

self.errors = []

self.args = (source, )

@property

def filename(self):

"""Deprecated, use `source'."""

warnings.warn(

"The 'filename' attribute will be removed in future versions. "

"Use 'source' instead.",

DeprecationWarning, stacklevel=2

)

return self.source

@filename.setter

def filename(self, value):

"""Deprecated, user `source'."""

warnings.warn(

"The 'filename' attribute will be removed in future versions. "

"Use 'source' instead.",

DeprecationWarning, stacklevel=2

)

self.source = value

def append(self, lineno, line):

self.errors.append((lineno, line))

"""Raised when a key-value pair is found before any section header."""

def __init__(self, filename, lineno, line):

Error.__init__(

self,

'File contains no section headers.\nfile: %r, line: %d\n%r' %

(filename, lineno, line))

self.source = filename

self.lineno = lineno

self.line = line

"""Dummy interpolation that passes the value through with no changes."""

def before_get(self, parser, section, option, value, defaults):

return value

def before_set(self, parser, section, option, value):

return value

def before_read(self, parser, section, option, value):

return value

def before_write(self, parser, section, option, value):

"""Interpolation as implemented in the classic ConfigParser.

_KEYCRE = re.compile(r"%\(([^)]+)\)s")

def before_get(self, parser, section, option, value, defaults):

L = []

self._interpolate_some(parser, option, L, value, section, defaults, 1)

return ''.join(L)

def before_set(self, parser, section, option, value):

tmp_value = value.replace('%%', '') # escaped percent signs

tmp_value = self._KEYCRE.sub('', tmp_value) # valid syntax

if '%' in tmp_value:

raise ValueError("invalid interpolation syntax in %r at "

"position %d" % (value, tmp_value.find('%')))

return value

def _interpolate_some(self, parser, option, accum, rest, section, map,

depth):

rawval = parser.get(section, option, raw=True, fallback=rest)

if depth > MAX_INTERPOLATION_DEPTH:

raise InterpolationDepthError(option, section, rawval)

while rest:

p = rest.find("%")

if p < 0:

accum.append(rest)

return

if p > 0:

accum.append(rest[:p])

rest = rest[p:]

# p is no longer used

c = rest[1:2]

if c == "%":

accum.append("%")

rest = rest[2:]

elif c == "(":

m = self._KEYCRE.match(rest)

if m is None:

raise InterpolationSyntaxError(option, section,

"bad interpolation variable reference %r" % rest)

var = parser.optionxform(m.group(1))

rest = rest[m.end():]

try:

v = map[var]

except KeyError:

raise InterpolationMissingOptionError(

option, section, rawval, var) from None

if "%" in v:

self._interpolate_some(parser, option, accum, v,

section, map, depth + 1)

else:

accum.append(v)

else:

raise InterpolationSyntaxError(

option, section,

"'%%' must be followed by '%%' or '(', "

"""Advanced variant of interpolation, supports the syntax used by

_KEYCRE = re.compile(r"\$\{([^}]+)\}")

def before_get(self, parser, section, option, value, defaults):

L = []

self._interpolate_some(parser, option, L, value, section, defaults, 1)

return ''.join(L)

def before_set(self, parser, section, option, value):

tmp_value = value.replace('$$', '') # escaped dollar signs

tmp_value = self._KEYCRE.sub('', tmp_value) # valid syntax

if '$' in tmp_value:

raise ValueError("invalid interpolation syntax in %r at "

"position %d" % (value, tmp_value.find('$')))

return value

def _interpolate_some(self, parser, option, accum, rest, section, map,

depth):

rawval = parser.get(section, option, raw=True, fallback=rest)

if depth > MAX_INTERPOLATION_DEPTH:

raise InterpolationDepthError(option, section, rawval)

while rest:

p = rest.find("$")

if p < 0:

accum.append(rest)

return

if p > 0:

accum.append(rest[:p])

rest = rest[p:]

# p is no longer used

c = rest[1:2]

if c == "$":

accum.append("$")

rest = rest[2:]

elif c == "{":

m = self._KEYCRE.match(rest)

if m is None:

raise InterpolationSyntaxError(option, section,

"bad interpolation variable reference %r" % rest)

path = m.group(1).split(':')

rest = rest[m.end():]

sect = section

opt = option

try:

if len(path) == 1:

opt = parser.optionxform(path[0])

v = map[opt]

elif len(path) == 2:

sect = path[0]

opt = parser.optionxform(path[1])

v = parser.get(sect, opt, raw=True)

else:

raise InterpolationSyntaxError(

option, section,

"More than one ':' found: %r" % (rest,))

except (KeyError, NoSectionError, NoOptionError):

raise InterpolationMissingOptionError(

option, section, rawval, ":".join(path)) from None

if "$" in v:

self._interpolate_some(parser, opt, accum, v, sect,

dict(parser.items(sect, raw=True)),

depth + 1)

else:

accum.append(v)

else:

raise InterpolationSyntaxError(

option, section,

"'$' must be followed by '$' or '{', "

"""Deprecated interpolation used in old versions of ConfigParser.

_KEYCRE = re.compile(r"%\(([^)]*)\)s|.")

def before_get(self, parser, section, option, value, vars):

rawval = value

depth = MAX_INTERPOLATION_DEPTH

while depth: # Loop through this until it's done

depth -= 1

if value and "%(" in value:

replace = functools.partial(self._interpolation_replace,

parser=parser)

value = self._KEYCRE.sub(replace, value)

try:

value = value % vars

except KeyError as e:

raise InterpolationMissingOptionError(

option, section, rawval, e.args[0]) from None

else:

break

if value and "%(" in value:

raise InterpolationDepthError(option, section, rawval)

return value

def before_set(self, parser, section, option, value):

return value

@staticmethod

def _interpolation_replace(match, parser):

s = match.group(1)

if s is None:

return match.group()

else:

"""ConfigParser that does not do interpolation."""

# Regular expressions for parsing section headers and options

_SECT_TMPL = r"""

_OPT_TMPL = r"""

_OPT_NV_TMPL = r"""

# Interpolation algorithm to be used if the user does not specify another

_DEFAULT_INTERPOLATION = Interpolation()

# Compiled regular expression for matching sections

SECTCRE = re.compile(_SECT_TMPL, re.VERBOSE)

# Compiled regular expression for matching options with typical separators

OPTCRE = re.compile(_OPT_TMPL.format(delim="=|:"), re.VERBOSE)

# Compiled regular expression for matching options with optional values

# delimited using typical separators

OPTCRE_NV = re.compile(_OPT_NV_TMPL.format(delim="=|:"), re.VERBOSE)

# Compiled regular expression for matching leading whitespace in a line

NONSPACECRE = re.compile(r"\S")

# Possible boolean values in the configuration.

BOOLEAN_STATES = {'1': True, 'yes': True, 'true': True, 'on': True,

'0': False, 'no': False, 'false': False, 'off': False}

def __init__(self, defaults=None, dict_type=_default_dict,

allow_no_value=False, *, delimiters=('=', ':'),

comment_prefixes=('#', ';'), inline_comment_prefixes=None,

strict=True, empty_lines_in_values=True,

default_section=DEFAULTSECT,

interpolation=_UNSET, converters=_UNSET):

self._dict = dict_type

self._sections = self._dict()

self._defaults = self._dict()

self._converters = ConverterMapping(self)

self._proxies = self._dict()

self._proxies[default_section] = SectionProxy(self, default_section)

self._delimiters = tuple(delimiters)

if delimiters == ('=', ':'):

self._optcre = self.OPTCRE_NV if allow_no_value else self.OPTCRE

else:

d = "|".join(re.escape(d) for d in delimiters)

if allow_no_value:

self._optcre = re.compile(self._OPT_NV_TMPL.format(delim=d),

re.VERBOSE)

else:

self._optcre = re.compile(self._OPT_TMPL.format(delim=d),

re.VERBOSE)

self._comment_prefixes = tuple(comment_prefixes or ())

self._inline_comment_prefixes = tuple(inline_comment_prefixes or ())

self._strict = strict

self._allow_no_value = allow_no_value

self._empty_lines_in_values = empty_lines_in_values

self.default_section=default_section

self._interpolation = interpolation

if self._interpolation is _UNSET:

self._interpolation = self._DEFAULT_INTERPOLATION

if self._interpolation is None:

self._interpolation = Interpolation()

if converters is not _UNSET:

self._converters.update(converters)

if defaults:

self._read_defaults(defaults)

def defaults(self):

return self._defaults

def sections(self):

"""Return a list of section names, excluding [DEFAULT]"""

# self._sections will never have [DEFAULT] in it

return list(self._sections.keys())

def add_section(self, section):

"""Create a new section in the configuration.

if section == self.default_section:

raise ValueError('Invalid section name: %r' % section)

if section in self._sections:

raise DuplicateSectionError(section)

self._sections[section] = self._dict()

self._proxies[section] = SectionProxy(self, section)

def has_section(self, section):

"""Indicate whether the named section is present in the configuration.

return section in self._sections

def options(self, section):

"""Return a list of option names for the given section name."""

try:

opts = self._sections[section].copy()

except KeyError:

raise NoSectionError(section) from None

opts.update(self._defaults)

return list(opts.keys())

def read(self, filenames, encoding=None):

"""Read and parse a filename or an iterable of filenames.

if isinstance(filenames, (str, bytes, os.PathLike)):

filenames = [filenames]

read_ok = []

for filename in filenames:

try:

with open(filename, encoding=encoding) as fp:

self._read(fp, filename)

except OSError:

continue

if isinstance(filename, os.PathLike):

filename = os.fspath(filename)

read_ok.append(filename)

return read_ok

def read_file(self, f, source=None):

"""Like read() but the argument must be a file-like object.

if source is None:

try:

source = f.name

except AttributeError:

source = '<???>'

self._read(f, source)

def read_string(self, string, source='<string>'):

"""Read configuration from a given string."""

sfile = io.StringIO(string)

self.read_file(sfile, source)

def read_dict(self, dictionary, source='<dict>'):

"""Read configuration from a dictionary.

elements_added = set()

for section, keys in dictionary.items():

section = str(section)

try:

self.add_section(section)

except (DuplicateSectionError, ValueError):

if self._strict and section in elements_added:

raise

elements_added.add(section)

for key, value in keys.items():

key = self.optionxform(str(key))

if value is not None:

value = str(value)

if self._strict and (section, key) in elements_added:

raise DuplicateOptionError(section, key, source)

elements_added.add((section, key))

self.set(section, key, value)

def readfp(self, fp, filename=None):

"""Deprecated, use read_file instead."""

warnings.warn(

"This method will be removed in future versions. "

"Use 'parser.read_file()' instead.",

DeprecationWarning, stacklevel=2

)

self.read_file(fp, source=filename)

def get(self, section, option, *, raw=False, vars=None, fallback=_UNSET):

"""Get an option value for a given section.

try:

d = self._unify_values(section, vars)

except NoSectionError:

if fallback is _UNSET:

raise

else:

return fallback

option = self.optionxform(option)

try:

value = d[option]

except KeyError:

if fallback is _UNSET:

raise NoOptionError(option, section)

else:

return fallback

if raw or value is None:

return value

else:

return self._interpolation.before_get(self, section, option, value,

d)

def _get(self, section, conv, option, **kwargs):

return conv(self.get(section, option, **kwargs))

def _get_conv(self, section, option, conv, *, raw=False, vars=None,

fallback=_UNSET, **kwargs):

try:

return self._get(section, conv, option, raw=raw, vars=vars,

**kwargs)

except (NoSectionError, NoOptionError):

if fallback is _UNSET:

raise

return fallback

# getint, getfloat and getboolean provided directly for backwards compat

def getint(self, section, option, *, raw=False, vars=None,

fallback=_UNSET, **kwargs):

return self._get_conv(section, option, int, raw=raw, vars=vars,

fallback=fallback, **kwargs)

def getfloat(self, section, option, *, raw=False, vars=None,

fallback=_UNSET, **kwargs):

return self._get_conv(section, option, float, raw=raw, vars=vars,

fallback=fallback, **kwargs)

def getboolean(self, section, option, *, raw=False, vars=None,

fallback=_UNSET, **kwargs):

return self._get_conv(section, option, self._convert_to_boolean,

raw=raw, vars=vars, fallback=fallback, **kwargs)

def items(self, section=_UNSET, raw=False, vars=None):

"""Return a list of (name, value) tuples for each option in a section.

if section is _UNSET:

return super().items()

d = self._defaults.copy()

try:

d.update(self._sections[section])

except KeyError:

if section != self.default_section:

raise NoSectionError(section)

orig_keys = list(d.keys())

# Update with the entry specific variables

if vars:

for key, value in vars.items():

d[self.optionxform(key)] = value

value_getter = lambda option: self._interpolation.before_get(self,

section, option, d[option], d)

if raw:

value_getter = lambda option: d[option]

return [(option, value_getter(option)) for option in orig_keys]

def popitem(self):

"""Remove a section from the parser and return it as

for key in self.sections():

value = self[key]

del self[key]

return key, value

raise KeyError

def optionxform(self, optionstr):

return optionstr.lower()

def has_option(self, section, option):

"""Check for the existence of a given option in a given section.

if not section or section == self.default_section:

option = self.optionxform(option)

return option in self._defaults

elif section not in self._sections:

return False

else:

option = self.optionxform(option)

return (option in self._sections[section]

or option in self._defaults)

def set(self, section, option, value=None):

"""Set an option."""

if value:

value = self._interpolation.before_set(self, section, option,

value)

if not section or section == self.default_section:

sectdict = self._defaults

else:

try:

sectdict = self._sections[section]

except KeyError:

raise NoSectionError(section) from None

sectdict[self.optionxform(option)] = value

def write(self, fp, space_around_delimiters=True):

"""Write an .ini-format representation of the configuration state.

if space_around_delimiters:

d = " {} ".format(self._delimiters[0])

else:

d = self._delimiters[0]

if self._defaults:

self._write_section(fp, self.default_section,

self._defaults.items(), d)

for section in self._sections:

self._write_section(fp, section,

self._sections[section].items(), d)

def _write_section(self, fp, section_name, section_items, delimiter):

"""Write a single section to the specified `fp'."""

fp.write("[{}]\n".format(section_name))

for key, value in section_items:

value = self._interpolation.before_write(self, section_name, key,

value)

if value is not None or not self._allow_no_value:

value = delimiter + str(value).replace('\n', '\n\t')

else:

value = ""

fp.write("{}{}\n".format(key, value))

fp.write("\n")

def remove_option(self, section, option):

"""Remove an option."""

if not section or section == self.default_section:

sectdict = self._defaults

else:

try:

sectdict = self._sections[section]

except KeyError:

raise NoSectionError(section) from None

option = self.optionxform(option)

existed = option in sectdict

if existed:

del sectdict[option]

return existed

def remove_section(self, section):

"""Remove a file section."""

existed = section in self._sections

if existed:

del self._sections[section]

del self._proxies[section]

return existed

def __getitem__(self, key):

if key != self.default_section and not self.has_section(key):

raise KeyError(key)

return self._proxies[key]

def __setitem__(self, key, value):

# To conform with the mapping protocol, overwrites existing values in

# the section.

if key in self and self[key] is value:

return

# XXX this is not atomic if read_dict fails at any point. Then again,

# no update method in configparser is atomic in this implementation.

if key == self.default_section:

self._defaults.clear()

elif key in self._sections:

self._sections[key].clear()

self.read_dict({key: value})

def __delitem__(self, key):

if key == self.default_section:

raise ValueError("Cannot remove the default section.")

if not self.has_section(key):

raise KeyError(key)

self.remove_section(key)

def __contains__(self, key):

return key == self.default_section or self.has_section(key)

def __len__(self):

return len(self._sections) + 1 # the default section

def __iter__(self):

# XXX does it break when underlying container state changed?

return itertools.chain((self.default_section,), self._sections.keys())

def _read(self, fp, fpname):

"""Parse a sectioned configuration file.