def dump_edn(l): out = "[" for item in l: out += "{" for k, v in item.items(): out += "" + edn_format.dumps(k) + " " + edn_format.dumps( v) + ",\n " if out[-4:] == ",\n ": out = out[:-4] out += "}\n " if out[-2:] == "\n ": out = out[:-2] out += "]\n" return out
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 route_configs_file(): global config_root path = "{}/{}".format(config_root, request.args.get('path')) if request.method == 'GET': txt = open(path).read() return edn.dumps({"contents": txt}) elif request.method == 'PUT': fp = open(path, 'w') fp.write(request.form.get('contents')) return edn.dumps({}) elif request.method == 'OPTIONS': # http/delete calls options then delete return edn.dumps({}) elif request.method == 'DELETE': os.remove(path) return edn.dumps({})
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_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 route_measure(): global sim_pos t = time.time() / 1000.0 sim_pos += 0.1 if sim_pos > 1.0: sim_pos = 0.0 return edn.dumps({"t": t, "Ext-0": random.random(), "Ext-1": random.random() + 1.0, "Ext-2": random.random() + 2.0, "Axis-0-x": sim_pos, "Axis-0-y": 0.0, "Axis-0-z": 0.0, "Axis-0-a": 0.0, "Axis-1-x": -sim_pos, "Axis-1-y": 0.0, "Axis-1-z": 0.0, "Axis-1-a": 0.0, "Axis-2-x": 0.0, "Axis-2-y": sim_pos, "Axis-2-z": 0.0, "Axis-2-a": 0.0, "Axis-3-x": 0.2*(random.random() - 0.5), "Axis-3-y": 0.2*(random.random() - 0.5), "Axis-3-z": max(0.0, 0.2*(random.random() - 0.5)), "Axis-3-a": 0.0})
def run_mk(): global mklauncher global configserver global linuxcnc cmd1 = 'configserver /home/machinekit/Desktop -d'.split() configserver = subprocess.Popen(cmd1) return edn.dumps(status)
def __init__(self): self.output = "{:date " + edn_format.dumps(datetime.datetime.now(pytz.utc)) + " " git = subprocess.Popen(["git log --pretty=format:'%h' -n 1"], shell=True, stdout=subprocess.PIPE).communicate()[0] self.output += ":git-hash \"" + git.decode("ascii") + "\" " self.remove_keys = ["real_path"] self.explict_remap = [["displayname", "display-name"]] self.vehicle_name = None
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 run(): item_pages = api.query_category("Items") for name, page in item_pages.items(): try: code = mw.parse(page, skip_style_tags=True) has_recipes = False craftable = Craftable(name) for recipe in filter_templates(code, "Recipe"): has_recipes = True craftable.add_recipe(template_params_to_dict(recipe)) if not has_recipes: continue has_price = False for infobox_item in filter_templates(code, "Infobox Item"): has_price = True craftable.add_infobox(template_params_to_dict(infobox_item)) if not has_price: continue target_dir = "resources/generated/scraped-craftable" if not os.path.exists(target_dir): os.makedirs(target_dir) with open(f"{target_dir}/{name}.edn", "w") as f: f.write(edn_format.dumps(craftable.to_dict())) except (KeyboardInterrupt, SystemExit): raise except: print("Craftable {} failed:".format(name)) traceback.print_exc()
def _ontology_to_edn(cur_o): """Map an ontology specification to datomic schemas and inputs. """ schema = [] vals = [] for okey, val in cur_o: cur_id = K(okey["term"]) schema.append({ "ident": cur_id, "valueType": K("db.type/%s" % okey["value_type"]), "cardinality": K("db.cardinality/one"), "doc": okey.get("doc", "") }) vals.append((cur_id, val)) return (edn_format.dumps(schema, keyword_keys=True, sort_keys=True), edn_format.dumps(vals, keyword_keys=True, sort_keys=True))
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.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 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 dump_edn_val(v): " edn simple value dump" if isinstance(v, (str, unicode)): return json.dumps(v) elif isinstance(v, E): return unicode(v) else: return dumps(v)
def route_login(): global status if request.method == 'OPTIONS': return edn.dumps({}) if request.method == 'POST': if request.form.get('password') == login_password: return '{:authenticated true :username ' + login_username + '}' else: return '{:authenticated false}'
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 emit(self, g): for param in g.params: output_dict = dict() # lowercase all keywords for key in param.__dict__.keys(): output_dict[key.lower()] = param.__dict__[key] # strip off any leading sillyness on the param name split_name = param.__dict__["name"].split(":") if len(split_name) == 2: self.vehicle_name = split_name[0] name = param.__dict__["name"].split(":")[-1] output_dict["name"] = name # remove any keys we don't really care to share for key in self.remove_keys: output_dict.pop(key, None) # rearrange bitmasks to be a vector with nil's if the bit doesn't have meaning if "bitmask" in output_dict: highest_set_bit = 0 bits = [] for bit in output_dict["bitmask"].split(","): bit_parts = bit.split(":") bit_number = int(bit_parts[0]) bit_parts[0] = bit_number bits.append(bit_parts) if bit_number > highest_set_bit: highest_set_bit = bit_number output_bits = (highest_set_bit + 1) * [None] for bit in bits: output_bits[bit[0]] = bit[1] output_dict["bitmask"] = output_bits # rearrange values into a float indexed map if "values" in output_dict: values = dict() for value in output_dict["values"].split(","): index, description = value.split(":") values[float(index)] = description output_dict["values"] = values # remap range to be a map of floats if "range" in output_dict: low, high = output_dict["range"].split() output_dict["range"] = {"low": float(low), "high": float(high)} # remap the string to a float if "increment" in output_dict: output_dict["increment"] = float(output_dict["increment"]) # do any name changing desired for remap in self.explict_remap: output_dict[remap[1]] = output_dict.pop(remap[0]) self.output += "\"" + name + "\" " + edn_format.dumps( output_dict, keyword_keys=True)
def route_resolve(): global service_log global resolver cmd = 'python /home/machinekit/Desktop/resolve.py'.split() stop_process(resolver) resolver = subprocess.Popen(cmd, stdout=service_log, stderr=service_log) if not status['resolving_services']: status['resolving_services'] = True return edn.dumps(status)
def route_configs(): global config_root config_dirs = glob("{}/*/".format(config_root)) files = map(lambda d: glob("{}*".format(d)), config_dirs) get_f = lambda s: s.split('/')[-1] m_keys = map(lambda p: p.split('/')[-2]+'/', config_dirs) m_vals = map(lambda fs: map(get_f, fs), files) m = dict(zip(m_keys, m_vals)) return edn.dumps(m)
def emit(self, g): for param in g.params: output_dict = dict() # lowercase all keywords for key in param.__dict__.keys(): output_dict[key.lower()] = param.__dict__[key] # strip off any leading sillyness on the param name split_name = param.__dict__["name"].split(":") if len(split_name) == 2: self.vehicle_name = split_name[0] name = param.__dict__["name"].split(":")[-1] output_dict["name"] = name # remove any keys we don't really care to share for key in self.remove_keys: output_dict.pop(key, None) # rearrange bitmasks to be a vector with nil's if the bit doesn't have meaning if "bitmask" in output_dict: highest_set_bit = 0 bits = [] for bit in output_dict["bitmask"].split(","): bit_parts = bit.split(":") bit_number = int(bit_parts[0]) bit_parts[0] = bit_number bits.append(bit_parts) if bit_number > highest_set_bit: highest_set_bit = bit_number output_bits = (highest_set_bit+1)*[None] for bit in bits: output_bits[bit[0]] = bit[1] output_dict["bitmask"] = output_bits # rearrange values into a float indexed map if "values" in output_dict: values = dict() for value in output_dict["values"].split(","): index, description = value.split(":") values[float(index)] = description output_dict["values"] = values # remap range to be a map of floats if "range" in output_dict: low, high = output_dict["range"].split() output_dict["range"] = {"low": float(low), "high": float(high)} # remap the string to a float if "increment" in output_dict: output_dict["increment"] = float(output_dict["increment"]) # do any name changing desired for remap in self.explict_remap: output_dict[remap[1]] = output_dict.pop(remap[0]) self.output += "\"" + name + "\" " + edn_format.dumps(output_dict, keyword_keys=True)
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 __init__(self): self.output = "{:date " + edn_format.dumps( datetime.datetime.now(pytz.utc)) + " " git = subprocess.Popen(["git log --pretty=format:'%h' -n 1"], shell=True, stdout=subprocess.PIPE).communicate()[0] self.output += ":git-hash \"" + git.decode("ascii") + "\" " self.remove_keys = ["real_path"] self.explict_remap = [["displayname", "display-name"]] self.vehicle_name = None
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 route_stop_mk(): global status global mklauncher global configserver global linuxcnc stop_process(mklauncher) stop_process(configserver) stop_process(linuxcnc) stop_process(resolver) if status["mk_running"]: status["mk_running"] = False return edn.dumps(status)
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 dump_edn_val(v): " edn simple value dump" print(v, type(v), repr(E), type(E), isinstance(v, E), isinstance(v, collections.Mapping)) if isinstance(v, str): return json.dumps(v) elif isinstance(v, list): # print('list:map::', list(map(dump_edn_val, v)), repr(list(map(dump_edn_val, v)))) # return json.dumps(list(map(dump_edn_val, v)))#str(v)#json.dumps(list(map(str, v))) print('list:map::', list(map(dump_edn_val, v)), json.dumps(list(map(dump_edn_val, v))), dumps(list(map(dump_edn_val, v)))) return json.dumps(list(map(dump_edn_val, v))) elif isinstance(v, bool): return json.dumps(v) elif isinstance(v, E):#(E, collections.Mapping)): print("E", v, repr(v), v.eid, u':db/id #db/id[:db.part/user %(e)s' % {'e': v.eid}) # return u'#db/id[:db.part/user %(e)s]' % {'e': v.eid} return str(v) elif isinstance(v, int): return v else: print("else", dumps(v)) return dumps(v)
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 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_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 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 generate(self, joint_dict, changed_joint_names, enabled_joint_names, is_blocking=False, keyframe_duration=None, **kwargs): if changed_joint_names: changed_joints = {} for j in changed_joint_names: changed_joints[j] = joint_dict[j] state = {} for j in enabled_joint_names: state[j] = joint_dict[j] edn_map = { "is_blocking" : is_blocking, "state" : state, "changes" : changed_joints } if keyframe_duration: edn_map["duration"] = keyframe_duration return edn_format.dumps(edn_map) else: return ''
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 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 expand_rules(rule_file, params): """Expand rules with ontology lookups to avoid need for SciGraph during runs. """ rules = _read_rules(rule_file) out_rules = [] for r in rules: term = _term_from_rule(r, params["scigraph"], params.get("lookup_db")) term["pat"] = r["pat"].replace("?P<", "?<") if term["pat"] == term["term"]: term["pat"] = "^%s$" % term["pat"] for inherit in ["ns", "units-in-val", "common-key", "chemical"]: if r.get(inherit): term[inherit] = r[inherit] out_rules.append(term) out_file = "%s-finalized.edn" % os.path.splitext(rule_file)[0] with open(out_file, "w") as out_handle: out_handle.write("{:rules\n[\n") for r in out_rules: out_handle.write(edn_format.dumps(r, keyword_keys=True, sort_keys=True) + "\n") out_handle.write("]}") return out_rules
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 check_roundtrip(self, data_input, **kw): self.assertEqual(data_input, loads(dumps(data_input, **kw)))
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)
import requests import edn_format as edn ''' r = requests.get('http://localhost:3001') print(r.text) print(r.content) #print(r.json()) print(edn_format.loads(r.text)) r = requests.post( 'http://localhost:3001', data = edn_format.dumps( {1: [1,2,3,4,5], "asdf": 123} ) ) ''' import sys dat = edn.dumps({ 1: sys.argv[1], "asdf": 123, edn.Symbol("sym"): edn.Keyword(123) }) #print(dir(edn)) for _ in range(10): r = requests.post('http://localhost:3001', data=sys.argv[1])
"</a>") print("</td>") # Version print("<td>") if db_version_file is not None: print("<a href='" + cpath + "?version-details=1&path=" + urllib.parse.quote_plus(db_version_file) + "' class='btn btn-%s btn-xs'>" % status + db_thisver + " <span class='glyphicon glyphicon-info-sign'></span></a>") print("</td>") # Details print("<td>") dtk = edn_format.Keyword('details') if dtk not in r: dtk = edn_format.Keyword('error') if dtk in r: dstr = edn_format.dumps(r[dtk]) if len(dstr) > 60: dstr = dstr[:60] + "... <a href='" + cpath + "?path=" + urllib.parse.quote_plus(ednpath) + "'>(more)</a>" print("<tt class='small'>" + dstr + "</tt>") print("</td>") # Node logs print("<td>") print("<a href='" + cpath + "?path=" + urllib.parse.quote_plus(dpath) + "&merge-logs=1' class='btn btn-%s btn-xs'>" % status + "<span class='glyphicon glyphicon-filter'></span></a>") logs = sorted(glob.glob(os.path.join(dpath, "*/cockroach.stderr"))) if len(logs) > 0: for log in logs: print("<a href='" + cpath + "?path=" + urllib.parse.quote_plus(log) + "' class='btn btn-%s btn-xs'>" % status + "<span class='glyphicon glyphicon-info-sign'></span></a>") print("</td>")
def printer(obj, add_end_unit=True): out.write(edn_format.dumps(obj)) if add_end_unit: out.write(END_UNIT)
def parse_ingredients(ings): Quant = namedtuple('Quant', 'quant unit keyword') parse_ing = lambda ing: [edn.dumps(item) for item in ing] return [Quant(*parse_ing(i)) for i in ings]
def __str__(self): return "#y.E {}".format(edn_format.dumps(self.value))
def running(): status['mk_running'] = (configserver != None and configserver.poll() == None) return edn.dumps(status['mk_running'])
def ping(port): send_data(port, MT_PING) return edn.dumps(status)
def print_error(reason, status, out): err = Error(dict(reason=reason, status=status)) out.write(edn_format.dumps(err)) out.write(END_UNIT)
def __str__(self): return "#y.File {}".format(edn_format.dumps(self.to_dict()))
def route_run_mk(): global status run_mk() if not status["mk_running"]: status["mk_running"] = True return edn.dumps(status)
def route_services_log(): global service_log_path text = open(service_log_path).read() return edn.dumps({"log": text})
def route_status(): global status return edn.dumps(status)
def serialize(data): return edn_format.dumps(data)
def check_dump(self, expected_output, actual_input): if isinstance(expected_output, list): self.assertIn(dumps(actual_input), expected_output) else: self.assertEqual(expected_output, dumps(actual_input))