migrate to Python3 (from alejeune)
This commit is contained in:
htouvet
@@ -0,0 +1,652 @@
|
||||
"""Access and/or modify INI files
|
||||
|
||||
* Compatiable with ConfigParser
|
||||
* Preserves order of sections & options
|
||||
* Preserves comments/blank lines/etc
|
||||
* More conveninet access to data
|
||||
|
||||
Example:
|
||||
|
||||
>>> from six import StringIO
|
||||
>>> sio = StringIO('''# configure foo-application
|
||||
... [foo]
|
||||
... bar1 = qualia
|
||||
... bar2 = 1977
|
||||
... [foo-ext]
|
||||
... special = 1''')
|
||||
|
||||
>>> cfg = INIConfig(sio)
|
||||
>>> print(cfg.foo.bar1)
|
||||
qualia
|
||||
>>> print(cfg['foo-ext'].special)
|
||||
1
|
||||
>>> cfg.foo.newopt = 'hi!'
|
||||
>>> cfg.baz.enabled = 0
|
||||
|
||||
>>> print(cfg)
|
||||
# configure foo-application
|
||||
[foo]
|
||||
bar1 = qualia
|
||||
bar2 = 1977
|
||||
newopt = hi!
|
||||
[foo-ext]
|
||||
special = 1
|
||||
<BLANKLINE>
|
||||
[baz]
|
||||
enabled = 0
|
||||
|
||||
"""
|
||||
|
||||
# An ini parser that supports ordered sections/options
|
||||
# Also supports updates, while preserving structure
|
||||
# Backward-compatiable with ConfigParser
|
||||
|
||||
import re
|
||||
from .configparser import DEFAULTSECT, ParsingError, MissingSectionHeaderError
|
||||
|
||||
import six
|
||||
|
||||
from . import config
|
||||
|
||||
|
||||
class LineType(object):
|
||||
line = None
|
||||
|
||||
def __init__(self, line=None):
|
||||
if line is not None:
|
||||
self.line = line.strip('\n')
|
||||
|
||||
# Return the original line for unmodified objects
|
||||
# Otherwise construct using the current attribute values
|
||||
def __str__(self):
|
||||
if self.line is not None:
|
||||
return self.line
|
||||
else:
|
||||
return self.to_string()
|
||||
|
||||
# If an attribute is modified after initialization
|
||||
# set line to None since it is no longer accurate.
|
||||
def __setattr__(self, name, value):
|
||||
if hasattr(self,name):
|
||||
self.__dict__['line'] = None
|
||||
self.__dict__[name] = value
|
||||
|
||||
def to_string(self):
|
||||
raise Exception('This method must be overridden in derived classes')
|
||||
|
||||
|
||||
class SectionLine(LineType):
|
||||
regex = re.compile(r'^\['
|
||||
r'(?P<name>[^]]+)'
|
||||
r'\]\s*'
|
||||
r'((?P<csep>;|#)(?P<comment>.*))?$')
|
||||
|
||||
def __init__(self, name, comment=None, comment_separator=None,
|
||||
comment_offset=-1, line=None):
|
||||
super(SectionLine, self).__init__(line)
|
||||
self.name = name
|
||||
self.comment = comment
|
||||
self.comment_separator = comment_separator
|
||||
self.comment_offset = comment_offset
|
||||
|
||||
def to_string(self):
|
||||
out = '[' + self.name + ']'
|
||||
if self.comment is not None:
|
||||
# try to preserve indentation of comments
|
||||
out = (out+' ').ljust(self.comment_offset)
|
||||
out = out + self.comment_separator + self.comment
|
||||
return out
|
||||
|
||||
def parse(cls, line):
|
||||
m = cls.regex.match(line.rstrip())
|
||||
if m is None:
|
||||
return None
|
||||
return cls(m.group('name'), m.group('comment'),
|
||||
m.group('csep'), m.start('csep'),
|
||||
line)
|
||||
parse = classmethod(parse)
|
||||
|
||||
|
||||
class OptionLine(LineType):
|
||||
def __init__(self, name, value, separator=' = ', comment=None,
|
||||
comment_separator=None, comment_offset=-1, line=None):
|
||||
super(OptionLine, self).__init__(line)
|
||||
self.name = name
|
||||
self.value = value
|
||||
self.separator = separator
|
||||
self.comment = comment
|
||||
self.comment_separator = comment_separator
|
||||
self.comment_offset = comment_offset
|
||||
|
||||
def to_string(self):
|
||||
out = '%s%s%s' % (self.name, self.separator, self.value)
|
||||
if self.comment is not None:
|
||||
# try to preserve indentation of comments
|
||||
out = (out+' ').ljust(self.comment_offset)
|
||||
out = out + self.comment_separator + self.comment
|
||||
return out
|
||||
|
||||
regex = re.compile(r'^(?P<name>[^:=\s[][^:=]*)'
|
||||
r'(?P<sep>[:=]\s*)'
|
||||
r'(?P<value>.*)$')
|
||||
|
||||
def parse(cls, line):
|
||||
m = cls.regex.match(line.rstrip())
|
||||
if m is None:
|
||||
return None
|
||||
|
||||
name = m.group('name').rstrip()
|
||||
value = m.group('value')
|
||||
sep = m.group('name')[len(name):] + m.group('sep')
|
||||
|
||||
# comments are not detected in the regex because
|
||||
# ensuring total compatibility with ConfigParser
|
||||
# requires that:
|
||||
# option = value ;comment // value=='value'
|
||||
# option = value;1 ;comment // value=='value;1 ;comment'
|
||||
#
|
||||
# Doing this in a regex would be complicated. I
|
||||
# think this is a bug. The whole issue of how to
|
||||
# include ';' in the value needs to be addressed.
|
||||
# Also, '#' doesn't mark comments in options...
|
||||
|
||||
coff = value.find(';')
|
||||
if coff != -1 and value[coff-1].isspace():
|
||||
comment = value[coff+1:]
|
||||
csep = value[coff]
|
||||
value = value[:coff].rstrip()
|
||||
coff = m.start('value') + coff
|
||||
else:
|
||||
comment = None
|
||||
csep = None
|
||||
coff = -1
|
||||
|
||||
return cls(name, value, sep, comment, csep, coff, line)
|
||||
parse = classmethod(parse)
|
||||
|
||||
|
||||
def change_comment_syntax(comment_chars='%;#', allow_rem=False):
|
||||
comment_chars = re.sub(r'([\]\-\^])', r'\\\1', comment_chars)
|
||||
regex = r'^(?P<csep>[%s]' % comment_chars
|
||||
if allow_rem:
|
||||
regex += '|[rR][eE][mM]'
|
||||
regex += r')(?P<comment>.*)$'
|
||||
CommentLine.regex = re.compile(regex)
|
||||
|
||||
|
||||
class CommentLine(LineType):
|
||||
regex = re.compile(r'^(?P<csep>[;#])'
|
||||
r'(?P<comment>.*)$')
|
||||
|
||||
def __init__(self, comment='', separator='#', line=None):
|
||||
super(CommentLine, self).__init__(line)
|
||||
self.comment = comment
|
||||
self.separator = separator
|
||||
|
||||
def to_string(self):
|
||||
return self.separator + self.comment
|
||||
|
||||
def parse(cls, line):
|
||||
m = cls.regex.match(line.rstrip())
|
||||
if m is None:
|
||||
return None
|
||||
return cls(m.group('comment'), m.group('csep'), line)
|
||||
|
||||
parse = classmethod(parse)
|
||||
|
||||
|
||||
class EmptyLine(LineType):
|
||||
# could make this a singleton
|
||||
def to_string(self):
|
||||
return ''
|
||||
|
||||
value = property(lambda self: '')
|
||||
|
||||
def parse(cls, line):
|
||||
if line.strip():
|
||||
return None
|
||||
return cls(line)
|
||||
|
||||
parse = classmethod(parse)
|
||||
|
||||
|
||||
class ContinuationLine(LineType):
|
||||
regex = re.compile(r'^\s+(?P<value>.*)$')
|
||||
|
||||
def __init__(self, value, value_offset=None, line=None):
|
||||
super(ContinuationLine, self).__init__(line)
|
||||
self.value = value
|
||||
if value_offset is None:
|
||||
value_offset = 8
|
||||
self.value_offset = value_offset
|
||||
|
||||
def to_string(self):
|
||||
return ' '*self.value_offset + self.value
|
||||
|
||||
def parse(cls, line):
|
||||
m = cls.regex.match(line.rstrip())
|
||||
if m is None:
|
||||
return None
|
||||
return cls(m.group('value'), m.start('value'), line)
|
||||
|
||||
parse = classmethod(parse)
|
||||
|
||||
|
||||
class LineContainer(object):
|
||||
def __init__(self, d=None):
|
||||
self.contents = []
|
||||
self.orgvalue = None
|
||||
if d:
|
||||
if isinstance(d, list): self.extend(d)
|
||||
else: self.add(d)
|
||||
|
||||
def add(self, x):
|
||||
self.contents.append(x)
|
||||
|
||||
def extend(self, x):
|
||||
for i in x: self.add(i)
|
||||
|
||||
def get_name(self):
|
||||
return self.contents[0].name
|
||||
|
||||
def set_name(self, data):
|
||||
self.contents[0].name = data
|
||||
|
||||
def get_value(self):
|
||||
if self.orgvalue is not None:
|
||||
return self.orgvalue
|
||||
elif len(self.contents) == 1:
|
||||
return self.contents[0].value
|
||||
else:
|
||||
return '\n'.join([('%s' % x.value) for x in self.contents
|
||||
if not isinstance(x, CommentLine)])
|
||||
|
||||
def set_value(self, data):
|
||||
self.orgvalue = data
|
||||
lines = ('%s' % data).split('\n')
|
||||
|
||||
# If there is an existing ContinuationLine, use its offset
|
||||
value_offset = None
|
||||
for v in self.contents:
|
||||
if isinstance(v, ContinuationLine):
|
||||
value_offset = v.value_offset
|
||||
break
|
||||
|
||||
# Rebuild contents list, preserving initial OptionLine
|
||||
self.contents = self.contents[0:1]
|
||||
self.contents[0].value = lines[0]
|
||||
del lines[0]
|
||||
for line in lines:
|
||||
if line.strip():
|
||||
self.add(ContinuationLine(line, value_offset))
|
||||
else:
|
||||
self.add(EmptyLine())
|
||||
|
||||
name = property(get_name, set_name)
|
||||
|
||||
value = property(get_value, set_value)
|
||||
|
||||
def __str__(self):
|
||||
s = [x.__str__() for x in self.contents]
|
||||
return '\n'.join(s)
|
||||
|
||||
def finditer(self, key):
|
||||
for x in self.contents[::-1]:
|
||||
if hasattr(x, 'name') and x.name==key:
|
||||
yield x
|
||||
|
||||
def find(self, key):
|
||||
for x in self.finditer(key):
|
||||
return x
|
||||
raise KeyError(key)
|
||||
|
||||
|
||||
def _make_xform_property(myattrname, srcattrname=None):
|
||||
private_attrname = myattrname + 'value'
|
||||
private_srcname = myattrname + 'source'
|
||||
if srcattrname is None:
|
||||
srcattrname = myattrname
|
||||
|
||||
def getfn(self):
|
||||
srcobj = getattr(self, private_srcname)
|
||||
if srcobj is not None:
|
||||
return getattr(srcobj, srcattrname)
|
||||
else:
|
||||
return getattr(self, private_attrname)
|
||||
|
||||
def setfn(self, value):
|
||||
srcobj = getattr(self, private_srcname)
|
||||
if srcobj is not None:
|
||||
setattr(srcobj, srcattrname, value)
|
||||
else:
|
||||
setattr(self, private_attrname, value)
|
||||
|
||||
return property(getfn, setfn)
|
||||
|
||||
|
||||
class INISection(config.ConfigNamespace):
|
||||
_lines = None
|
||||
_options = None
|
||||
_defaults = None
|
||||
_optionxformvalue = None
|
||||
_optionxformsource = None
|
||||
_compat_skip_empty_lines = set()
|
||||
|
||||
def __init__(self, lineobj, defaults=None, optionxformvalue=None, optionxformsource=None):
|
||||
self._lines = [lineobj]
|
||||
self._defaults = defaults
|
||||
self._optionxformvalue = optionxformvalue
|
||||
self._optionxformsource = optionxformsource
|
||||
self._options = {}
|
||||
|
||||
_optionxform = _make_xform_property('_optionxform')
|
||||
|
||||
def _compat_get(self, key):
|
||||
# identical to __getitem__ except that _compat_XXX
|
||||
# is checked for backward-compatible handling
|
||||
if key == '__name__':
|
||||
return self._lines[-1].name
|
||||
if self._optionxform: key = self._optionxform(key)
|
||||
try:
|
||||
value = self._options[key].value
|
||||
del_empty = key in self._compat_skip_empty_lines
|
||||
except KeyError:
|
||||
if self._defaults and key in self._defaults._options:
|
||||
value = self._defaults._options[key].value
|
||||
del_empty = key in self._defaults._compat_skip_empty_lines
|
||||
else:
|
||||
raise
|
||||
if del_empty:
|
||||
value = re.sub('\n+', '\n', value)
|
||||
return value
|
||||
|
||||
def _getitem(self, key):
|
||||
if key == '__name__':
|
||||
return self._lines[-1].name
|
||||
if self._optionxform: key = self._optionxform(key)
|
||||
try:
|
||||
return self._options[key].value
|
||||
except KeyError:
|
||||
if self._defaults and key in self._defaults._options:
|
||||
return self._defaults._options[key].value
|
||||
else:
|
||||
raise
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
if self._optionxform: xkey = self._optionxform(key)
|
||||
else: xkey = key
|
||||
if xkey in self._compat_skip_empty_lines:
|
||||
self._compat_skip_empty_lines.remove(xkey)
|
||||
if xkey not in self._options:
|
||||
# create a dummy object - value may have multiple lines
|
||||
obj = LineContainer(OptionLine(key, ''))
|
||||
self._lines[-1].add(obj)
|
||||
self._options[xkey] = obj
|
||||
# the set_value() function in LineContainer
|
||||
# automatically handles multi-line values
|
||||
self._options[xkey].value = value
|
||||
|
||||
def __delitem__(self, key):
|
||||
if self._optionxform: key = self._optionxform(key)
|
||||
if key in self._compat_skip_empty_lines:
|
||||
self._compat_skip_empty_lines.remove(key)
|
||||
for l in self._lines:
|
||||
remaining = []
|
||||
for o in l.contents:
|
||||
if isinstance(o, LineContainer):
|
||||
n = o.name
|
||||
if self._optionxform: n = self._optionxform(n)
|
||||
if key != n: remaining.append(o)
|
||||
else:
|
||||
remaining.append(o)
|
||||
l.contents = remaining
|
||||
del self._options[key]
|
||||
|
||||
def __iter__(self):
|
||||
d = set()
|
||||
for l in self._lines:
|
||||
for x in l.contents:
|
||||
if isinstance(x, LineContainer):
|
||||
if self._optionxform:
|
||||
ans = self._optionxform(x.name)
|
||||
else:
|
||||
ans = x.name
|
||||
if ans not in d:
|
||||
yield ans
|
||||
d.add(ans)
|
||||
if self._defaults:
|
||||
for x in self._defaults:
|
||||
if x not in d:
|
||||
yield x
|
||||
d.add(x)
|
||||
|
||||
def _new_namespace(self, name):
|
||||
raise Exception('No sub-sections allowed', name)
|
||||
|
||||
|
||||
def make_comment(line):
|
||||
return CommentLine(line.rstrip('\n'))
|
||||
|
||||
|
||||
def readline_iterator(f):
|
||||
"""iterate over a file by only using the file object's readline method"""
|
||||
|
||||
have_newline = False
|
||||
while True:
|
||||
line = f.readline()
|
||||
|
||||
if not line:
|
||||
if have_newline:
|
||||
yield ""
|
||||
return
|
||||
|
||||
if line.endswith('\n'):
|
||||
have_newline = True
|
||||
else:
|
||||
have_newline = False
|
||||
|
||||
yield line
|
||||
|
||||
|
||||
def lower(x):
|
||||
return x.lower()
|
||||
|
||||
|
||||
class INIConfig(config.ConfigNamespace):
|
||||
_data = None
|
||||
_sections = None
|
||||
_defaults = None
|
||||
_optionxformvalue = None
|
||||
_optionxformsource = None
|
||||
_sectionxformvalue = None
|
||||
_sectionxformsource = None
|
||||
_parse_exc = None
|
||||
_bom = False
|
||||
|
||||
def __init__(self, fp=None, defaults=None, parse_exc=True,
|
||||
optionxformvalue=lower, optionxformsource=None,
|
||||
sectionxformvalue=None, sectionxformsource=None):
|
||||
self._data = LineContainer()
|
||||
self._parse_exc = parse_exc
|
||||
self._optionxformvalue = optionxformvalue
|
||||
self._optionxformsource = optionxformsource
|
||||
self._sectionxformvalue = sectionxformvalue
|
||||
self._sectionxformsource = sectionxformsource
|
||||
self._sections = {}
|
||||
if defaults is None: defaults = {}
|
||||
self._defaults = INISection(LineContainer(), optionxformsource=self)
|
||||
for name, value in defaults.items():
|
||||
self._defaults[name] = value
|
||||
if fp is not None:
|
||||
self._readfp(fp)
|
||||
|
||||
_optionxform = _make_xform_property('_optionxform', 'optionxform')
|
||||
_sectionxform = _make_xform_property('_sectionxform', 'optionxform')
|
||||
|
||||
def _getitem(self, key):
|
||||
if key == DEFAULTSECT:
|
||||
return self._defaults
|
||||
if self._sectionxform: key = self._sectionxform(key)
|
||||
return self._sections[key]
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
raise Exception('Values must be inside sections', key, value)
|
||||
|
||||
def __delitem__(self, key):
|
||||
if self._sectionxform: key = self._sectionxform(key)
|
||||
for line in self._sections[key]._lines:
|
||||
self._data.contents.remove(line)
|
||||
del self._sections[key]
|
||||
|
||||
def __iter__(self):
|
||||
d = set()
|
||||
d.add(DEFAULTSECT)
|
||||
for x in self._data.contents:
|
||||
if isinstance(x, LineContainer):
|
||||
if x.name not in d:
|
||||
yield x.name
|
||||
d.add(x.name)
|
||||
|
||||
def _new_namespace(self, name):
|
||||
if self._data.contents:
|
||||
self._data.add(EmptyLine())
|
||||
obj = LineContainer(SectionLine(name))
|
||||
self._data.add(obj)
|
||||
if self._sectionxform: name = self._sectionxform(name)
|
||||
if name in self._sections:
|
||||
ns = self._sections[name]
|
||||
ns._lines.append(obj)
|
||||
else:
|
||||
ns = INISection(obj, defaults=self._defaults,
|
||||
optionxformsource=self)
|
||||
self._sections[name] = ns
|
||||
return ns
|
||||
|
||||
def __str__(self):
|
||||
if self._bom:
|
||||
fmt = u'\ufeff%s'
|
||||
else:
|
||||
fmt = '%s'
|
||||
return fmt % self._data.__str__()
|
||||
|
||||
__unicode__ = __str__
|
||||
|
||||
_line_types = [EmptyLine, CommentLine,
|
||||
SectionLine, OptionLine,
|
||||
ContinuationLine]
|
||||
|
||||
def _parse(self, line):
|
||||
for linetype in self._line_types:
|
||||
lineobj = linetype.parse(line)
|
||||
if lineobj:
|
||||
return lineobj
|
||||
else:
|
||||
# can't parse line
|
||||
return None
|
||||
|
||||
def _readfp(self, fp):
|
||||
cur_section = None
|
||||
cur_option = None
|
||||
cur_section_name = None
|
||||
cur_option_name = None
|
||||
pending_lines = []
|
||||
pending_empty_lines = False
|
||||
try:
|
||||
fname = fp.name
|
||||
except AttributeError:
|
||||
fname = '<???>'
|
||||
line_count = 0
|
||||
exc = None
|
||||
line = None
|
||||
|
||||
for line in readline_iterator(fp):
|
||||
# Check for BOM on first line
|
||||
if line_count == 0 and isinstance(line, six.text_type):
|
||||
if line[0] == u'\ufeff':
|
||||
line = line[1:]
|
||||
self._bom = True
|
||||
|
||||
line_obj = self._parse(line)
|
||||
line_count += 1
|
||||
|
||||
if not cur_section and not isinstance(line_obj, (CommentLine, EmptyLine, SectionLine)):
|
||||
if self._parse_exc:
|
||||
raise MissingSectionHeaderError(fname, line_count, line)
|
||||
else:
|
||||
line_obj = make_comment(line)
|
||||
|
||||
if line_obj is None:
|
||||
if self._parse_exc:
|
||||
if exc is None:
|
||||
exc = ParsingError(fname)
|
||||
exc.append(line_count, line)
|
||||
line_obj = make_comment(line)
|
||||
|
||||
if isinstance(line_obj, ContinuationLine):
|
||||
if cur_option:
|
||||
if pending_lines:
|
||||
cur_option.extend(pending_lines)
|
||||
pending_lines = []
|
||||
if pending_empty_lines:
|
||||
optobj._compat_skip_empty_lines.add(cur_option_name)
|
||||
pending_empty_lines = False
|
||||
cur_option.add(line_obj)
|
||||
else:
|
||||
# illegal continuation line - convert to comment
|
||||
if self._parse_exc:
|
||||
if exc is None:
|
||||
exc = ParsingError(fname)
|
||||
exc.append(line_count, line)
|
||||
line_obj = make_comment(line)
|
||||
|
||||
if isinstance(line_obj, OptionLine):
|
||||
if pending_lines:
|
||||
cur_section.extend(pending_lines)
|
||||
pending_lines = []
|
||||
pending_empty_lines = False
|
||||
cur_option = LineContainer(line_obj)
|
||||
cur_section.add(cur_option)
|
||||
if self._optionxform:
|
||||
cur_option_name = self._optionxform(cur_option.name)
|
||||
else:
|
||||
cur_option_name = cur_option.name
|
||||
if cur_section_name == DEFAULTSECT:
|
||||
optobj = self._defaults
|
||||
else:
|
||||
optobj = self._sections[cur_section_name]
|
||||
optobj._options[cur_option_name] = cur_option
|
||||
|
||||
if isinstance(line_obj, SectionLine):
|
||||
self._data.extend(pending_lines)
|
||||
pending_lines = []
|
||||
pending_empty_lines = False
|
||||
cur_section = LineContainer(line_obj)
|
||||
self._data.add(cur_section)
|
||||
cur_option = None
|
||||
cur_option_name = None
|
||||
if cur_section.name == DEFAULTSECT:
|
||||
self._defaults._lines.append(cur_section)
|
||||
cur_section_name = DEFAULTSECT
|
||||
else:
|
||||
if self._sectionxform:
|
||||
cur_section_name = self._sectionxform(cur_section.name)
|
||||
else:
|
||||
cur_section_name = cur_section.name
|
||||
if cur_section_name not in self._sections:
|
||||
self._sections[cur_section_name] = \
|
||||
INISection(cur_section, defaults=self._defaults,
|
||||
optionxformsource=self)
|
||||
else:
|
||||
self._sections[cur_section_name]._lines.append(cur_section)
|
||||
|
||||
if isinstance(line_obj, (CommentLine, EmptyLine)):
|
||||
pending_lines.append(line_obj)
|
||||
if isinstance(line_obj, EmptyLine):
|
||||
pending_empty_lines = True
|
||||
|
||||
self._data.extend(pending_lines)
|
||||
if line and line[-1] == '\n':
|
||||
self._data.add(EmptyLine())
|
||||
|
||||
if exc:
|
||||
raise exc
|
||||
Reference in New Issue
Block a user