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_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_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 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_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_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_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_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_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 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 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 _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):
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 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 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 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 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_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 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 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))
