def _send(pipefd, msg, os):
msg = mummy.dumps(msg)
msg = struct.pack('>I', len(msg)) + msg
total = len(msg)
written = 0
while written < total:
written += os.write(pipefd, msg[written:])
def dump_func(f):
code = f.func_code
return mummy.dumps(
(code.co_argcount, code.co_nlocals, code.co_stacksize, code.co_flags,
code.co_code, code.co_consts, code.co_names, code.co_varnames,
code.co_filename, code.co_name, code.co_firstlineno, code.co_lnotab,
code.co_freevars, code.co_cellvars))
def backwards_compatible(self, val):
print "new", self
new_enc = newmummy.dumps(val)
print "old", self
old_enc = oldmummy.dumps(val)
# they serialize to the same string
self.assertEqual(new_enc, old_enc)
def test_storage_serial(self):
datahog.set_context(6, datahog.NODE, {
'base_ctx': 1, 'storage': datahog.storage.SERIAL,
})
self.assertEqual(
util.storage_wrap(6, ['test', 'path', {10: 0.1}]).adapted,
mummy.dumps(['test', 'path', {10: 0.1}]))
self.assertEqual(
util.storage_unwrap(6, psycopg2.Binary('\x10\x03\x08\x04test\x08\x04path\x13\x01\x02\n\x07?\xb9\x99\x99\x99\x99\x99\x9a')),
['test', 'path', {10: 0.1}])
def dump_func(f):
code = f.func_code
return mummy.dumps((
code.co_argcount,
code.co_nlocals,
code.co_stacksize,
code.co_flags,
code.co_code,
code.co_consts,
code.co_names,
code.co_varnames,
code.co_filename,
code.co_name,
code.co_firstlineno,
code.co_lnotab,
code.co_freevars,
code.co_cellvars))
def storage_wrap(ctx, value):
st = ctx_storage(ctx)
if st == storage.NULL:
if value is not None:
raise error.StorageClassError("NULL requires None")
return None
if st == storage.INT:
if not isinstance(value, (int, long)):
raise error.StorageClassError("INT requires int or long")
return value
if st == storage.STR:
if not isinstance(value, str):
raise error.StorageClassError("STR requires str")
return psycopg2.Binary(value)
if st == storage.UTF:
if not isinstance(value, unicode):
raise error.StorageClassError("UTF storage requires unicode")
return psycopg2.Binary(value.encode("utf8"))
if st == storage.SERIAL:
schema = ctx_schema(ctx)
if schema:
msg = schema(value)
try:
value = msg.dumps()
except schema.InvalidMessage:
raise error.StorageClassError(
"SERIAL schema validation failed", msg.message)
else:
try:
value = mummy.dumps(value)
except TypeError:
raise error.StorageClassError(
"SERIAL requires a serializable value")
return psycopg2.Binary(value)
raise error.BadContext(ctx)
def test(serial, deserial, data):
assert equalish(deserial(serial(data)), data)
def format(flt, prec=3):
s = str(round(flt, prec))
return padright(s, s.index(".") + 4, "0")
def padright(s, upto, padchar=" "):
return s + (padchar * (upto - len(s)))
contenders = [
('mummy', (lambda s: mummy.dumps(s), mummy.loads)),
('oldmummy', (lambda s: oldmummy.dumps(s), oldmummy.loads))]
if wbin:
contenders.append(('wirebin', (wbin.serialize, wbin.deserialize)))
if msgpack:
contenders.append(('msgpack', (msgpack.dumps, msgpack.loads)))
if yajl:
contenders.append(('py-yajl', (yajl.dumps, yajl.loads)))
if cjson:
contenders.append(('cjson', (cjson.encode, cjson.decode)))
if bson:
contenders.append(('bson', (bson.BSON.encode, lambda s: bson.BSON(s).decode())))
#contenders.append(('cPickle (protocol 2)',
# (lambda x: cPickle.dumps(x, 2), cPickle.loads)))
#contenders.append(('cPickle (protocol 1)',
# (lambda x: cPickle.dumps(x, 1), cPickle.loads)))
def deepcopy(item):
return mummy.loads(mummy.dumps(item))
def dump(msg):
msg = mummy.dumps(msg)
return struct.pack("!I", len(msg)) + msg
def dump(msg):
msg = mummy.dumps(msg)
return struct.pack("!I", len(msg)) + msg
def deepcopy(item):
return mummy.loads(mummy.dumps(item))
