示例#1
0
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()
示例#2
0
    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
示例#3
0
    @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)
示例#4
0
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'
示例#5
0
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)
示例#7
0
文件: getters.py 项目: apieum/inxpect
        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)
示例#8
0
    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
示例#9
0
    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)
示例#10
0
    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)