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