def test_unicode_mixin(): obj = UnicodeMixin('test') assert isinstance(obj, UnicodeMixin) assert obj == 'test' # Encode into JSON handlers.register(UnicodeMixin, UnicodeMixinHandler) content = jsonpickle.encode(obj) # Resurrect from JSON new_obj = jsonpickle.decode(content) handlers.unregister(UnicodeMixin) new_obj += ' passed' assert new_obj == 'test passed' assert isinstance(new_obj, UnicodeMixin) assert new_obj.ok()
def restore(self, data): unpickler = self.context restore = unpickler.restore reduced = [restore(i, reset=False) for i in data['__reduce__']] modulename = reduced[0] classname = reduced[1] args = reduced[2] __import__(modulename) module = sys.modules[modulename] factory = getattr(module, classname) return factory(*args) handlers.register(QtCore.QPointF, QReduceHandler) class QtTestCase(unittest.TestCase): def test_QPointF_roundtrip(self): expect = QtCore.QPointF(1.0, 2.0) json = jsonpickle.encode(expect) actual = jsonpickle.decode(json) self.assertEqual(expect, actual) def suite(self): suite = unittest.TestSuite() suite.addSuite(unittest.makeSuite(QtTestCase)) return suite
@staticmethod def getNotSyncedEntries(session, userId, since, usersIds=[]): return session.query(Place).filter( Place.updatedOn > getDateTime(since), Place.ownerId.in_(usersIds)).all() class MyBaseObject(handlers.BaseHandler): def flatten(self, obj, data): state = obj.__dict__.copy() for key in state: if isinstance(state[key], Base): state[key] = state[key].__dict__.copy() del state[key]['_sa_instance_state'] del state[key]['createdOn'] del state['_sa_instance_state'] state.pop('createdOn', None) return state handlers.register(Base, MyBaseObject, base=True) if __name__ == '__main__': engine = create_engine('mysql://root@localhost/wau', echo=True) Base.metadata.create_all(bind=engine) # com = engine.connect() # s = select([User]) # com.execute(s)
class UnicodeMixin(str, Mixin): def __add__(self, rhs): obj = super(UnicodeMixin, self).__add__(rhs) return UnicodeMixin(obj) class UnicodeMixinHandler(handlers.BaseHandler): def flatten(self, obj, data): data['value'] = obj return data def restore(self, obj): return UnicodeMixin(obj['value']) handlers.register(UnicodeMixin, UnicodeMixinHandler) class ExternalHandlerTestCase(unittest.TestCase): def test_unicode_mixin(self): obj = UnicodeMixin('test') self.assertTrue(isinstance(obj, UnicodeMixin)) self.assertEqual(obj, 'test') # Encode into JSON content = jsonpickle.encode(obj) # Resurrect from JSON new_obj = jsonpickle.decode(content) new_obj += ' passed'
class UnicodeMixin(unicode, Mixin): def __add__(self, rhs): obj = super(UnicodeMixin, self).__add__(rhs) return UnicodeMixin(obj) class UnicodeMixinHandler(handlers.BaseHandler): def flatten(self, obj, data): data['value'] = obj return data def restore(self, obj): return UnicodeMixin(obj['value']) handlers.register(UnicodeMixin, UnicodeMixinHandler) class ExternalHandlerTestCase(unittest.TestCase): def test_unicode_mixin(self): obj = UnicodeMixin('test') self.assertEqual(type(obj), UnicodeMixin) self.assertEqual(unicode(obj), unicode('test')) # Encode into JSON content = jsonpickle.encode(obj) # Resurrect from JSON new_obj = jsonpickle.decode(content) new_obj += ' passed'
def setUpJsonpickle(): register(Enum, EnumHandler, base=True)
if not callable(closure): closure = FirstArg() if not isinstance(closure, _getter_): closure = AnonymousFunc(closure) self.closure = closure self.getter = getter def __call__(self, *args, **kwargs): return self.closure(self.getter(*args, **kwargs)) class AsIs(_getter_): def __init__(self, value): self.value = value def __call__(self, *args, **kwargs): return self.value class FirstArg(_getter_): def __call__(self, *args, **kwargs): return args[0] class AttrByName(_getter_): def __init__(self, attr_name): self.attr_name = attr_name def __call__(self, instance, default=None): return getattr(instance, self.attr_name, default) handlers.register(AnonymousFunc, handlers.SimpleReduceHandler)
Returns: Any: data restored from state """ return jsonpickle.Unpickler.restore(state, reset=True, **kwargs) class QuantityHandler(BaseHandler): def flatten(self, obj, state): tpl = obj.to_tuple() tpl = self.context.flatten(tpl, reset=False) state["tpl"] = tpl return state def restore(self, state): tpl = self.context.restore(state["tpl"], reset=False) return ureg.Quantity.from_tuple(tpl) class UnitHandler(BaseHandler): def flatten(self, obj, state): state["units"] = str(obj) return state def restore(self, state): return ureg.Unit(state["units"]) jsonpickle_numpy.register_handlers() register(ureg.Quantity, QuantityHandler, base=True) register(ureg.Unit, UnitHandler, base=True)
rUser = relationship(u'User', primaryjoin='Place.ownerId == User.id') @staticmethod def getNotSyncedEntries(session, userId, since, usersIds=[]): return session.query(Place).filter(Place.updatedOn > getDateTime(since), Place.ownerId.in_(usersIds)).all() class MyBaseObject(handlers.BaseHandler): def flatten(self, obj, data): state = obj.__dict__.copy() for key in state: if isinstance(state[key], Base): state[key] = state[key].__dict__.copy() del state[key]['_sa_instance_state'] del state[key]['createdOn'] del state['_sa_instance_state'] state.pop('createdOn',None) return state handlers.register(Base, MyBaseObject, base=True) if __name__ == '__main__': engine = create_engine('mysql://root@localhost/wau', echo=True) Base.metadata.create_all(bind=engine) # com = engine.connect() # s = select([User]) # com.execute(s)