delimiters=('=', ':'), comment_prefixes=('#', ';'),
inline_comment_prefixes=None, strict=True,
empty_lines_in_values=True, default_section='DEFAULT',
- interpolation=<unset>, converters=<unset>):
-
+ interpolation=<unset>, converters=<unset>,
+ allow_unnamed_section=False):
Create the parser. When `defaults` is given, it is initialized into the
dictionary or intrinsic defaults. The keys must be strings, the values
must be appropriate for %()s string interpolation.
converter gets its corresponding get*() method on the parser object and
section proxies.
+ When `allow_unnamed_section` is True (default: False), options
+ without section are accepted: the section for these is
+ ``configparser.UNNAMED_SECTION``.
+
sections()
Return all the configuration section names, sans DEFAULT.
"ConfigParser", "RawConfigParser",
"Interpolation", "BasicInterpolation", "ExtendedInterpolation",
"SectionProxy", "ConverterMapping",
- "DEFAULTSECT", "MAX_INTERPOLATION_DEPTH")
+ "DEFAULTSECT", "MAX_INTERPOLATION_DEPTH", "UNNAMED_SECTION")
_default_dict = dict
DEFAULTSECT = "DEFAULT"
self.line = line
self.args = (filename, lineno, line)
+class _UnnamedSection:
+
+ def __repr__(self):
+ return "<UNNAMED_SECTION>"
+
+
+UNNAMED_SECTION = _UnnamedSection()
+
+
# Used in parser getters to indicate the default behaviour when a specific
# option is not found it to raise an exception. Created to enable `None` as
# a valid fallback value.
comment_prefixes=('#', ';'), inline_comment_prefixes=None,
strict=True, empty_lines_in_values=True,
default_section=DEFAULTSECT,
- interpolation=_UNSET, converters=_UNSET):
+ interpolation=_UNSET, converters=_UNSET,
+ allow_unnamed_section=False,):
self._dict = dict_type
self._sections = self._dict()
self._converters.update(converters)
if defaults:
self._read_defaults(defaults)
+ self._allow_unnamed_section = allow_unnamed_section
def defaults(self):
return self._defaults
if self._defaults:
self._write_section(fp, self.default_section,
self._defaults.items(), d)
+ if UNNAMED_SECTION in self._sections:
+ 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):
- """Write a single section to the specified `fp`."""
- fp.write("[{}]\n".format(section_name))
+ 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:
value = self._interpolation.before_write(self, section_name, key,
value)
lineno = 0
indent_level = 0
e = None # None, or an exception
+
try:
for lineno, line in enumerate(fp, start=1):
comment_start = sys.maxsize
cursect[optname].append(value)
# a section header or option header?
else:
+ if self._allow_unnamed_section and cursect is None:
+ sectname = UNNAMED_SECTION
+ cursect = self._dict()
+ self._sections[sectname] = cursect
+ self._proxies[sectname] = SectionProxy(self, sectname)
+ elements_added.add(sectname)
+
indent_level = cur_indent_level
# is it a section header?
mo = self.SECTCRE.match(value)
elements_added.add(sectname)
# So sections can't start with a continuation line
optname = None
- # no section header in the file?
+ # no section header?
elif cursect is None:
raise MissingSectionHeaderError(fpname, lineno, line)
- # an option line?
+ # an option line?
else:
- mo = self._optcre.match(value)
+ indent_level = cur_indent_level
+ # is it a section header?
+ mo = self.SECTCRE.match(value)
if mo:
- optname, vi, optval = mo.group('option', 'vi', 'value')
- if not optname:
- e = self._handle_error(e, fpname, lineno, line)
- optname = self.optionxform(optname.rstrip())
- if (self._strict and
- (sectname, optname) in elements_added):
- raise DuplicateOptionError(sectname, optname,
- fpname, lineno)
- elements_added.add((sectname, optname))
- # This check is fine because the OPTCRE cannot
- # match if it would set optval to None
- if optval is not None:
- optval = optval.strip()
- cursect[optname] = [optval]
+ sectname = mo.group('header')
+ if sectname in self._sections:
+ if self._strict and sectname in elements_added:
+ raise DuplicateSectionError(sectname, fpname,
+ lineno)
+ cursect = self._sections[sectname]
+ elements_added.add(sectname)
+ elif sectname == self.default_section:
+ cursect = self._defaults
else:
- # valueless option handling
- cursect[optname] = None
+ cursect = self._dict()
+ self._sections[sectname] = cursect
+ self._proxies[sectname] = SectionProxy(self, sectname)
+ elements_added.add(sectname)
+ # So sections can't start with a continuation line
+ optname = None
+ # no section header in the file?
+ elif cursect is None:
+ raise MissingSectionHeaderError(fpname, lineno, line)
+ # an option line?
else:
- # a non-fatal parsing error occurred. set up the
- # exception but keep going. the exception will be
- # raised at the end of the file and will contain a
- # list of all bogus lines
- e = self._handle_error(e, fpname, lineno, line)
+ mo = self._optcre.match(value)
+ if mo:
+ optname, vi, optval = mo.group('option', 'vi', 'value')
+ if not optname:
+ e = self._handle_error(e, fpname, lineno, line)
+ optname = self.optionxform(optname.rstrip())
+ if (self._strict and
+ (sectname, optname) in elements_added):
+ raise DuplicateOptionError(sectname, optname,
+ fpname, lineno)
+ elements_added.add((sectname, optname))
+ # This check is fine because the OPTCRE cannot
+ # match if it would set optval to None
+ if optval is not None:
+ optval = optval.strip()
+ cursect[optname] = [optval]
+ else:
+ # valueless option handling
+ cursect[optname] = None
+ else:
+ # a non-fatal parsing error occurred. set up the
+ # exception but keep going. the exception will be
+ # raised at the end of the file and will contain a
+ # list of all bogus lines
+ e = self._handle_error(e, fpname, lineno, line)
finally:
self._join_multiline_values()
# if any parsing errors occurred, raise an exception
self.assertEqual(cfg['two'].getlen('one'), 5)
+class SectionlessTestCase(unittest.TestCase):
+
+ def fromstring(self, string):
+ cfg = configparser.ConfigParser(allow_unnamed_section=True)
+ cfg.read_string(string)
+ return cfg
+
+ def test_no_first_section(self):
+ cfg1 = self.fromstring("""
+ a = 1
+ b = 2
+ [sect1]
+ c = 3
+ """)
+
+ self.assertEqual(set([configparser.UNNAMED_SECTION, 'sect1']), set(cfg1.sections()))
+ self.assertEqual('1', cfg1[configparser.UNNAMED_SECTION]['a'])
+ self.assertEqual('2', cfg1[configparser.UNNAMED_SECTION]['b'])
+ self.assertEqual('3', cfg1['sect1']['c'])
+
+ output = io.StringIO()
+ cfg1.write(output)
+ cfg2 = self.fromstring(output.getvalue())
+
+ #self.assertEqual(set([configparser.UNNAMED_SECTION, 'sect1']), set(cfg2.sections()))
+ self.assertEqual('1', cfg2[configparser.UNNAMED_SECTION]['a'])
+ self.assertEqual('2', cfg2[configparser.UNNAMED_SECTION]['b'])
+ self.assertEqual('3', cfg2['sect1']['c'])
+
+ def test_no_section(self):
+ cfg1 = self.fromstring("""
+ a = 1
+ b = 2
+ """)
+
+ self.assertEqual([configparser.UNNAMED_SECTION], cfg1.sections())
+ self.assertEqual('1', cfg1[configparser.UNNAMED_SECTION]['a'])
+ self.assertEqual('2', cfg1[configparser.UNNAMED_SECTION]['b'])
+
+ output = io.StringIO()
+ cfg1.write(output)
+ cfg2 = self.fromstring(output.getvalue())
+
+ self.assertEqual([configparser.UNNAMED_SECTION], cfg2.sections())
+ self.assertEqual('1', cfg2[configparser.UNNAMED_SECTION]['a'])
+ self.assertEqual('2', cfg2[configparser.UNNAMED_SECTION]['b'])
+
+
class MiscTestCase(unittest.TestCase):
def test__all__(self):
support.check__all__(self, configparser, not_exported={"Error"})
projects / thirdparty / Python / cpython.git / commitdiff
