| import datetime |
| import re |
| import sys |
| from decimal import Decimal |
|
|
| from toml.decoder import InlineTableDict |
|
|
| if sys.version_info >= (3,): |
| unicode = str |
|
|
|
|
| def dump(o, f, encoder=None): |
| """Writes out dict as toml to a file |
| |
| Args: |
| o: Object to dump into toml |
| f: File descriptor where the toml should be stored |
| encoder: The ``TomlEncoder`` to use for constructing the output string |
| |
| Returns: |
| String containing the toml corresponding to dictionary |
| |
| Raises: |
| TypeError: When anything other than file descriptor is passed |
| """ |
|
|
| if not f.write: |
| raise TypeError("You can only dump an object to a file descriptor") |
| d = dumps(o, encoder=encoder) |
| f.write(d) |
| return d |
|
|
|
|
| def dumps(o, encoder=None): |
| """Stringifies input dict as toml |
| |
| Args: |
| o: Object to dump into toml |
| encoder: The ``TomlEncoder`` to use for constructing the output string |
| |
| Returns: |
| String containing the toml corresponding to dict |
| |
| Examples: |
| ```python |
| >>> import toml |
| >>> output = { |
| ... 'a': "I'm a string", |
| ... 'b': ["I'm", "a", "list"], |
| ... 'c': 2400 |
| ... } |
| >>> toml.dumps(output) |
| 'a = "I\'m a string"\nb = [ "I\'m", "a", "list",]\nc = 2400\n' |
| ``` |
| """ |
|
|
| retval = "" |
| if encoder is None: |
| encoder = TomlEncoder(o.__class__) |
| addtoretval, sections = encoder.dump_sections(o, "") |
| retval += addtoretval |
| outer_objs = [id(o)] |
| while sections: |
| section_ids = [id(section) for section in sections.values()] |
| for outer_obj in outer_objs: |
| if outer_obj in section_ids: |
| raise ValueError("Circular reference detected") |
| outer_objs += section_ids |
| newsections = encoder.get_empty_table() |
| for section in sections: |
| addtoretval, addtosections = encoder.dump_sections( |
| sections[section], section) |
|
|
| if addtoretval or (not addtoretval and not addtosections): |
| if retval and retval[-2:] != "\n\n": |
| retval += "\n" |
| retval += "[" + section + "]\n" |
| if addtoretval: |
| retval += addtoretval |
| for s in addtosections: |
| newsections[section + "." + s] = addtosections[s] |
| sections = newsections |
| return retval |
|
|
|
|
| def _dump_str(v): |
| if sys.version_info < (3,) and hasattr(v, 'decode') and isinstance(v, str): |
| v = v.decode('utf-8') |
| v = "%r" % v |
| if v[0] == 'u': |
| v = v[1:] |
| singlequote = v.startswith("'") |
| if singlequote or v.startswith('"'): |
| v = v[1:-1] |
| if singlequote: |
| v = v.replace("\\'", "'") |
| v = v.replace('"', '\\"') |
| v = v.split("\\x") |
| while len(v) > 1: |
| i = -1 |
| if not v[0]: |
| v = v[1:] |
| v[0] = v[0].replace("\\\\", "\\") |
| |
| joinx = v[0][i] != "\\" |
| while v[0][:i] and v[0][i] == "\\": |
| joinx = not joinx |
| i -= 1 |
| if joinx: |
| joiner = "x" |
| else: |
| joiner = "u00" |
| v = [v[0] + joiner + v[1]] + v[2:] |
| return unicode('"' + v[0] + '"') |
|
|
|
|
| def _dump_float(v): |
| return "{}".format(v).replace("e+0", "e+").replace("e-0", "e-") |
|
|
|
|
| def _dump_time(v): |
| utcoffset = v.utcoffset() |
| if utcoffset is None: |
| return v.isoformat() |
| |
| return v.isoformat()[:-6] |
|
|
|
|
| class TomlEncoder(object): |
|
|
| def __init__(self, _dict=dict, preserve=False): |
| self._dict = _dict |
| self.preserve = preserve |
| self.dump_funcs = { |
| str: _dump_str, |
| unicode: _dump_str, |
| list: self.dump_list, |
| bool: lambda v: unicode(v).lower(), |
| int: lambda v: v, |
| float: _dump_float, |
| Decimal: _dump_float, |
| datetime.datetime: lambda v: v.isoformat().replace('+00:00', 'Z'), |
| datetime.time: _dump_time, |
| datetime.date: lambda v: v.isoformat() |
| } |
|
|
| def get_empty_table(self): |
| return self._dict() |
|
|
| def dump_list(self, v): |
| retval = "[" |
| for u in v: |
| retval += " " + unicode(self.dump_value(u)) + "," |
| retval += "]" |
| return retval |
|
|
| def dump_inline_table(self, section): |
| """Preserve inline table in its compact syntax instead of expanding |
| into subsection. |
| |
| https://github.com/toml-lang/toml#user-content-inline-table |
| """ |
| retval = "" |
| if isinstance(section, dict): |
| val_list = [] |
| for k, v in section.items(): |
| val = self.dump_inline_table(v) |
| val_list.append(k + " = " + val) |
| retval += "{ " + ", ".join(val_list) + " }\n" |
| return retval |
| else: |
| return unicode(self.dump_value(section)) |
|
|
| def dump_value(self, v): |
| |
| dump_fn = self.dump_funcs.get(type(v)) |
| if dump_fn is None and hasattr(v, '__iter__'): |
| dump_fn = self.dump_funcs[list] |
| |
| return dump_fn(v) if dump_fn is not None else self.dump_funcs[str](v) |
|
|
| def dump_sections(self, o, sup): |
| retstr = "" |
| if sup != "" and sup[-1] != ".": |
| sup += '.' |
| retdict = self._dict() |
| arraystr = "" |
| for section in o: |
| section = unicode(section) |
| qsection = section |
| if not re.match(r'^[A-Za-z0-9_-]+$', section): |
| qsection = _dump_str(section) |
| if not isinstance(o[section], dict): |
| arrayoftables = False |
| if isinstance(o[section], list): |
| for a in o[section]: |
| if isinstance(a, dict): |
| arrayoftables = True |
| if arrayoftables: |
| for a in o[section]: |
| arraytabstr = "\n" |
| arraystr += "[[" + sup + qsection + "]]\n" |
| s, d = self.dump_sections(a, sup + qsection) |
| if s: |
| if s[0] == "[": |
| arraytabstr += s |
| else: |
| arraystr += s |
| while d: |
| newd = self._dict() |
| for dsec in d: |
| s1, d1 = self.dump_sections(d[dsec], sup + |
| qsection + "." + |
| dsec) |
| if s1: |
| arraytabstr += ("[" + sup + qsection + |
| "." + dsec + "]\n") |
| arraytabstr += s1 |
| for s1 in d1: |
| newd[dsec + "." + s1] = d1[s1] |
| d = newd |
| arraystr += arraytabstr |
| else: |
| if o[section] is not None: |
| retstr += (qsection + " = " + |
| unicode(self.dump_value(o[section])) + '\n') |
| elif self.preserve and isinstance(o[section], InlineTableDict): |
| retstr += (qsection + " = " + |
| self.dump_inline_table(o[section])) |
| else: |
| retdict[qsection] = o[section] |
| retstr += arraystr |
| return (retstr, retdict) |
|
|
|
|
| class TomlPreserveInlineDictEncoder(TomlEncoder): |
|
|
| def __init__(self, _dict=dict): |
| super(TomlPreserveInlineDictEncoder, self).__init__(_dict, True) |
|
|
|
|
| class TomlArraySeparatorEncoder(TomlEncoder): |
|
|
| def __init__(self, _dict=dict, preserve=False, separator=","): |
| super(TomlArraySeparatorEncoder, self).__init__(_dict, preserve) |
| if separator.strip() == "": |
| separator = "," + separator |
| elif separator.strip(' \t\n\r,'): |
| raise ValueError("Invalid separator for arrays") |
| self.separator = separator |
|
|
| def dump_list(self, v): |
| t = [] |
| retval = "[" |
| for u in v: |
| t.append(self.dump_value(u)) |
| while t != []: |
| s = [] |
| for u in t: |
| if isinstance(u, list): |
| for r in u: |
| s.append(r) |
| else: |
| retval += " " + unicode(u) + self.separator |
| t = s |
| retval += "]" |
| return retval |
|
|
|
|
| class TomlNumpyEncoder(TomlEncoder): |
|
|
| def __init__(self, _dict=dict, preserve=False): |
| import numpy as np |
| super(TomlNumpyEncoder, self).__init__(_dict, preserve) |
| self.dump_funcs[np.float16] = _dump_float |
| self.dump_funcs[np.float32] = _dump_float |
| self.dump_funcs[np.float64] = _dump_float |
| self.dump_funcs[np.int16] = self._dump_int |
| self.dump_funcs[np.int32] = self._dump_int |
| self.dump_funcs[np.int64] = self._dump_int |
|
|
| def _dump_int(self, v): |
| return "{}".format(int(v)) |
|
|
|
|
| class TomlPreserveCommentEncoder(TomlEncoder): |
|
|
| def __init__(self, _dict=dict, preserve=False): |
| from toml.decoder import CommentValue |
| super(TomlPreserveCommentEncoder, self).__init__(_dict, preserve) |
| self.dump_funcs[CommentValue] = lambda v: v.dump(self.dump_value) |
|
|
|
|
| class TomlPathlibEncoder(TomlEncoder): |
|
|
| def _dump_pathlib_path(self, v): |
| return _dump_str(str(v)) |
|
|
| def dump_value(self, v): |
| if (3, 4) <= sys.version_info: |
| import pathlib |
| if isinstance(v, pathlib.PurePath): |
| v = str(v) |
| return super(TomlPathlibEncoder, self).dump_value(v) |
|
|
