def test_round_trip_inst_short(self):
step1 = '#inst "2011"'
step2 = loads(step1)
step3 = dumps(step2)
step4 = loads(step3)
self.assertEqual('#inst "2011-01-01"', step3)
self.assertEqual(datetime.date(2011, 1, 1), step4)
def test_discard_all(self):
for edn_data in (
'42',
'-1',
'nil',
'true',
'false',
'"foo"',
'\\space',
'\\a',
':foo',
':foo/bar',
'[]',
'{}',
'#{}',
'()',
'(a)',
'(a b)',
'[a [[[b] c]] 2]',
'#inst "2017"',
):
self.assertEqual([1], loads('[1 #_ {}]'.format(edn_data)),
edn_data)
self.assertEqual([1], loads('[#_ {} 1]'.format(edn_data)),
edn_data)
self.assertEqual(None, loads('#_ {}'.format(edn_data)))
for coll in ('[%s]', '(%s)', '{%s}', '#{%s}'):
expected = coll % ""
edn_data = coll % '#_ {}'.format(edn_data)
self.assertEqual(expected, dumps(loads(edn_data)), edn_data)
def test_round_trip_inst_short(self):
step1 = '#inst "2011"'
step2 = loads(step1)
step3 = dumps(step2)
step4 = loads(step3)
self.assertEqual('#inst "2011-01-01"', step3)
self.assertEqual(datetime.date(2011, 1, 1), step4)
def test_custom_tags(self):
@tag("dog")
def parse_dog(name):
return {
"kind": "dog",
"name": name,
"message": "woof-woof",
}
@tag("cat")
class Cat(TaggedElement):
def __init__(self, name):
self.name = name
dog = loads("#dog \"Max\"")
self.assertEqual({
"kind": "dog",
"name": "Max",
"message": "woof-woof"
}, dog)
cat = loads("#cat \"Alex\"")
self.assertIsInstance(cat, Cat)
self.assertEqual("Alex", cat.name)
remove_tag("cat")
self.assertRaises(NotImplementedError, lambda: loads("#cat \"Alex\""))
add_tag("cat", Cat)
cat = loads("#cat \"Alex\"")
self.assertIsInstance(cat, Cat)
self.assertEqual("Alex", cat.name)
def test_dumping(self):
is_exception = False
try:
loads("[1 true nil]")
except AttributeError as x:
is_exception = True
self.assertFalse(is_exception)
def test_dumping(self):
is_exception = False
try:
loads("[1 true nil]")
except AttributeError:
is_exception = True
self.assertFalse(is_exception)
def test_round_trip_sets(self):
step1 = '#{:a (1 2 3) :b}'
step2 = loads(step1)
step3 = dumps(step2)
step4 = loads(step3)
self.assertIn(Keyword("a"), step4)
self.assertIn(Keyword("b"), step4)
self.assertIn((1, 2, 3), step4)
def test_round_trip_sets(self):
step1 = '#{:a (1 2 3) :b}'
step2 = loads(step1)
step3 = dumps(step2)
step4 = loads(step3)
self.assertIn(Keyword("a"), step4)
self.assertIn(Keyword("b"), step4)
self.assertIn((1, 2, 3), step4)
def test_discard_all(self):
for edn_data in (
'42', '-1', 'nil', 'true', 'false', '"foo"', '\\space', '\\a',
':foo', ':foo/bar', '[]', '{}', '#{}', '()', '(a)', '(a b)',
'[a [[[b] c]] 2]', '#inst "2017"',
):
self.assertEqual([1], loads('[1 #_ {}]'.format(edn_data)), edn_data)
self.assertEqual([1], loads('[#_ {} 1]'.format(edn_data)), edn_data)
self.check_eof('#_ {}'.format(edn_data))
for coll in ('[%s]', '(%s)', '{%s}', '#{%s}'):
expected = coll % ""
edn_data = coll % '#_ {}'.format(edn_data)
self.assertEqual(expected, dumps(loads(edn_data)), edn_data)
def getfile(kimid, filename, contentformat='str'):
"""
Gets a file associated with a kim-item.
Parameters
----------
kimid : str
The kim-id associated with the file.
filename : str
The name of the file to download.
contentformat : str
The format to return the file contents as. Supported values are
'str' for str, 'edn' a dict of parsed edn content, ...
Default value is 'str'.
Returns
-------
any
The file contents loaded according to contentformat.
"""
# Download web content
url = 'https://openkim.org/files/' + shortid(kimid) + '/' + filename
r = requests.get(url)
r.raise_for_status()
if contentformat == 'str':
contents = r.text
elif contentformat == 'edn':
contents = edn_format.loads(r.text)
else:
raise ValueError('contentformat value not supported')
return contents
def _parse_edn(self, fname, keys):
""" Wrapper to use end_format to parse output file of 'runner' in edn format.
Parameters
----------
fname: str
Name of the output file of OpenKIM test.
keys: list of str
Keyword in the edn format(think it as a dictionary), whose value will be returned.
"""
with open(fname, "r") as fin:
lines = fin.read()
parsed = edn_format.loads(lines)
values = []
for k in keys:
try:
v = parsed[k]["source-value"]
except KeyError:
raise KeyError('Keyword "{}" not found in {}.'.format(
k, self.outname))
# make it a 1D array
# we expect v as a python built-in object (if numpy object, this will fail)
if isinstance(v, collections.Sequence):
v = np.array(v).flatten()
else:
v = [v]
values.append(v)
return np.concatenate(values)
def test_chained_discards(self):
for expected, edn_data in (
('[]', '[#_ 1 #_ 2 #_ 3]'),
('[]', '[#_ #_ 1 2 #_ 3]'),
('[]', '[#_ #_ #_ 1 2 3]'),
):
self.assertEqual(expected, dumps(loads(edn_data)), edn_data)
def test_chained_discards(self):
for expected, edn_data in (
('[]', '[#_ 1 #_ 2 #_ 3]'),
('[]', '[#_ #_ 1 2 #_ 3]'),
('[]', '[#_ #_ #_ 1 2 3]'),
):
self.assertEqual(expected, dumps(loads(edn_data)), edn_data)
def bootstrap_fixtures(config, backend_uri, fixtures=["./tests/fixtures/messages.edn"]):
bootstrap_schema(config, backend_uri)
parsed_fixtures = []
for fixture in fixtures:
parsed = edn_format.loads(open(fixture).read())
parsed_fixtures += parsed
return transact_fn(config.berossus_url, parsed_fixtures)
def test_round_trip_conversion(self):
EDN_LITERALS = [
[r"\c", '"c"'],
["[ :ghi ]", "[:ghi]"],
["[:a #_foo 42]", "[:a 42]"],
["123N", "123"],
["-123N", "-123"],
["+123", "123"],
["+123N", "123"],
["123.2", "123.2"],
["+32.23M", "32.23M"],
["3.23e10", "32300000000.0"],
['#{:a (1 2 3) :b}', ['#{:a (1 2 3) :b}',
'#{(1 2 3) :a :b}',
'#{:a :b (1 2 3)}',
'#{:b :a (1 2 3)}']]
]
for literal in EDN_LITERALS:
step1 = literal[0]
step2 = loads(step1)
step3 = dumps(step2)
# print step1, "->", step2, "->", step3
if isinstance(literal[1], list):
self.assertIn(step3, literal[1])
else:
self.assertEqual(literal[1], step3)
def test_round_trip_same(self):
EDN_LITERALS = ("nil", "true", "false", '"hello world"', ":keyword",
":+", ":!", ":-", ":_", ":$", ":&", ":=", ":.",
":abc/def", "symbol", "123", "-123", "32.23", "32.23M",
"-32.23M", "-3.903495E-73M", "3.23e-10", "3e+20",
"3E+20M", '["abc"]', '[1]', '[1 "abc"]',
'[1 "abc" true]', '[:ghi]', '(:ghi)',
'[1 "abc" true :ghi]', '(1 "abc" true :ghi)',
'{"a" 2}', '#inst "1985-04-12T23:20:50.000000Z"',
'#inst "2011-10-09"',
'#uuid "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"',
'#date "19/07/1984"', '#{{"a" 1}}',
'#{{"a" #{{:b 2}}}}', '"|"')
class TagDate(TaggedElement):
def __init__(self, value):
super(TagDate, self).__init__()
self.name = 'date'
self.value = datetime.datetime.strptime(value,
"%d/%m/%Y").date()
def __str__(self):
return '#{} "{}"'.format(self.name,
self.value.strftime("%d/%m/%Y"))
add_tag('date', TagDate)
for literal in EDN_LITERALS:
step1 = literal
step2 = loads(step1)
step3 = dumps(step2)
self.assertEqual(step1, step3)
def test_round_trip_same(self):
EDN_LITERALS = (
"nil",
"true",
"false",
'"hello world"',
":keyword",
":+",
":!",
":-",
":_",
":$",
":&",
":=",
":.",
":abc/def",
"symbol",
"123",
"-123",
"32.23",
"32.23M",
"-32.23M",
"3.23e-10",
'["abc"]',
'[1]',
'[1 "abc"]',
'[1 "abc" true]',
'[:ghi]',
'(:ghi)',
'[1 "abc" true :ghi]',
'(1 "abc" true :ghi)',
'{"a" 2}',
'#inst "1985-04-12T23:20:50Z"',
'#uuid "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"',
'#date "19/07/1984"',
'#{{"a" 1}}',
'#{{"a" #{{:b 2}}}}',
'"|"'
)
class TagDate(TaggedElement):
def __init__(self, value):
self.name = 'date'
self.value = datetime.datetime.strptime(
value,
"%d/%m/%Y").date()
def __str__(self):
return '#{} "{}"'.format(
self.name,
self.value.strftime("%d/%m/%Y"))
add_tag('date', TagDate)
for literal in EDN_LITERALS:
step1 = literal
step2 = loads(step1)
step3 = dumps(step2)
# print step1, "->", step2, "->", step3
self.assertEqual(step1, step3)
def check_char(self, expected, name):
edn_data = "\\{}".format(name)
parsed = loads(edn_data)
self.assertIsInstance(parsed, unicode)
self.assertEqual(expected, parsed, edn_data)
self.assertIsInstance(parsed, Char)
self.assertEqual(Char(expected), parsed, edn_data)
def test_set_roundtrip(self):
rt_value = dumps(loads('#{:a (1 2 3) :b}'))
possible_vals = ['#{:a (1 2 3) :b}',
'#{:a :b (1 2 3)}',
'#{(1 2 3) :a :b}',
'#{(1 2 3) :b :a}',
'#{:b (1 2 3) :a}',
'#{:b :a (1 2 3)}']
self.assertIn(rt_value, possible_vals)
def test_fractions(self):
for edn_data in (
'0/1',
'1/1',
'1/2',
'1/3',
'-5/3',
'99999999999999999999999999999999999/999999999999999999999999991',
):
self.assertEqual(edn_data, dumps(loads(edn_data)), edn_data)
def consume_input():
raw_message = raw_input()
eprint(raw_message)
message = dict(edn.loads(raw_message))
op = message[edn.Keyword("f")]
op_val = None
if edn.Keyword("value") in message:
op_val = dict(message[edn.Keyword("value")])
message[edn.Keyword("value")] = op_val
return message, op, op_val
def test_fractions(self):
for edn_data in (
'0/1',
'1/1',
'1/2',
'1/3',
'-5/3',
'99999999999999999999999999999999999/999999999999999999999999991',
):
self.assertEqual(edn_data, dumps(loads(edn_data)), edn_data)
def main():
ednFile = "MattPublic.edn"
with open(ednFile, 'r+') as f:
content = f.read()
# split out unneeded info from beginning and end of file
content = content.split(":datoms ")[1][:-1]
data = edn_format.loads(content)
print(type(data))
search = 24
# for sublist in data:
# if sublist[0] == search:
# print(type(sublist[1]._name))
pages = []
search = 'node/title'
for sublist in data:
if sublist[1]._name == search:
# print(sublist[2])
individPage = {}
for s in data:
if s[0] == sublist[0]:
individPage["entity/id"] = s[0]
# testPage.append(sublist)
if s[1]._name == "block/children":
child = searchChildren(s[2])
individPage.setdefault("children", []).append(child)
elif s[1]._name == "node/title":
individPage["title"] = str(s[2])
elif s[1]._name == "edit/time":
individPage["edit-time"] = int(s[2])
elif s[1]._name == "create/time":
individPage["create-time"] = int(s[2])
elif s[1]._name == "block/uid":
individPage["uid"] = str(s[2])
elif s[1]._name == "block/string":
individPage["string"] = str(s[2])
elif s[1]._name == "block/heading":
individPage["heading"] = int(s[2])
elif s[1]._name == "block/text-align":
individPage["text-align"] = str(s[2])
elif s[1]._name == "children/view-type":
individPage["view-type"] = str(s[2])
elif s[1]._name == "block/order":
individPage["order"] = int(s[2])
else:
individPage[str(s[1]._name)] = str(s[2])
pages.append(individPage)
with open('About.json', 'w') as f:
# todo sort by block/
json.dump(pages,
f,
indent=4,
separators=(',', ': '),
ensure_ascii=False)
def test_round_trip_same(self):
EDN_LITERALS = (
"nil",
"true",
"false",
'"hello world"',
":keyword",
":+",
":!",
":-",
":_",
":$",
":&",
":=",
":.",
":abc/def",
#"symbol",
"123",
"-123",
"32.23",
"32.23M",
"-32.23M",
"3.23e-10",
'["abc"]',
'[1]',
'[1 "abc"]',
'[1 "abc" true]',
'[:ghi]',
'(:ghi)',
'[1 "abc" true :ghi]',
'(1 "abc" true :ghi)',
#'#myapp/Person {:first "Fred" :last "Mertz',
'#inst "1985-04-12T23:20:50Z"',
'#uuid "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"',
'#date "19/07/1984"')
class TagDate(TaggedElement):
def __init__(self, value):
self.name = 'date'
self.value = datetime.datetime.strptime(value,
"%d/%m/%Y").date()
def __str__(self):
return '#{} "{}"'.format(self.name,
self.value.strftime("%d/%m/%Y"))
add_tag('date', TagDate)
for literal in EDN_LITERALS:
step1 = literal
step2 = loads(step1)
step3 = dumps(step2)
# print step1, "->", step2, "->", step3
self.assertEqual(step1, step3)
def edn_loads_clean(x):
def _clean_key(k):
return k.name if isinstance(k, edn_format.Keyword) else k
def _clean_dict(xs):
if isinstance(xs, (dict, edn_format.immutable_dict.ImmutableDict)):
return {_clean_key(k): _clean_dict(v) for k, v in xs.items()}
elif isinstance(xs, (list, tuple, edn_format.immutable_list.ImmutableList)):
return [_clean_dict(x) for x in xs]
else:
return _clean_key(xs)
return _clean_dict(edn_format.loads(x))
def parse_recipe(recipe_str):
parsed = edn.loads('{' + recipe_str + '}')
parse_kws = lambda d: {k.name: d.dict[k] for k in d.dict.keys()}
recipe = parse_kws(parsed)
ings = parse_ingredients(recipe['ingredients'])
title = edn.dumps(recipe['title'])
return {
'title': title,
'ingredients': ings,
'description': recipe['description']
}
def send_stuff(self, port, painload):
self.logger.info("Sending %s", str(painload))
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((self._ip, port))
sock.sendall(edn_format.dumps(
{Keyword(k): v for k, v in painload.items()}).encode('utf8'))
response = sock.recv(65535)
self.logger.info('begin response')
self.logger.info(response.decode('utf8'))
self.logger.info('end response')
val = edn_format.loads(response.decode('utf8') + " ")
sock.close()
return val
def compare_file(output: str, f: File) -> List[dto.Assertion]:
with open(output) as out:
out_text = out.read()
loaded_edn = edn_format.loads_all(out_text)
parsed_edn = to_edn(f)
results = []
for (l, p) in zip(loaded_edn, parsed_edn):
parsed_typed = edn_format.loads(edn_format.dumps(p))
results.append(
dto.Assertion(l, parsed_typed, edn_format.dumps(l),
edn_format.dumps(p)))
return results
def decode_edn_msg(self, msg):
"""Decodes a TCP message from Carabiner to python dictionary"""
msg = msg.decode()
striped_msg = msg[msg.index('{'):]
decoded_msg = edn_format.loads(striped_msg)
# Because the edf_format package does not return normal dam dicts (or string keywords). What dicts.
if type(decoded_msg) is edn_format.immutable_dict.ImmutableDict:
decoded_dict = {}
for key, value in decoded_msg.dict.items():
print()
decoded_dict[str(key).strip(':')] = value
decoded_msg = decoded_dict
return decoded_msg
def updateVmServiceImage(windowsVersions):
vmServiceRepo = "github.com/circleci/vm-service.git"
vmConfigFile = "config/config.edn"
vmChartFile = "chrats/vm-service/templates/vm-service-config.yaml"
vmServiceGit = Gitter("vm_service", vmServiceRepo, "windows-update/" + str(uuid4()))
vmServiceGit.clone()
vmServiceGit.branch()
vmConfigPath = os.path.join(vmServiceGit.repoDir, vmConfigFile)
vmChartPath = os.path.join(vmServiceGit.repoDir, vmChartFile)
chartData = YAML()
chartConfig = None
config = None
with open(vmChartPath, 'r') as chartFile:
imageStubs = ["windows-server-2019-vs2019:", "windows-server-2019-nvidia-small:",
"windows-server-2019-nvidia-medium:", "windows-server-2019-nvidia-large:"]
imageTags = ["stable", "edge", "canary"]
chartConfig = loads(chartData.load(chartFile)["data"]) # image config is in EDN format
vmImages = chartConfig[Keyword("vm-manager")][Keyword("images")]
for i in imageStubs:
for tag in imageTags:
vmImages[i+tag] = windowsVersions[i]
chartConfig[Keyword("vm-manager")][Keyword("images")] = vmImages
with open(vmConfigPath, 'r') as configFile:
config = loads(configFile.read())
configImages = config[Keyword("vm-manager")][Keyword("images")]["gce"]
configImages["windows-server-2019:e2e-test"] = windowsVersions["windows-server-2019-base"]
configImages["windows-server-2019-vs2019:e2e-test"] = windowsVersions["windows-server-2019-nvidia-small"]
def decode_edn_msg(self, msg):
"""Decodes a TCP message from Carabiner to python dictionary"""
msg = msg.decode()
msg_type = msg[:msg.index(' ')]
try:
striped_msg = msg[msg.index('{'):]
decoded_msg = edn_format.loads(striped_msg, write_ply_tables=False)
except:
decoded_msg = ""
# Because the edn_format package does not return normal dam dicts (or string keywords). What dicts.
if type(decoded_msg) is edn_format.immutable_dict.ImmutableDict:
decoded_msg = {
str(key).strip(':'): value
for key, value in decoded_msg.dict.items()
}
return msg_type, decoded_msg
def rest(self, method, uri, data=None, status_codes=None, parse=True, **kwargs):
""" Rest helpers
"""
r = self.pool.request_encode_body(method, uri, fields=data, encode_multipart=False)
if not r.status in (status_codes if status_codes else (200,201)):
print(cl('\n---------\nURI / REQUEST TYPE : %s %s' % (uri, method), 'red'))
print(cl(data, 'red'))
print(r.headers)
raise Exception("Invalid status code: %s" % r.status)
if not parse:
" return raw urllib3 response"
return r
if not self.debug_loads:
" return parsed edn"
return loads(r.data)
"time edn parse time and return parsed edn"
return self.debug(loads, args=(r_data, ), kwargs={},
fmt='<<< parsed edn datastruct in {ms}ms', color='green')
def test_round_trip_conversion(self):
edn_literals = [
["[ :ghi ]", "[:ghi]"],
["[:a #_foo 42]", "[:a 42]"],
["123N", "123"],
["-123N", "-123"],
["+123", "123"],
["+123N", "123"],
["123.2", "123.2"],
["+32.23M", "32.23M"],
["3.23e10", "32300000000.0"],
["3e10", "30000000000.0"],
]
for literal in edn_literals:
step1 = literal[0]
step2 = loads(step1)
step3 = dumps(step2)
self.assertEqual(literal[1], step3)
def get_openkim_citation(p, it, col):
extent, error = col.cache_list_of_item_metadata_files(it, p)
if error == 0:
cite_lst = []
for i in range(extent):
out = col.get_item_metadata_file(i)
file_name, file_length, file_raw_data, avail_as_str, file_str, error = out
if file_name == "kimspec.edn":
edn_dict = edn_format.loads(file_str)
if "source-citations" in edn_dict.keys():
for cite in edn_dict["source-citations"]:
cite_dict = {k: cite[k] for k in ["title", "volume", "year", "journal", "doi"] if k in cite.keys()}
cite_dict["author"] = cite['author'].split("and")
if "issue" in cite.keys():
cite_dict["number"] = cite["issue"]
name = cite_dict["author"][0].split()[-1] + "_" + cite_dict["year"]
cite_lst.append({name: cite_dict})
return cite_lst
else:
return []
def next_data(din, dout):
skip = False
data = None
if isinstance(din, LineMapper):
return din.next_data()
unit = din.readline()
end = not bool(unit)
if end:
return skip, end, data
try:
data = edn_format.loads(unit)
except SyntaxError as err:
print_error(str(err), 500, dout)
skip = True
return skip, end, data
def next_data(din, dout):
skip = False
data = None
if isinstance(din, LineMapper):
return din.next_data()
unit = din.readline()
end = not bool(unit)
if end:
return skip, end, data
try:
data = edn_format.loads(unit)
except SyntaxError as err:
print_error(str(err), 500, dout)
skip = True
return skip, end, data
def test_discard(self):
for expected, edn_data in (
('[x]', '[x #_ z]'),
('[z]', '[#_ x z]'),
('[x z]', '[x #_ y z]'),
('{1 4}', '{1 #_ 2 #_ 3 4}'),
('[1 2]', '[1 #_ [ #_ [ #_ [ #_ [ #_ 42 ] ] ] ] 2 ]'),
('[1 2 11]', '[1 2 #_ #_ #_ #_ 4 5 6 #_ 7 #_ #_ 8 9 10 11]'),
('()', '(#_(((((((1))))))))'),
('[6]', '[#_ #_ #_ #_ #_ 1 2 3 4 5 6]'),
('[4]', '[#_ #_ 1 #_ 2 3 4]'),
('{:a 1}', '{:a #_:b 1}'),
('[42]', '[42 #_ {:a [1 2 3 4] true false 1 #inst "2017"}]'),
('#{1}', '#{1 #_foo}'),
('"#_ foo"', '"#_ foo"'),
(r'[\# _]', r'[\#_]'),
('[_]', r'[#_\#_]'),
('[1]', '[1 #_\n\n42]'),
('{}', '{#_ 1}'),
):
self.assertEqual(expected, dumps(loads(edn_data)), edn_data)
def test_discard(self):
for expected, edn_data in (
('[x]', '[x #_ z]'),
('[z]', '[#_ x z]'),
('[x z]', '[x #_ y z]'),
('{1 4}', '{1 #_ 2 #_ 3 4}'),
('[1 2]', '[1 #_ [ #_ [ #_ [ #_ [ #_ 42 ] ] ] ] 2 ]'),
('[1 2 11]', '[1 2 #_ #_ #_ #_ 4 5 6 #_ 7 #_ #_ 8 9 10 11]'),
('()', '(#_(((((((1))))))))'),
('[6]', '[#_ #_ #_ #_ #_ 1 2 3 4 5 6]'),
('[4]', '[#_ #_ 1 #_ 2 3 4]'),
('{:a 1}', '{:a #_:b 1}'),
('[42]', '[42 #_ {:a [1 2 3 4] true false 1 #inst "2017"}]'),
('#{1}', '#{1 #_foo}'),
('"#_ foo"', '"#_ foo"'),
('["#" _]', r'[\#_]'),
('[_]', r'[#_\#_]'),
('[1]', '[1 #_\n\n42]'),
('{}', '{#_ 1}'),
):
self.assertEqual(expected, dumps(loads(edn_data)), edn_data)
def parse_edn_spec_file(path: Path) -> dict:
"""Find a possible API param examples in a debug .edn file.
If the keyword has a 'type', 'example', and 'description' property
then it's considered to be an API param.
Example of entry in edn:
`{:name {:description "Product", :type "string", :example "Whiskey"}}`
It will be parsed to {"name": "Whiskey"}
"""
import edn_format
from edn_format import Keyword
from edn_format.immutable_dict import ImmutableDict
edn = edn_format.loads(path.read_text())
edn_dump = {}
def search(current_dict: dict):
for key in current_dict.keys():
data = current_dict[key]
if not isinstance(data, ImmutableDict):
continue
param_type = data.get(Keyword('type'))
param_example = data.get(Keyword('example'))
param_description = data.get(Keyword('description'))
if param_type and param_example:
param_key = key.name.replace('?', '')
if param_type == 'array':
param_value = ast.literal_eval(param_example)
else:
param_value = str(param_example)
edn_dump[param_key] = param_value
elif param_type and param_description:
param_key = key.name.replace('?', '')
edn_dump[param_key] = 'STUB'
else:
search(current_dict[key])
search(edn)
return edn_dump
def test_round_trip_conversion(self):
EDN_LITERALS = [
[r"\c", '"c"'],
["[ :ghi ]", "[:ghi]"],
["[:a #_foo 42]", "[:a 42]"],
["123N", "123"],
["-123N", "-123"],
["+123", "123"],
["+123N", "123"],
["123.2", "123.2"],
["+32.23M", "32.23M"],
["3.23e10", "32300000000.0"],
["3e10", "30000000000.0"],
]
for literal in EDN_LITERALS:
step1 = literal[0]
step2 = loads(step1)
step3 = dumps(step2)
if isinstance(literal[1], list):
self.assertIn(step3, literal[1])
else:
self.assertEqual(literal[1], step3)
def test_keyword_keys(self):
unchanged = (
None,
True,
1,
"foo",
{},
{True: 42},
{25: 42},
{3.14: "test"},
{Keyword("foo"): "something"},
{Symbol("foo"): "something"},
["foo", "bar"],
("foo", "bar"),
{1: {2: 3}},
ImmutableDict({1: 2}),
)
for case in unchanged:
self.check_roundtrip(case, keyword_keys=True)
keyworded_keys = (
("{:foo 42}", {"foo": 42}),
("{:a {:b {:c 42} :d 1}}", {"a": {"b": {"c": 42}, "d": 1}}),
("[{:a 42} {:b 25}]", [{"a": 42}, {"b": 25}]),
("({:a 42} {:b 25})", ({"a": 42}, {"b": 25})),
("{1 [{:a 42}]}", {1: [{"a": 42}]}),
("{:foo 1}", ImmutableDict({"foo": 1})),
)
for expected, data in keyworded_keys:
self.assertEqual(expected, dumps(data, keyword_keys=True))
self.assertEqual(
{Keyword("a"): {Keyword("b"): 2}, 3: 4},
loads(dumps({Keyword("a"): {"b": 2}, 3: 4}, keyword_keys=True)))
def test_keyword_keys(self):
unchanged = (
None,
True,
1,
"foo",
{},
{True: 42},
{25: 42},
{3.14: "test"},
{Keyword("foo"): "something"},
{Symbol("foo"): "something"},
["foo", "bar"],
("foo", "bar"),
{1: {2: 3}},
ImmutableDict({1: 2}),
)
for case in unchanged:
self.check_roundtrip(case, keyword_keys=True)
keyworded_keys = (
("{:foo 42}", {"foo": 42}),
("{:a {:b {:c 42} :d 1}}", {"a": {"b": {"c": 42}, "d": 1}}),
("[{:a 42} {:b 25}]", [{"a": 42}, {"b": 25}]),
("({:a 42} {:b 25})", ({"a": 42}, {"b": 25})),
("{1 [{:a 42}]}", {1: [{"a": 42}]}),
("{:foo 1}", ImmutableDict({"foo": 1})),
)
for expected, data in keyworded_keys:
self.assertEqual(expected, dumps(data, keyword_keys=True))
self.assertEqual(
{Keyword("a"): {Keyword("b"): 2}, 3: 4},
loads(dumps({Keyword("a"): {"b": 2}, 3: 4}, keyword_keys=True)))
def generate_uuid():
return loads("#uuid \"%s\"" % uuid.uuid1())
def parse(self, code):
return edn_format.loads(code)
def check_roundtrip(self, data_input):
self.assertEqual(data_input, loads(dumps(data_input)))
def __str__(self):
return "#myapp/Person " + edn_format.dump(self.value)
edn_format.add_tag("myapp/Person", MyappPerson)
validEdnDir = "../../../../valid-edn"
results = {}
for ednFile in [f for f in listdir(validEdnDir) if isfile(join(validEdnDir, f))]:
ednFileName = ednFile.split(".")[0]
validEdn = open(join(validEdnDir, ednFileName + ".edn"), "r").read()
expectedPy = open(join("..", ednFileName + ".py"), "r").read()
if debug:
print ednFileName
try:
expected = eval(expectedPy)
parsed = edn_format.loads(validEdn)
result = expected == parsed
if not result and debug:
print "Values did not match", "\n\tEXPECTED: ", edn_format.dumps(expected), "\n\tPARSED: ", edn_format.dumps(parsed), "\n\tEDN: ", validEdn
results[edn_format.Symbol(ednFileName)] = result
except:
e = sys.exc_info()[0]
results[edn_format.Symbol(ednFileName)] = False
if debug:
print "\tFailed to parse.", validEdn, e
print edn_format.dumps(results)
def test_exceptions(self):
with self.assertRaises(EDNDecodeError):
loads("{")
def eval(self, string):
ls = loads(string)
ret = unicode(self._eval(ls))
return ret
def check_roundtrip(self, data_input, expected_value, from_python=False):
rt_value = (loads(dumps(data_input)) if from_python else
dumps(loads(data_input)))
self.assertEqual(expected_value, rt_value)
def test_nested_quotes(self):
self.check_roundtrip('nested "quotes"', from_python=True)
self.assertEqual(loads(dumps('nested "quotes"')),
loads(dumps(loads(dumps('nested "quotes"')))))
def inject_id(d, dbid=loads("#db/id[:db.part/user]")):
d[K("db/id")] = dbid
return d
print("<table class='table table-striped table-hover table-responsive'><thead><tr><th>Test</th>")
for n in nemeses:
print("<th><a href='" + cpath + "?filter=*:" + n + "'>" + n + "</a></th>")
print("</tr></thead><tbody>")
for t in tests:
print("<tr><td><a href='" + cpath + "?filter=" + t + ":*'>" + t.replace("cockroachdb-","") + "</a></td>")
for n in nemeses:
print("<td>")
tn = t + ':' + n
dr = sorted([x for x in rl if x[0] == tn])
if len(dr) > 0:
d = dr[-1]
dpath = os.path.join(d[0],d[1])
ednpath = os.path.join(dpath, 'results.edn')
with open(ednpath) as f:
r = edn_format.loads(f.read())
if r is not None:
ok = r[edn_format.Keyword('valid?')]
status = {True:'success',False:'danger'}[ok]
ts = d[1][:-5]
#lfile = os.path.join(dpath, "latency-raw.png")
#if os.path.exists(lfile):
# print("<a href='/" + lfile + "'>"
# "<img height=60px src='/" + lfile + "' />"
# "</a>")
print("<a href='" + cpath + "?entry=" + ts + "#" + ts + "' class='btn btn-%s btn-xs'>" % status + reltime(ts) +
' <span class="glyphicon glyphicon-info-sign"></span>'
"</a>")
print("</td>")
print("</tr>")
print("</tbody></table>")
def test_chars(self):
# 33-126 = printable ASCII range, except space (code 32)
for i in range(33, 127):
ch = chr(i)
edn_data = "\\{}".format(ch)
self.assertEqual(ch, loads(edn_data), edn_data)
cur.execute("delete from projects;")
ordering = []
with open("ordering", "r") as f:
for line in f:
ordering.append(line.strip().lower())
def order(project):
title = project[TITLE].lower()
if title in ordering:
return ordering.index(title)
else:
return len(ordering)
file_names = [f for f in listdir(".") if re.match("^(.*?).clj$", f)]
for file_name in file_names:
with open(file_name, "r") as f:
print file_name
content = f.read()
project = edn.loads(content)
url = project[TITLE].lower()
url = re.sub(" ", "-", url)
url = re.sub("[^\w\-]", "", url)
cur.execute("insert into projects (url, ordering, data) values (%s, %s, %s)",
(url, order(project), content))
db.commit()
def check_eof(self, data_input, **kw):
with self.assertRaises(EDNDecodeError) as ctx:
loads(data_input, **kw)
self.assertEqual('EOF Reached', str(ctx.exception))
def test_discard_syntax_errors(self):
for edn_data in ('#_', '#_ #_ 1', '#inst #_ 2017', '[#_]'):
with self.assertRaises(EDNDecodeError):
loads(edn_data)
def load_edn(path):
with open(path, "r") as f:
return edn_format.loads(f.read())
import edn_format from sys import argv if len(argv) < 1 + 1: print "Supply data file name" exit(1) with open(argv[1], 'r') as f: data_string = f.read() print data_string data = edn_format.loads(data_string) print data
