Download .venv_haddock/lib/python3.12/site-packages/toml/encoder.py from QPromaQ/Docking_project: direct link, hf CLI and curl.
- Browser
- Download file 9.94 kB
-
https://huggingface.co/datasets/QPromaQ/Docking_project/resolve/main/.venv_haddock/lib/python3.12/site-packages/toml/encoder.py
- Command line
-
hf download hf://datasets/QPromaQ/Docking_project/.venv_haddock/lib/python3.12/site-packages/toml/encoder.py
-
curl -L -o encoder.py https://huggingface.co/datasets/QPromaQ/Docking_project/resolve/main/.venv_haddock/lib/python3.12/site-packages/toml/encoder.py
9.94 kB
| 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("\\\\", "\\") | |
| # No, I don't know why != works and == breaks | |
| 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() | |
| # The TOML norm specifies that it's local time thus we drop the offset | |
| 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): | |
| # Lookup function corresponding to v's type | |
| dump_fn = self.dump_funcs.get(type(v)) | |
| if dump_fn is None and hasattr(v, '__iter__'): | |
| dump_fn = self.dump_funcs[list] | |
| # Evaluate function (if it exists) else return v | |
| 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) | |