mirror of
https://github.com/servo/servo.git
synced 2025-08-05 21:50:18 +01:00
Remove no longer needed Python dependencies
See the parent commit for more information why these were removed tl;dr: these dependencies should now get installed by pip in a virtualenv
This commit is contained in:
Corey Farwell
parent
33f78314d9
commit
b327e9b595
45 changed files with 0 additions and 5758 deletions
|
|
@ -1,21 +0,0 @@
|
|||
The MIT License
|
||||
|
||||
Copyright 2013 Uiri Noyb
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
Metadata-Version: 1.0
|
||||
Name: toml
|
||||
Version: 0.8.2
|
||||
Summary: Python Library for Tom's Obvious, Minimal Language
|
||||
Home-page: https://github.com/uiri/toml
|
||||
Author: Uiri Noyb
|
||||
Author-email: uiri@xqz.ca
|
||||
License: License :: OSI Approved :: MIT License
|
||||
Description: TOML
|
||||
====
|
||||
|
||||
Original repository: https://github.com/uiri/toml
|
||||
|
||||
See also https://github.com/mojombo/toml
|
||||
|
||||
Python module which parses and emits TOML.
|
||||
|
||||
Released under the MIT license.
|
||||
|
||||
Passes https://github.com/BurntSushi/toml-test
|
||||
|
||||
See http://j.xqz.ca/toml-status for up to date test results.
|
||||
|
||||
Current Version of the Specification
|
||||
------------------------------------
|
||||
|
||||
https://github.com/mojombo/toml/blob/v0.2.0/README.md
|
||||
|
||||
QUICK GUIDE
|
||||
-----------
|
||||
|
||||
``pip install toml``
|
||||
|
||||
toml.loads --- takes a string to be parsed as toml and returns the corresponding dictionary
|
||||
|
||||
toml.dumps --- takes a dictionary and returns a string which is the contents of the corresponding toml file.
|
||||
|
||||
|
||||
There are other functions which I use to dump and load various fragments of toml but dumps and loads will cover most usage.
|
||||
|
||||
Example usage:
|
||||
|
||||
.. code:: python
|
||||
|
||||
import toml
|
||||
|
||||
with open("conf.toml") as conffile:
|
||||
config = toml.loads(conffile.read())
|
||||
# do stuff with config here
|
||||
. . .
|
||||
|
||||
Platform: UNKNOWN
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
TOML
|
||||
====
|
||||
|
||||
Original repository: https://github.com/uiri/toml
|
||||
|
||||
See also https://github.com/mojombo/toml
|
||||
|
||||
Python module which parses and emits TOML.
|
||||
|
||||
Released under the MIT license.
|
||||
|
||||
Passes https://github.com/BurntSushi/toml-test
|
||||
|
||||
See http://j.xqz.ca/toml-status for up to date test results.
|
||||
|
||||
Current Version of the Specification
|
||||
------------------------------------
|
||||
|
||||
https://github.com/mojombo/toml/blob/v0.2.0/README.md
|
||||
|
||||
QUICK GUIDE
|
||||
-----------
|
||||
|
||||
``pip install toml``
|
||||
|
||||
toml.loads --- takes a string to be parsed as toml and returns the corresponding dictionary
|
||||
|
||||
toml.dumps --- takes a dictionary and returns a string which is the contents of the corresponding toml file.
|
||||
|
||||
|
||||
There are other functions which I use to dump and load various fragments of toml but dumps and loads will cover most usage.
|
||||
|
||||
Example usage:
|
||||
|
||||
.. code:: python
|
||||
|
||||
import toml
|
||||
|
||||
with open("conf.toml") as conffile:
|
||||
config = toml.loads(conffile.read())
|
||||
# do stuff with config here
|
||||
. . .
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
from distutils.core import setup
|
||||
|
||||
with open("README.rst") as readmefile:
|
||||
readme = readmefile.read()
|
||||
setup(name='toml',
|
||||
version='0.8.2',
|
||||
description="Python Library for Tom's Obvious, Minimal Language",
|
||||
author="Uiri Noyb",
|
||||
author_email="uiri@xqz.ca",
|
||||
url="https://github.com/uiri/toml",
|
||||
py_modules=['toml'],
|
||||
license="License :: OSI Approved :: MIT License",
|
||||
long_description=readme,
|
||||
)
|
||||
|
|
@ -1,643 +0,0 @@
|
|||
import datetime, decimal, re
|
||||
|
||||
class TomlTz(datetime.tzinfo):
|
||||
|
||||
def __new__(self, toml_offset):
|
||||
self._raw_offset = toml_offset
|
||||
self._hours = int(toml_offset[:3])
|
||||
self._minutes = int(toml_offset[4:6])
|
||||
|
||||
def tzname(self, dt):
|
||||
return "UTC"+self._raw_offset
|
||||
|
||||
def utcoffset(self, dt):
|
||||
return datetime.timedelta(hours=self._hours, minutes=self._minutes)
|
||||
|
||||
try:
|
||||
_range = xrange
|
||||
except NameError:
|
||||
unicode = str
|
||||
_range = range
|
||||
basestring = str
|
||||
unichr = chr
|
||||
|
||||
def load(f, _dict=dict):
|
||||
"""Returns a dictionary containing the named file parsed as toml."""
|
||||
if isinstance(f, basestring):
|
||||
with open(f) as ffile:
|
||||
return loads(ffile.read(), _dict)
|
||||
elif isinstance(f, list):
|
||||
for l in f:
|
||||
if not isinstance(l, basestring):
|
||||
raise Exception("Load expects a list to contain filenames only")
|
||||
d = _dict()
|
||||
for l in f:
|
||||
d.append(load(l))
|
||||
r = _dict()
|
||||
for l in d:
|
||||
toml_merge_dict(r, l)
|
||||
return r
|
||||
elif f.read:
|
||||
return loads(f.read(), _dict)
|
||||
else:
|
||||
raise Exception("You can only load a file descriptor, filename or list")
|
||||
|
||||
def loads(s, _dict=dict):
|
||||
"""Returns a dictionary containing s, a string, parsed as toml."""
|
||||
implicitgroups = []
|
||||
retval = _dict()
|
||||
currentlevel = retval
|
||||
if isinstance(s, basestring):
|
||||
try:
|
||||
s.decode('utf8')
|
||||
except AttributeError:
|
||||
pass
|
||||
sl = list(s)
|
||||
openarr = 0
|
||||
openstring = False
|
||||
openstrchar = ""
|
||||
multilinestr = False
|
||||
arrayoftables = False
|
||||
beginline = True
|
||||
keygroup = False
|
||||
keyname = 0
|
||||
delnum = 1
|
||||
for i in range(len(sl)):
|
||||
if sl[i] == '\r' and sl[i+1] == '\n':
|
||||
sl[i] = ' '
|
||||
continue
|
||||
if keyname:
|
||||
if sl[i] == '\n':
|
||||
raise Exception("Key name found without value. Reached end of line.")
|
||||
if openstring:
|
||||
if sl[i] == openstrchar:
|
||||
keyname = 2
|
||||
openstring = False
|
||||
openstrchar = ""
|
||||
continue
|
||||
elif keyname == 1:
|
||||
if sl[i].isspace():
|
||||
keyname = 2
|
||||
continue
|
||||
elif sl[i].isalnum() or sl[i] == '_' or sl[i] == '-':
|
||||
continue
|
||||
elif keyname == 2 and sl[i].isspace():
|
||||
continue
|
||||
if sl[i] == '=':
|
||||
keyname = 0
|
||||
else:
|
||||
raise Exception("Found invalid character in key name: '"+sl[i]+"'. Try quoting the key name.")
|
||||
if sl[i] == "'" and openstrchar != '"':
|
||||
k = 1
|
||||
try:
|
||||
while sl[i-k] == "'":
|
||||
k += 1
|
||||
if k == 3:
|
||||
break
|
||||
except IndexError:
|
||||
pass
|
||||
if k == 3:
|
||||
multilinestr = not multilinestr
|
||||
openstring = multilinestr
|
||||
else:
|
||||
openstring = not openstring
|
||||
if openstring:
|
||||
openstrchar = "'"
|
||||
else:
|
||||
openstrchar = ""
|
||||
if sl[i] == '"' and openstrchar != "'":
|
||||
oddbackslash = False
|
||||
k = 1
|
||||
tripquote = False
|
||||
try:
|
||||
while sl[i-k] == '"':
|
||||
k += 1
|
||||
if k == 3:
|
||||
tripquote = True
|
||||
break
|
||||
while sl[i-k] == '\\':
|
||||
oddbackslash = not oddbackslash
|
||||
k += 1
|
||||
except IndexError:
|
||||
pass
|
||||
if not oddbackslash:
|
||||
if tripquote:
|
||||
multilinestr = not multilinestr
|
||||
openstring = multilinestr
|
||||
else:
|
||||
openstring = not openstring
|
||||
if openstring:
|
||||
openstrchar = '"'
|
||||
else:
|
||||
openstrchar = ""
|
||||
if sl[i] == '#' and not openstring and not keygroup and \
|
||||
not arrayoftables:
|
||||
j = i
|
||||
try:
|
||||
while sl[j] != '\n':
|
||||
sl.insert(j, ' ')
|
||||
sl.pop(j+1)
|
||||
j += 1
|
||||
except IndexError:
|
||||
break
|
||||
if sl[i] == '[' and not openstring and not keygroup and \
|
||||
not arrayoftables:
|
||||
if beginline:
|
||||
if sl[i+1] == '[':
|
||||
arrayoftables = True
|
||||
else:
|
||||
keygroup = True
|
||||
else:
|
||||
openarr += 1
|
||||
if sl[i] == ']' and not openstring:
|
||||
if keygroup:
|
||||
keygroup = False
|
||||
elif arrayoftables:
|
||||
if sl[i-1] == ']':
|
||||
arrayoftables = False
|
||||
else:
|
||||
openarr -= 1
|
||||
if sl[i] == '\n':
|
||||
if openstring or multilinestr:
|
||||
if not multilinestr:
|
||||
raise Exception("Unbalanced quotes")
|
||||
if sl[i-1] == "'" or sl[i-1] == '"':
|
||||
sl.insert(i, sl[i-1])
|
||||
sl.pop(i+1)
|
||||
sl[i-3] = ' '
|
||||
elif openarr:
|
||||
sl.insert(i, ' ')
|
||||
sl.pop(i+1)
|
||||
else:
|
||||
beginline = True
|
||||
elif beginline and sl[i] != ' ' and sl[i] != '\t':
|
||||
beginline = False
|
||||
if not keygroup and not arrayoftables:
|
||||
if sl[i] == '=':
|
||||
raise Exception("Found empty keyname. ")
|
||||
keyname = 1
|
||||
s = ''.join(sl)
|
||||
s = s.split('\n')
|
||||
else:
|
||||
raise Exception("What exactly are you trying to pull?")
|
||||
multikey = None
|
||||
multilinestr = ""
|
||||
multibackslash = False
|
||||
for line in s:
|
||||
line = line.strip()
|
||||
if multikey:
|
||||
if multibackslash:
|
||||
strippedline = line.lstrip(' \t\n')
|
||||
if strippedline == '':
|
||||
continue
|
||||
multilinestr += strippedline
|
||||
else:
|
||||
multilinestr += line
|
||||
multibackslash = False
|
||||
if len(line) > 2 and line[-1] == multilinestr[0] and \
|
||||
line[-2] == multilinestr[0] and line[-3] == multilinestr[0]:
|
||||
value, vtype = load_value(multilinestr)
|
||||
currentlevel[multikey] = value
|
||||
multikey = None
|
||||
multilinestr = ""
|
||||
else:
|
||||
k = len(multilinestr) -1
|
||||
while k > -1 and multilinestr[k] == '\\':
|
||||
multibackslash = not multibackslash
|
||||
k -= 1
|
||||
if multibackslash:
|
||||
multilinestr = multilinestr[:-1]
|
||||
else:
|
||||
multilinestr += "\n"
|
||||
continue
|
||||
if line == "":
|
||||
continue
|
||||
if line[0] == '[':
|
||||
arrayoftables = False
|
||||
if line[1] == '[':
|
||||
arrayoftables = True
|
||||
line = line[2:].split(']]', 1)
|
||||
else:
|
||||
line = line[1:].split(']', 1)
|
||||
if line[1].strip() != "":
|
||||
raise Exception("Key group not on a line by itself.")
|
||||
groups = line[0].split('.')
|
||||
i = 0
|
||||
while i < len(groups):
|
||||
groups[i] = groups[i].strip()
|
||||
if groups[i][0] == '"' or groups[i][0] == "'":
|
||||
groupstr = groups[i]
|
||||
j = i+1
|
||||
while not groupstr[0] == groupstr[-1]:
|
||||
j += 1
|
||||
groupstr = '.'.join(groups[i:j])
|
||||
groups[i] = groupstr[1:-1]
|
||||
j -= 1
|
||||
while j > i:
|
||||
groups.pop(j)
|
||||
j -= 1
|
||||
else:
|
||||
if not re.match(r'^[A-Za-z0-9_-]+$', groups[i]):
|
||||
raise Exception("Invalid group name '"+groups[i]+"'. Try quoting it.")
|
||||
i += 1
|
||||
currentlevel = retval
|
||||
for i in range(len(groups)):
|
||||
group = groups[i]
|
||||
if group == "":
|
||||
raise Exception("Can't have a keygroup with an empty name")
|
||||
try:
|
||||
currentlevel[group]
|
||||
if i == len(groups) - 1:
|
||||
if group in implicitgroups:
|
||||
implicitgroups.remove(group)
|
||||
if arrayoftables:
|
||||
raise Exception("An implicitly defined table can't be an array")
|
||||
elif arrayoftables:
|
||||
currentlevel[group].append(_dict())
|
||||
else:
|
||||
raise Exception("What? "+group+" already exists?"+str(currentlevel))
|
||||
except TypeError:
|
||||
if i != len(groups) - 1:
|
||||
implicitgroups.append(group)
|
||||
currentlevel = currentlevel[-1]
|
||||
try:
|
||||
currentlevel[group]
|
||||
except KeyError:
|
||||
currentlevel[group] = _dict()
|
||||
if i == len(groups) - 1 and arrayoftables:
|
||||
currentlevel[group] = [_dict()]
|
||||
except KeyError:
|
||||
if i != len(groups) - 1:
|
||||
implicitgroups.append(group)
|
||||
currentlevel[group] = _dict()
|
||||
if i == len(groups) - 1 and arrayoftables:
|
||||
currentlevel[group] = [_dict()]
|
||||
currentlevel = currentlevel[group]
|
||||
if arrayoftables:
|
||||
try:
|
||||
currentlevel = currentlevel[-1]
|
||||
except KeyError:
|
||||
pass
|
||||
elif "=" in line:
|
||||
i = 1
|
||||
pair = line.split('=', i)
|
||||
if re.match(r'^[0-9]', pair[-1]):
|
||||
pair[-1] = re.sub(r'([0-9])_(?=[0-9])', r'\1', pair[-1])
|
||||
l = len(line)
|
||||
while pair[-1][0] != ' ' and pair[-1][0] != '\t' and \
|
||||
pair[-1][0] != "'" and pair[-1][0] != '"' and \
|
||||
pair[-1][0] != '[' and pair[-1] != 'true' and \
|
||||
pair[-1] != 'false':
|
||||
try:
|
||||
float(pair[-1])
|
||||
break
|
||||
except ValueError:
|
||||
pass
|
||||
if load_date(pair[-1]) != None:
|
||||
break
|
||||
i += 1
|
||||
prev_val = pair[-1]
|
||||
pair = line.split('=', i)
|
||||
if re.match(r'^[0-9]', pair[-1]):
|
||||
pair[-1] = re.sub(r'([0-9])_(?=[0-9])', r'\1', pair[-1])
|
||||
if prev_val == pair[-1]:
|
||||
raise Exception("Invalid date or number")
|
||||
newpair = []
|
||||
newpair.append('='.join(pair[:-1]))
|
||||
newpair.append(pair[-1])
|
||||
pair = newpair
|
||||
pair[0] = pair[0].strip()
|
||||
if (pair[0][0] == '"' or pair[0][0] == "'") and \
|
||||
(pair[0][-1] == '"' or pair[0][-1] == "'"):
|
||||
pair[0] = pair[0][1:-1]
|
||||
pair[1] = pair[1].strip()
|
||||
if len(pair[1]) > 2 and (pair[1][0] == '"' or pair[1][0] == "'") \
|
||||
and pair[1][1] == pair[1][0] and pair[1][2] == pair[1][0] \
|
||||
and not (len(pair[1]) > 5 and pair[1][-1] == pair[1][0] \
|
||||
and pair[1][-2] == pair[1][0] and \
|
||||
pair[1][-3] == pair[1][0]):
|
||||
k = len(pair[1]) -1
|
||||
while k > -1 and pair[1][k] == '\\':
|
||||
multibackslash = not multibackslash
|
||||
k -= 1
|
||||
if multibackslash:
|
||||
multilinestr = pair[1][:-1]
|
||||
else:
|
||||
multilinestr = pair[1] + "\n"
|
||||
multikey = pair[0]
|
||||
else:
|
||||
value, vtype = load_value(pair[1])
|
||||
try:
|
||||
currentlevel[pair[0]]
|
||||
raise Exception("Duplicate keys!")
|
||||
except KeyError:
|
||||
if multikey:
|
||||
continue
|
||||
else:
|
||||
currentlevel[pair[0]] = value
|
||||
return retval
|
||||
|
||||
def load_date(val):
|
||||
microsecond = 0
|
||||
tz = None
|
||||
if len(val) > 19 and val[19] == '.':
|
||||
microsecond = int(val[20:26])
|
||||
if len(val) > 26:
|
||||
tz = TomlTz(val[26:31])
|
||||
elif len(val) > 20:
|
||||
tz = TomlTz(val[19:24])
|
||||
try:
|
||||
d = datetime.datetime(int(val[:4]), int(val[5:7]), int(val[8:10]), int(val[11:13]), int(val[14:16]), int(val[17:19]), microsecond, tz)
|
||||
except ValueError:
|
||||
return None
|
||||
return d
|
||||
|
||||
def load_unicode_escapes(v, hexbytes, prefix):
|
||||
hexchars = ['0', '1', '2', '3', '4', '5', '6', '7',
|
||||
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
|
||||
skip = False
|
||||
i = len(v) - 1
|
||||
while i > -1 and v[i] == '\\':
|
||||
skip = not skip
|
||||
i -= 1
|
||||
for hx in hexbytes:
|
||||
if skip:
|
||||
skip = False
|
||||
i = len(hx) - 1
|
||||
while i > -1 and hx[i] == '\\':
|
||||
skip = not skip
|
||||
i -= 1
|
||||
v += prefix
|
||||
v += hx
|
||||
continue
|
||||
hxb = ""
|
||||
i = 0
|
||||
hxblen = 4
|
||||
if prefix == "\\U":
|
||||
hxblen = 8
|
||||
while i < hxblen:
|
||||
try:
|
||||
if not hx[i].lower() in hexchars:
|
||||
raise IndexError("This is a hack")
|
||||
except IndexError:
|
||||
raise Exception("Invalid escape sequence")
|
||||
hxb += hx[i].lower()
|
||||
i += 1
|
||||
v += unichr(int(hxb, 16))
|
||||
v += unicode(hx[len(hxb):])
|
||||
return v
|
||||
|
||||
def load_value(v):
|
||||
if v == 'true':
|
||||
return (True, "bool")
|
||||
elif v == 'false':
|
||||
return (False, "bool")
|
||||
elif v[0] == '"':
|
||||
testv = v[1:].split('"')
|
||||
if testv[0] == '' and testv[1] == '':
|
||||
testv = testv[2:-2]
|
||||
closed = False
|
||||
for tv in testv:
|
||||
if tv == '':
|
||||
closed = True
|
||||
else:
|
||||
oddbackslash = False
|
||||
try:
|
||||
i = -1
|
||||
j = tv[i]
|
||||
while j == '\\':
|
||||
oddbackslash = not oddbackslash
|
||||
i -= 1
|
||||
j = tv[i]
|
||||
except IndexError:
|
||||
pass
|
||||
if not oddbackslash:
|
||||
if closed:
|
||||
raise Exception("Stuff after closed string. WTF?")
|
||||
else:
|
||||
closed = True
|
||||
escapes = ['0', 'b', 'f', 'n', 'r', 't', '"', '\\']
|
||||
escapedchars = ['\0', '\b', '\f', '\n', '\r', '\t', '\"', '\\']
|
||||
escapeseqs = v.split('\\')[1:]
|
||||
backslash = False
|
||||
for i in escapeseqs:
|
||||
if i == '':
|
||||
backslash = not backslash
|
||||
else:
|
||||
if i[0] not in escapes and i[0] != 'u' and i[0] != 'U' and \
|
||||
not backslash:
|
||||
raise Exception("Reserved escape sequence used")
|
||||
if backslash:
|
||||
backslash = False
|
||||
for prefix in ["\\u", "\\U"]:
|
||||
if prefix in v:
|
||||
hexbytes = v.split(prefix)
|
||||
v = load_unicode_escapes(hexbytes[0], hexbytes[1:], prefix)
|
||||
for i in range(len(escapes)):
|
||||
if escapes[i] == '\\':
|
||||
v = v.replace("\\"+escapes[i], escapedchars[i])
|
||||
else:
|
||||
v = re.sub("([^\\\\](\\\\\\\\)*)\\\\"+escapes[i], "\\1"+escapedchars[i], v)
|
||||
if v[1] == '"':
|
||||
v = v[2:-2]
|
||||
return (v[1:-1], "str")
|
||||
elif v[0] == "'":
|
||||
if v[1] == "'":
|
||||
v = v[2:-2]
|
||||
return (v[1:-1], "str")
|
||||
elif v[0] == '[':
|
||||
return (load_array(v), "array")
|
||||
else:
|
||||
parsed_date = load_date(v)
|
||||
if parsed_date != None:
|
||||
return (parsed_date, "date")
|
||||
else:
|
||||
itype = "int"
|
||||
digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
|
||||
neg = False
|
||||
if v[0] == '-':
|
||||
neg = True
|
||||
v = v[1:]
|
||||
if '.' in v or 'e' in v:
|
||||
if v.split('.', 1)[1] == '':
|
||||
raise Exception("This float is missing digits after the point")
|
||||
if v[0] not in digits:
|
||||
raise Exception("This float doesn't have a leading digit")
|
||||
v = float(v)
|
||||
itype = "float"
|
||||
else:
|
||||
v = int(v)
|
||||
if neg:
|
||||
return (0 - v, itype)
|
||||
return (v, itype)
|
||||
|
||||
def load_array(a):
|
||||
atype = None
|
||||
retval = []
|
||||
a = a.strip()
|
||||
if '[' not in a[1:-1]:
|
||||
strarray = False
|
||||
tmpa = a[1:-1].strip()
|
||||
if tmpa != '' and tmpa[0] == '"':
|
||||
strarray = True
|
||||
a = a[1:-1].split(',')
|
||||
b = 0
|
||||
if strarray:
|
||||
while b < len(a) - 1:
|
||||
while a[b].strip()[-1] != '"' and a[b+1].strip()[0] != '"':
|
||||
a[b] = a[b] + ',' + a[b+1]
|
||||
if b < len(a) - 2:
|
||||
a = a[:b+1] + a[b+2:]
|
||||
else:
|
||||
a = a[:b+1]
|
||||
b += 1
|
||||
else:
|
||||
al = list(a[1:-1])
|
||||
a = []
|
||||
openarr = 0
|
||||
j = 0
|
||||
for i in range(len(al)):
|
||||
if al[i] == '[':
|
||||
openarr += 1
|
||||
elif al[i] == ']':
|
||||
openarr -= 1
|
||||
elif al[i] == ',' and not openarr:
|
||||
a.append(''.join(al[j:i]))
|
||||
j = i+1
|
||||
a.append(''.join(al[j:]))
|
||||
for i in range(len(a)):
|
||||
a[i] = a[i].strip()
|
||||
if a[i] != '':
|
||||
nval, ntype = load_value(a[i])
|
||||
if atype:
|
||||
if ntype != atype:
|
||||
raise Exception("Not a homogeneous array")
|
||||
else:
|
||||
atype = ntype
|
||||
retval.append(nval)
|
||||
return retval
|
||||
|
||||
def dump(o, f):
|
||||
"""Writes out to f the toml corresponding to o. Returns said toml."""
|
||||
if f.write:
|
||||
d = dumps(o)
|
||||
f.write(d)
|
||||
return d
|
||||
else:
|
||||
raise Exception("You can only dump an object to a file descriptor")
|
||||
|
||||
def dumps(o):
|
||||
"""Returns a string containing the toml corresponding to o, a dictionary"""
|
||||
retval = ""
|
||||
addtoretval, sections = dump_sections(o, "")
|
||||
retval += addtoretval
|
||||
while sections != {}:
|
||||
newsections = {}
|
||||
for section in sections:
|
||||
addtoretval, addtosections = dump_sections(sections[section], section)
|
||||
if addtoretval:
|
||||
retval += "["+section+"]\n"
|
||||
retval += addtoretval
|
||||
for s in addtosections:
|
||||
newsections[section+"."+s] = addtosections[s]
|
||||
sections = newsections
|
||||
return retval
|
||||
|
||||
def dump_sections(o, sup):
|
||||
retstr = ""
|
||||
if sup != "" and sup[-1] != ".":
|
||||
sup += '.'
|
||||
retdict = {}
|
||||
arraystr = ""
|
||||
for section in o:
|
||||
qsection = section
|
||||
if not re.match(r'^[A-Za-z0-9_-]+$', section):
|
||||
if '"' in section:
|
||||
qsection = "'" + section + "'"
|
||||
else:
|
||||
qsection = '"' + 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 = ""
|
||||
arraystr += "[["+sup+qsection+"]]\n"
|
||||
s, d = dump_sections(a, sup+qsection)
|
||||
if s:
|
||||
if s[0] == "[":
|
||||
arraytabstr += s
|
||||
else:
|
||||
arraystr += s
|
||||
while d != {}:
|
||||
newd = {}
|
||||
for dsec in d:
|
||||
s1, d1 = 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 + " = " +
|
||||
str(dump_value(o[section])) + '\n')
|
||||
else:
|
||||
retdict[qsection] = o[section]
|
||||
retstr += arraystr
|
||||
return (retstr, retdict)
|
||||
|
||||
def dump_value(v):
|
||||
if isinstance(v, list):
|
||||
t = []
|
||||
retval = "["
|
||||
for u in v:
|
||||
t.append(dump_value(u))
|
||||
while t != []:
|
||||
s = []
|
||||
for u in t:
|
||||
if isinstance(u, list):
|
||||
for r in u:
|
||||
s.append(r)
|
||||
else:
|
||||
retval += " " + str(u) + ","
|
||||
t = s
|
||||
retval += "]"
|
||||
return retval
|
||||
if isinstance(v, (str, unicode)):
|
||||
v = "%r" % v
|
||||
if v[0] == 'u':
|
||||
v = v[1:]
|
||||
singlequote = v[0] == "'"
|
||||
v = v[1:-1]
|
||||
if singlequote:
|
||||
v = v.replace("\\'", "'")
|
||||
v = v.replace('"', '\\"')
|
||||
v = v.replace("\\x", "\\u00")
|
||||
return str('"'+v+'"')
|
||||
if isinstance(v, bool):
|
||||
return str(v).lower()
|
||||
if isinstance(v, datetime.datetime):
|
||||
return v.isoformat()[:19]+'Z'
|
||||
if isinstance(v, float):
|
||||
return str(v)
|
||||
return v
|
||||
|
||||
def toml_merge_dict(a, b):
|
||||
for k in a:
|
||||
if isinstance(a[k], dict):
|
||||
try:
|
||||
b[k]
|
||||
except KeyError:
|
||||
continue
|
||||
if isinstance(b[k], dict):
|
||||
b[k] = toml_merge_dict(a[k], b[k])
|
||||
else:
|
||||
raise Exception("Can't merge dict and nondict in toml object")
|
||||
a.update(b)
|
||||
return a
|
||||
Loading…
Add table
Add a link
Reference in a new issue