from collections.abc import Iterable, MutableMapping

from collections import ChainMap as _ChainMap

import contextlib

import functools

import io

import itertools

import os

import re

import sys

__all__ = ("NoSectionError", "DuplicateOptionError", "DuplicateSectionError",

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

"InterpolationMissingOptionError", "InterpolationSyntaxError",

"ParsingError", "MissingSectionHeaderError",

"MultilineContinuationError", "UnnamedSectionDisabledError",

"InvalidWriteError", "ConfigParser", "RawConfigParser",

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

"SectionProxy", "ConverterMapping",

"DEFAULTSECT", "MAX_INTERPOLATION_DEPTH", "UNNAMED_SECTION")

_default_dict = dict

DEFAULTSECT = "DEFAULT"

MAX_INTERPOLATION_DEPTH = 10

class Error(Exception):

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

def __init__(self, msg=''):

self.message = msg

Exception.__init__(self, msg)

def __repr__(self):

return self.message

__str__ = __repr__

class NoSectionError(Error):

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

def __init__(self, section):

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

self.section = section

self.args = (section, )

class DuplicateSectionError(Error):

"""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

self.args = (section, source, lineno)

class DuplicateOptionError(Error):

"""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

self.args = (section, option, source, lineno)

class NoOptionError(Error):

"""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

self.args = (option, section)

class InterpolationError(Error):

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

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

Error.__init__(self, msg)

self.option = option

self.section = section

self.args = (option, section, msg)

class InterpolationMissingOptionError(InterpolationError):

"""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

self.args = (option, section, rawval, reference)

class InterpolationSyntaxError(InterpolationError):

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

class InterpolationDepthError(InterpolationError):

"""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)

self.args = (option, section, rawval)

class ParsingError(Error):

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

def __init__(self, source, *args):

super().__init__(f'Source contains parsing errors: {source!r}')

self.source = source

self.errors = []

self.args = (source, )

if args:

self.append(*args)

def append(self, lineno, line):

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

self.message += '\n\t[line %2d]: %s' % (lineno, repr(line))

def combine(self, others):

for other in others:

for error in other.errors:

self.append(*error)

return self

@staticmethod

def _raise_all(exceptions: Iterable['ParsingError']):

"""

exceptions = iter(exceptions)

with contextlib.suppress(StopIteration):

raise next(exceptions).combine(exceptions)

class MissingSectionHeaderError(ParsingError):

"""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

self.args = (filename, lineno, line)

class MultilineContinuationError(ParsingError):

"""Raised when a key without value is followed by continuation line"""

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

Error.__init__(

self,

"Key without value continued with an indented line.\n"

"file: %r, line: %d\n%r"

%(filename, lineno, line))

self.source = filename

self.lineno = lineno

self.line = line

self.args = (filename, lineno, line)

class UnnamedSectionDisabledError(Error):

"""Raised when an attempt to use UNNAMED_SECTION is made with the

def __init__(self):

Error.__init__(self, "Support for UNNAMED_SECTION is disabled.")

class _UnnamedSection:

def __repr__(self):

return "<UNNAMED_SECTION>"

class InvalidWriteError(Error):

"""Raised when attempting to write data that the parser would read back differently.

def __init__(self, msg=''):

Error.__init__(self, msg)

UNNAMED_SECTION = _UnnamedSection()

_UNSET = object()

class Interpolation:

"""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):

return value

class BasicInterpolation(Interpolation):

"""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 '(', "

"found: %r" % (rest,))

class ExtendedInterpolation(Interpolation):

"""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 v is None:

continue

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 '{', "

"found: %r" % (rest,))

class _ReadState:

elements_added : set[str]

cursect : dict[str, str] | None = None

sectname : str | None = None

optname : str | None = None

lineno : int = 0

indent_level : int = 0

errors : list[ParsingError]

def __init__(self):

self.elements_added = set()

self.errors = list()

class _Line(str):

__slots__ = 'clean', 'has_comments'

def __new__(cls, val, *args, **kwargs):

return super().__new__(cls, val)

def __init__(self, val, comments):

trimmed = val.strip()

self.clean = comments.strip(trimmed)

self.has_comments = trimmed != self.clean

class _CommentSpec:

def __init__(self, full_prefixes, inline_prefixes):

full_patterns = (

# prefix at the beginning of a line

fr'^({re.escape(prefix)}).*'

for prefix in full_prefixes

)

inline_patterns = (

# prefix at the beginning of the line or following a space

fr'(^|\s)({re.escape(prefix)}.*)'

for prefix in inline_prefixes

)

self.pattern = re.compile('|'.join(itertools.chain(full_patterns, inline_patterns)))

def strip(self, text):

return self.pattern.sub('', text).rstrip()

def wrap(self, text):

return _Line(text, self)

class RawConfigParser(MutableMapping):

"""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,

allow_unnamed_section=False,):

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._comments = _CommentSpec(comment_prefixes or (), 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 not isinstance(self._interpolation, Interpolation):

raise TypeError(

f"interpolation= must be None or an instance of Interpolation;"

f" got an object of type {type(self._interpolation)}"

)

if converters is not _UNSET:

self._converters.update(converters)

if defaults:

self._read_defaults(defaults)

self._allow_unnamed_section = allow_unnamed_section

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 is UNNAMED_SECTION:

if not self._allow_unnamed_section:

raise UnnamedSectionDisabledError

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]

encoding = io.text_encoding(encoding)

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():

if section is not UNNAMED_SECTION:

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 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)

if UNNAMED_SECTION in self._sections and self._sections[UNNAMED_SECTION]:

self._write_section(fp, UNNAMED_SECTION, self._sections[UNNAMED_SECTION].items(), d, unnamed=True)

for section in self._sections:

if section is UNNAMED_SECTION:

continue

self._write_section(fp, section,

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

def _write_section(self, fp, section_name, section_items, delimiter, unnamed=False):

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

if not unnamed:

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

for key, value in section_items:

self._validate_key_contents(key)

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]