def test_deser_speed(self): ser = serpent.dumps(self.data, False) print("deserialize without indent:", timeit.timeit(lambda: serpent.loads(ser), number=1000)) ser = serpent.dumps(self.data, True) print("deserialize with indent:", timeit.timeit(lambda: serpent.loads(ser), number=1000))
def test_exception(self): x = ZeroDivisionError("wrong") ser = serpent.dumps(x) data = serpent.loads(ser) self.assertEqual( { '__class__': 'ZeroDivisionError', '__exception__': True, 'args': ('wrong', ), 'attributes': {} }, data) x = ZeroDivisionError("wrong", 42) ser = serpent.dumps(x) data = serpent.loads(ser) self.assertEqual( { '__class__': 'ZeroDivisionError', '__exception__': True, 'args': ('wrong', 42), 'attributes': {} }, data) x.custom_attribute = "custom_attr" ser = serpent.dumps(x) data = serpent.loads(ser) self.assertEqual( { '__class__': 'ZeroDivisionError', '__exception__': True, 'args': ('wrong', 42), 'attributes': { 'custom_attribute': 'custom_attr' } }, data)
def test_deserialize(self): data = serpent.loads(b"555") self.assertEqual(555, data) unicodestring = "euro" + unichr(0x20ac) encoded = repr(unicodestring).encode("utf-8") data = serpent.loads(encoded) self.assertEqual(unicodestring, data)
def test_trailing_commas(self): v = serpent.loads(b"[1,2,3,]") self.assertEqual([1, 2, 3], v) v = serpent.loads(b"(1,2,3,)") self.assertEqual((1, 2, 3), v) v = serpent.loads(b"{'a':1, 'b':2, 'c':3,}") self.assertEqual({'a': 1, 'b': 2, 'c': 3}, v)
def test_weird_doubles(self): values = [float('inf'), float('-inf'), float('nan')] ser = serpent.dumps(values) values2 = serpent.loads(ser) self.assertEqual([float('inf'), float('-inf'), {'__class__':'float','value':'nan'}], values2) values2 = serpent.loads(b"[1e30000,-1e30000]") self.assertEqual([float('inf'), float('-inf')], values2)
def testCustomClass(self): def something_serializer(obj, serializer, stream, level): d = { "__class__": "Something", "custom": True, "name": obj.name, "value": obj.value } serializer.ser_builtins_dict(d, stream, level) serpent.register_class(Something, something_serializer) s = Something("hello", 42) d = serpent.dumps(s) x = serpent.loads(d) self.assertEqual( { "__class__": "Something", "custom": True, "name": "hello", "value": 42 }, x) serpent.unregister_class(Something) d = serpent.dumps(s) x = serpent.loads(d) self.assertEqual(("bogus", "state"), x)
def test_class(self): class Class1(object): def __init__(self): self.attr = 1 class Class2(object): def __getstate__(self): return {"attr": 42} class SlotsClass(object): __slots__ = ["attr"] def __init__(self): self.attr = 1 c = Class1() ser = serpent.dumps(c) data = serpent.loads(ser) self.assertEqual({'__class__': 'Class1', 'attr': 1}, data) c = Class2() ser = serpent.dumps(c) data = serpent.loads(ser) self.assertEqual({'attr': 42}, data) c = SlotsClass() ser = serpent.dumps(c) data = serpent.loads(ser) self.assertEqual({'__class__': 'SlotsClass', 'attr': 1}, data) import pprint p = pprint.PrettyPrinter(stream="dummy", width=99) ser = serpent.dumps(p) data = serpent.loads(ser) self.assertEqual("PrettyPrinter", data["__class__"]) self.assertEqual(99, data["_width"])
def CancellingOrder(self, IDbin, OrdersBin): try: self.UpdateP() except: print 'Failed: B1getP' try: self.UpdateB2() except: print 'Failed: B1getB2' Orders = serpent.loads(OrdersBin) ID = serpent.loads(IDbin) count = 0 for vektor in self.AllOrders: if vektor[0] == ID: for Order in Orders: if Order in vektor: vektor.remove(Order) count = +1 if count == 0: return 'Sorry, you havent placed an order yet' try: GameShopPrime.UpdateB1() except: print 'Failed: PgetB1' try: GameShopB2.UpdateB1() except: print 'Failed: B2getB1' return serpent.dumps(self.AllOrders)
def test_exception(self): x = ZeroDivisionError("wrong") ser = serpent.dumps(x) data = serpent.loads(ser) self.assertEqual({ '__class__': 'ZeroDivisionError', '__exception__': True, 'args': ('wrong',), 'attributes': {} }, data) x = ZeroDivisionError("wrong", 42) ser = serpent.dumps(x) data = serpent.loads(ser) self.assertEqual({ '__class__': 'ZeroDivisionError', '__exception__': True, 'args': ('wrong', 42), 'attributes': {} }, data) x.custom_attribute = "custom_attr" ser = serpent.dumps(x) data = serpent.loads(ser) self.assertEqual({ '__class__': 'ZeroDivisionError', '__exception__': True, 'args': ('wrong', 42), 'attributes': {'custom_attribute': 'custom_attr'} }, data)
def test_weird_complex(self): c1 = complex(float('inf'), 4) ser = serpent.dumps(c1) c2 = serpent.loads(ser) self.assertEqual(c1, c2) c3 = serpent.loads(b"(1e30000+4.0j)") self.assertEqual(c1, c3)
def test_deser_speed(self): use_set_literals = sys.version_info >= (3, 2) ser = serpent.dumps(self.data, False, set_literals=use_set_literals) print("deserialize without indent:", timeit.timeit(lambda: serpent.loads(ser), number=1000)) ser = serpent.dumps(self.data, True, set_literals=use_set_literals) print("deserialize with indent:", timeit.timeit(lambda: serpent.loads(ser), number=1000))
def test_pickle_api(self): ser = serpent.dumps([1, 2, 3]) serpent.loads(ser) tmpfn = tempfile.mktemp() with open(tmpfn, "wb") as outf: serpent.dump([1, 2, 3], outf, indent=True, set_literals=True) with open(tmpfn, "rb") as inf: data = serpent.load(inf) self.assertEqual([1, 2, 3], data) os.remove(tmpfn)
def test_input_types(self): bytes_input = b"'text'" bytearray_input = bytearray(bytes_input) memview_input = memoryview(bytes_input) self.assertEqual("text", serpent.loads(bytes_input)) self.assertEqual("text", serpent.loads(bytearray_input)) self.assertEqual("text", serpent.loads(memview_input)) if sys.version_info < (3, 0): buffer_input = buffer(bytes_input) self.assertEqual("text", serpent.loads(buffer_input))
def test_comments(self): ser = b"""# serpent utf-8 python2.7 [ 1, 2, # some comments here 3, 4] # more here # and here.""" data = serpent.loads(ser) self.assertEqual([1, 2, 3, 4], data) ser = b"[ 1, 2 ]" # no header whatsoever data = serpent.loads(ser) self.assertEqual([1, 2], data)
def test_bytes(self): if sys.version_info >= (3, 0): ser = serpent.dumps(bytes(b"abcdef")) data = serpent.loads(ser) self.assertEqual({'encoding': 'base64', 'data': 'YWJjZGVm'}, data) ser = serpent.dumps(bytearray(b"abcdef")) data = serpent.loads(ser) self.assertEqual({'encoding': 'base64', 'data': 'YWJjZGVm'}, data) if sys.version_info >= (2, 7): ser = serpent.dumps(memoryview(b"abcdef")) data = serpent.loads(ser) self.assertEqual({'encoding': 'base64', 'data': 'YWJjZGVm'}, data)
def test_dict_iters(self): data = {"john": 22, "sophie": 34, "bob": 26} ser = serpent.loads(serpent.dumps(data.keys())) self.assertIsInstance(ser, list) self.assertEqual(["bob", "john", "sophie"], sorted(ser)) ser = serpent.loads(serpent.dumps(data.values())) self.assertIsInstance(ser, list) self.assertEqual([22, 26, 34], sorted(ser)) ser = serpent.loads(serpent.dumps(data.items())) self.assertIsInstance(ser, list) self.assertEqual([("bob", 26), ("john", 22), ("sophie", 34)], sorted(ser))
def test_enums(self): import enum class Animal(enum.Enum): BEE = 1 CAT = 2 DOG = 3 v = serpent.loads(serpent.dumps(Animal.CAT)) self.assertEqual(2, v) Animal2 = enum.Enum("Animals2", "BEE CAT DOG HORSE RABBIT") v = serpent.loads(serpent.dumps(Animal2.HORSE)) self.assertEqual(4, v)
def test_detectNullByte(self): with self.assertRaises(ValueError) as ex: serpent.loads(b"'contains\x00nullbyte'") self.fail("must fail") self.assertTrue("0-bytes" in str(ex.exception)) with self.assertRaises(ValueError) as ex: serpent.loads(bytearray(b"'contains\x00nullbyte'")) self.fail("must fail") self.assertTrue("0-bytes" in str(ex.exception)) with self.assertRaises(ValueError) as ex: serpent.loads(memoryview(b"'contains\x00nullbyte'")) self.fail("must fail") self.assertTrue("0-bytes" in str(ex.exception)) serpent.loads(bytearray(b"'contains no nullbyte'")) serpent.loads(memoryview(b"'contains no nullbyte'"))
def main(): impl = platform.python_implementation() + "_{0}_{1}".format( sys.version_info[0], sys.version_info[1]) print("IMPL:", impl) with open("data_inputs_utf8.txt", "wb") as out: for source in teststrings: out.write(source.encode("utf-8") + b"\n") results = [] ser = serpent.Serializer() with open("data_" + impl + ".serpent", "wb") as out: for i, source in enumerate(teststrings): data = ser.serialize(source) out.write(data) out.write(b"~\n~\n") assert b"\x00" not in data results.append(data) assert len(results) == len(teststrings) for i, source in enumerate(teststrings): print(i) result = serpent.loads(results[i]) if source != result: print("ERRROR!!! RESULT AFTER serpent.loads IS NOT CORRECT!") print("SOURCE:", repr(source)) print("RESULT:", repr(result)) return print("OK")
def testRegular(self): import pprint p = pprint.PrettyPrinter(stream="dummy", width=42) ser = serpent.dumps(p) data = serpent.loads(ser) self.assertEqual(42, data["_width"]) self.assertEqual("PrettyPrinter", data["__class__"])
def testFile(self): if sys.version_info < (3, 2): self.skipTest("testdatafile contains stuff that is not supported by ast.literal_eval on Python < 3.2") with open("testserpent.utf8.bin", "rb") as file: data = file.read() obj = serpent.loads(data) self.assertEqual(-3 + 8j, obj["numbers"][3])
def example(): use_set_literals = sys.version_info >= (3, 2) # check if we can use set literals data = { "tuple": (1, 2, 3), "date": datetime.datetime.now(), "set": {'a', 'b', 'c'}, "class": CustomClass("Sally", 26) } # serialize the object ser = serpent.dumps(data, indent=True, set_literals=use_set_literals) # print it to the screen, but usually you'd save the bytes to a file or transfer them over a network connection print("Serialized data:") print(ser.decode("UTF-8")) # deserialize the bytes and print the objects obj = serpent.loads(ser) print("Deserialized data:") print("tuple:", obj["tuple"]) print("date:", obj["date"]) print("set:", obj["set"]) clazz = obj["class"] print("class attributes: type={0} name={1} age={2}".format( clazz["__class__"], clazz["name"], clazz["age"]))
def example(): use_set_literals = sys.version_info >= ( 3, 2) # check if we can use set literals data = { "tuple": (1, 2, 3), "date": datetime.datetime.now(), "set": {'a', 'b', 'c'}, "class": CustomClass("Sally", 26) } # serialize the object ser = serpent.dumps(data, indent=True, set_literals=use_set_literals) # print it to the screen, but usually you'd save the bytes to a file or transfer them over a network connection print("Serialized data:") print(ser.decode("UTF-8")) # deserialize the bytes and print the objects obj = serpent.loads(ser) print("Deserialized data:") print("tuple:", obj["tuple"]) print("date:", obj["date"]) print("set:", obj["set"]) clazz = obj["class"] print("class attributes: type={0} name={1} age={2}".format( clazz["__class__"], clazz["name"], clazz["age"]))
def testDefaultDict(self): dd = collections.defaultdict(list) dd['a'] = 1 dd['b'] = 2 d = serpent.dumps(dd) dd2 = serpent.loads(d) self.assertEqual({'a': 1, 'b': 2}, dd2)
def testUserDict(self): obj = collections.UserDict() obj['a'] = 1 obj['b'] = 2 d = serpent.dumps(obj) obj2 = serpent.loads(d) self.assertEqual({'a': 1, 'b': 2}, obj2)
def test_nullbytesunicode(self): line = unichr(0) + "null" ser = serpent.dumps(line) data = strip_header(ser) self.assertEqual(b"'\\x00null'", data) data = serpent.loads(ser) self.assertEqual(line, data)
def _fetch_account(self, conn: sqlite3.Connection, account_id: int) -> Account: acc = conn.execute("SELECT * FROM Account WHERE id=?", (account_id,)).fetchone() priv_result = conn.execute("SELECT privilege FROM Privilege WHERE account=?", (account_id,)).fetchall() privileges = {pr["privilege"] for pr in priv_result} storydata_result = conn.execute("SELECT format, data FROM StoryData WHERE account=?", (account_id,)).fetchone() if storydata_result: if storydata_result["format"] == "json": storydata = json.loads(storydata_result["data"], encoding="utf-8") elif storydata_result["format"] == "serpent": storydata = serpent.loads(storydata_result["data"]) else: raise ValueError("invalid storydata format in database: " + storydata_result["format"]) if not isinstance(storydata, dict): raise TypeError("storydata should be a dict") else: storydata = {} stats_result = dict(conn.execute("SELECT * FROM CharStat WHERE account=?", (account_id,)).fetchone() or {}) del stats_result["id"] del stats_result["account"] stats = base.Stats() for key, value in stats_result.items(): if hasattr(stats, key): setattr(stats, key, value) else: raise AttributeError("stats doesn't have attribute: " + key) stats.set_stats_from_race() # initialize static stats from races table return Account(acc["name"], acc["email"], acc["pw_hash"], acc["pw_salt"], privileges, acc["created"], acc["logged_in"], bool(acc["banned"]), stats, storydata)
def handle_message(self, message): aid = serpent.loads(message.content) try: del self.agent.fitness_datastore[message.sender] except Exception as e: logging.warning( 'Master could not remove agent from datastore. {0}', e)
def handle_message(self, message): self.__num_children += 1 logging.info('Master got fitness from agent: {0}'.format( message.content)) #try: content = serpent.loads(message.content) self.agent.fitness_datastore[message.sender] = \ { 'timestamp':time.time(), 'fitness':content['fitness'], 'chromosome':content['chromosome'] } logging.info('{0} reports fitness {1}'.format(message.sender, content['fitness'])) # Create sorted list of fitnesses self.agent.sorted_fitnesses = [] for (sender_id, item) in self.agent.fitness_datastore.items(): self.agent.sorted_fitnesses.append({ 'agent_id': sender_id, 'fitness': item['fitness'], 'chromosome': item['chromosome'] }) self.agent.sorted_fitnesses.sort(key=lambda x: x['fitness']) # Calculate mean fitness mean = numpy.mean( map(lambda x: x['fitness'], self.agent.sorted_fitnesses)) logging.info('MASTER AGENT DATA: {0} {1} {2} {3} {4} {5} {6}'.format( time.time(), self.__num_children, self.agent.sorted_fitnesses[0]['fitness'], mean, self.agent.sorted_fitnesses[-1]['fitness'], self.population_diversity(self.agent.sorted_fitnesses), self.agent.mts.ams.population))
def test_unicode_with_escapes(self): line = "euro"+unichr(0x20ac)+"\nlastline\ttab\\@slash" ser = serpent.dumps(line) d = strip_header(ser) self.assertEqual(b"'euro\xe2\x82\xac\\nlastline\\ttab\\\\@slash'", d) data = serpent.loads(ser) self.assertEqual(line, data)
def test_nullbytesstring(self): ser = serpent.dumps(u"\x00null") data = serpent.loads(ser) self.assertEqual("\x00null", data) ser = serpent.dumps(u"\x01") self.assertEqual(b"'\\x01'", strip_header(ser)) data = serpent.loads(ser) self.assertEqual("\x01", data) ser = serpent.dumps(u"\x1f") self.assertEqual(b"'\\x1f'", strip_header(ser)) data = serpent.loads(ser) self.assertEqual("\x1f", data) ser = serpent.dumps(u"\x20") self.assertEqual(b"' '", strip_header(ser)) data = serpent.loads(ser) self.assertEqual(" ", data)
def test_unicode_with_escapes(self): line = "euro" + unichr(0x20ac) + "\nlastline\ttab\\@slash" ser = serpent.dumps(line) d = strip_header(ser) self.assertEqual(b"'euro\xe2\x82\xac\\nlastline\\ttab\\\\@slash'", d) data = serpent.loads(ser) self.assertEqual(line, data)
def PlacingOrder(self, IDbin, OrdersBin): # # Here the update is made try: self.UpdateB2() except: print 'Failed: PgetB2' try: self.UpdateB1() except: print 'Failed: PgetB1' Orders = serpent.loads(OrdersBin) ID = serpent.loads(IDbin) count = 0 for vektor in self.AllOrders: print vektor if vektor[0] == ID: for Order in Orders: if Order in self.products: vektor.append(Order) count = +1 if count == 0: NewCustom = [] NewCustom.append(ID) for Order in Orders: if Order in self.products: NewCustom.append(Order) self.AllOrders.append(NewCustom) # # Here the updated server is try: GameShopB1.UpdateP() except: print 'Failed: B1getP' try: GameShopB2.UpdateP() except: print 'Failed: B2getP' return serpent.dumps(self.AllOrders)
def testIntercept(self): ex = ZeroDivisionError("wrong") ser = serpent.dumps(ex) data = serpent.loads(ser) # default behavior is to serialize the exception to a dict self.assertEqual({'__exception__': True, 'args': ('wrong',), '__class__': 'ZeroDivisionError', 'attributes': {}}, data) def custom_exception_translate(obj, serializer, stream, indent): serializer._serialize("custom_exception!", stream, indent) try: serpent.register_class(Exception, custom_exception_translate) ser = serpent.dumps(ex) data = serpent.loads(ser) self.assertEqual("custom_exception!", data) finally: serpent.unregister_class(Exception)
def testUUID(self): uid = uuid.uuid4() string_uid = str(uid) ser = serpent.dumps(uid) x = serpent.loads(ser) self.assertEqual(string_uid, x) def custom_uuid_translate(obj, serp, stream, level): serp._serialize("custom_uuid!", stream, level) serpent.register_class(uuid.UUID, custom_uuid_translate) try: ser = serpent.dumps(uid) x = serpent.loads(ser) self.assertEqual("custom_uuid!", x) finally: serpent.unregister_class(uuid.UUID)
def testOrderedDict(self): o = collections.OrderedDict() o['apple'] = 1 o['banana'] = 2 o['orange'] = 3 d = serpent.dumps(o) o2 = serpent.loads(d) self.assertEqual({"__class__": "OrderedDict", "items": [('apple', 1), ('banana', 2), ('orange', 3)]}, o2)
def mostrarItems(): print '-------------- LISTA DE TODOS LOS ITEMS --------------' c = servicio.getItems() c = serpent.loads(c) for x in c: print str(x['_data']['id'])+' '+x['_data']['nombre']+' '+str(x['_data']['precio']) print '-------------- ####################### --------------' print ''
def testFile(self): if sys.version_info < (3, 2): self.skipTest( "testdatafile contains stuff that is not supported by ast.literal_eval on Python < 3.2" ) with open("testserpent.utf8.bin", "rb") as file: data = file.read() obj = serpent.loads(data) self.assertEqual(-3 + 8j, obj["numbers"][3])
def mostrarOfertas(): print '-------------- LISTA DE TODAS LAS OFERTAS --------------' c = servicio.getOfertas() c = serpent.loads(c) for x in c: print x['nombre']+' '+x['fecha_ini']+' '+str(x['precio']) for i in x['items']: print i['_data']['nombre']+' '+str(i['_data']['precio']) print '-------------- ####################### --------------' print ''
def testCustomClass(self): def something_serializer(obj, serializer, stream, level): d = { "__class__": "Something", "custom": True, "name": obj.name, "value": obj.value } serializer.ser_builtins_dict(d, stream, level) serpent.register_class(Something, something_serializer) s = Something("hello", 42) d = serpent.dumps(s) x = serpent.loads(d) self.assertEqual({"__class__": "Something", "custom": True, "name": "hello", "value": 42}, x) serpent.unregister_class(Something) d = serpent.dumps(s) x = serpent.loads(d) self.assertEqual(("bogus", "state"), x)
def test_unicode(self): u = "euro" + unichr(0x20ac) self.assertTrue(type(u) is unicode) ser = serpent.dumps(u) data = serpent.loads(ser) self.assertEqual(u, data) ser = serpent.dumps(unicode("quotes'\"")) data = strip_header(ser) self.assertEqual(b"'quotes\\'\"'", data) ser = serpent.dumps(unicode("quotes2'")) data = strip_header(ser) self.assertEqual(b"\"quotes2'\"", data)
def test_exception2(self): x = ZeroDivisionError("wrong") ser = serpent.dumps(x, module_in_classname=True) data = serpent.loads(ser) if sys.version_info < (3, 0): expected_classname = "exceptions.ZeroDivisionError" else: expected_classname = "builtins.ZeroDivisionError" self.assertEqual({ '__class__': expected_classname, '__exception__': True, 'args': ('wrong',), 'attributes': {} }, data)
def testException(self): try: hashlib.new("non-existing-hash-name") except: et, ev, etb = sys.exc_info() tb_lines = traceback.format_exception(et, ev, etb) ev._pyroTraceback = tb_lines ser = serpent.dumps(ev) data = serpent.loads(ser) self.assertTrue(data["__exception__"]) attrs = data["attributes"] self.assertIsInstance(attrs["_pyroTraceback"], list) tb_txt = "".join(attrs["_pyroTraceback"]) self.assertTrue(tb_txt.startswith("Traceback")) self.assertTrue(data["args"][0].startswith("unsupported hash")) self.assertEqual("ValueError", data["__class__"])
def test_unicode_with_escapes_py3(self): ser = serpent.dumps(unicode("\n")) d = strip_header(ser) self.assertEqual(b"'\\n'", d) ser = serpent.dumps(unicode("\a")) d = strip_header(ser) self.assertEqual(b"'\\x07'", d) ser = serpent.dumps("\a"+unichr(0x20ac)) d = strip_header(ser) self.assertEqual(b"'\\x07\xe2\x82\xac'", d) line = "'euro" + unichr(0x20ac) + "\nlastline\ttab\\@slash\a\b\f\n\r\t\v'" ser = serpent.dumps(line) d = strip_header(ser) self.assertEqual(b"\"'euro\xe2\x82\xac\\nlastline\\ttab\\\\@slash\\x07\\x08\\x0c\\n\\r\\t\\x0b'\"", d) data = serpent.loads(ser) self.assertEqual(line, data)
def mostrarMenus(): print '-------------- LISTA DE TODOS LOS MENUS --------------' c = servicio.getMenus() c = serpent.loads(c) for x in c: print x['nombre']+' '+x['fecha_ini']+' '+str(x['precio']) print '-' for i in x['primeros']: print i['_data']['nombre']+' '+str(i['_data']['precio']) print '-' for i in x['segundos']: print i['_data']['nombre']+' '+str(i['_data']['precio']) print '-' for i in x['postres']: print i['_data']['nombre']+' '+str(i['_data']['precio']) print '-------------- ####################### --------------' print ''
def test_string_with_escapes(self): ser = serpent.dumps("\n") d = strip_header(ser) self.assertEqual(b"'\\n'", d) ser = serpent.dumps("\a") d = strip_header(ser) if sys.platform == "cli": self.assertEqual(b"'\\a'", d) # ironpython doesn't use repr() else: self.assertEqual(b"'\\x07'", d) # repr() does this hex escape line = "'hello\nlastline\ttab\\@slash\a\b\f\n\r\t\v'" ser = serpent.dumps(line) d = strip_header(ser) if sys.platform == "cli": self.assertEqual(b"\"'hello\\nlastline\\ttab\\\\@slash\\a\\b\\f\\n\\r\\t\\v'\"", d) # ironpython doesn't use repr() else: self.assertEqual(b"\"'hello\\nlastline\\ttab\\\\@slash\\x07\\x08\\x0c\\n\\r\\t\\x0b'\"", d) # the hex escapes are done by repr() data = serpent.loads(ser) self.assertEqual(line, data)
def loads(content): return all.traverse_and_decode(serpent.loads(content))