Python dumpsの例

コード例 #1

ファイル: test_result.py プロジェクト: wido/celery

    def test_reduce(self):
        a1 = self.app.AsyncResult('uuid')
        restored = pickle.loads(pickle.dumps(a1))
        assert restored.id == 'uuid'

        a2 = self.app.AsyncResult('uuid')
        assert pickle.loads(pickle.dumps(a2)).id == 'uuid'

コード例 #2

ファイル: test_result.py プロジェクト: HideMode/celery

    def test_reduce(self):
        a1 = self.app.AsyncResult('uuid')
        restored = pickle.loads(pickle.dumps(a1))
        self.assertEqual(restored.id, 'uuid')

        a2 = self.app.AsyncResult('uuid')
        self.assertEqual(pickle.loads(pickle.dumps(a2)).id, 'uuid')

コード例 #3

ファイル: test_result.py プロジェクト: aliscott/celery

    def test_reduce(self):
        a1 = AsyncResult('uuid', task_name=mytask.name)
        restored = pickle.loads(pickle.dumps(a1))
        self.assertEqual(restored.id, 'uuid')
        self.assertEqual(restored.task_name, mytask.name)

        a2 = AsyncResult('uuid')
        self.assertEqual(pickle.loads(pickle.dumps(a2)).id, 'uuid')

コード例 #4

ファイル: test_result.py プロジェクト: slyons/celery

    def test_reduce(self):
        a1 = self.app.AsyncResult("uuid", task_name=self.mytask.name)
        restored = pickle.loads(pickle.dumps(a1))
        self.assertEqual(restored.id, "uuid")
        self.assertEqual(restored.task_name, self.mytask.name)

        a2 = self.app.AsyncResult("uuid")
        self.assertEqual(pickle.loads(pickle.dumps(a2)).id, "uuid")

コード例 #5

ファイル: test_result.py プロジェクト: harmv/celery

    def test_reduce(self):
        a1 = AsyncResult("uuid", task_name="celery.ping")
        restored = pickle.loads(pickle.dumps(a1))
        self.assertEqual(restored.task_id, "uuid")
        self.assertEqual(restored.task_name, "celery.ping")

        a2 = AsyncResult("uuid")
        self.assertEqual(pickle.loads(pickle.dumps(a2)).task_id, "uuid")

コード例 #6

ファイル: cassandra.py プロジェクト: kornholi/celery

 def _do_store():
     cf = self._get_column_family()
     date_done = datetime.utcnow()
     meta = {"status": status,
             "result": pickle.dumps(result),
             "date_done": date_done.strftime('%Y-%m-%dT%H:%M:%SZ'),
             "traceback": pickle.dumps(traceback)}
     cf.insert(task_id, meta,
               ttl=timedelta_seconds(self.result_expires))

コード例 #7

ファイル: cassandra.py プロジェクト: eldondev/celery

 def _store_result(self, task_id, result, status, traceback=None):
     """Store return value and status of an executed task."""
     cf = self._get_column_family()
     date_done = datetime.utcnow()
     lifetime = self.result_expires.days * 86400 + self.result_expires.seconds
     meta = {"status": status,
             "result": pickle.dumps(result),
             "date_done": date_done.strftime('%Y-%m-%dT%H:%M:%SZ'),
             "traceback": pickle.dumps(traceback)}
     cf.insert(task_id, meta, ttl=lifetime)

コード例 #8

ファイル: cassandra.py プロジェクト: aleszoulek/celery

 def _store_result(self, task_id, result, status, traceback=None):
     """Store return value and status of an executed task."""
     cf = self._get_column_family()
     date_done = datetime.utcnow()
     index_key = 'celery.results.index!%02x' % (
             random.randrange(self._index_shards))
     index_column_name = '%8x!%s' % (time.mktime(date_done.timetuple()),
                                     task_id)
     meta = {"status": status,
             "result": pickle.dumps(result),
             "date_done": date_done.strftime('%Y-%m-%dT%H:%M:%SZ'),
             "traceback": pickle.dumps(traceback)}
     cf.insert(task_id, meta)
     cf.insert(index_key, {index_column_name: status})

コード例 #9

ファイル: mongodb.py プロジェクト: kornholi/celery

    def _store_result(self, task_id, result, status, traceback=None):
        """Store return value and status of an executed task."""
        from pymongo.binary import Binary

        meta = {"_id": task_id,
                "status": status,
                "result": Binary(pickle.dumps(result)),
                "date_done": datetime.now(),
                "traceback": Binary(pickle.dumps(traceback))}

        db = self._get_database()
        taskmeta_collection = db[self.mongodb_taskmeta_collection]
        taskmeta_collection.save(meta, safe=True)

        return result

コード例 #10

ファイル: test_worker.py プロジェクト: Vayana/celery

def create_message(channel, **data):
    data.setdefault('id', uuid())
    channel.no_ack_consumers = set()
    return Message(channel, body=pickle.dumps(dict(**data)),
                   content_type='application/x-python-serialize',
                   content_encoding='binary',
                   delivery_info={'consumer_tag': 'mock'})

コード例 #11

ファイル: __init__.py プロジェクト: psnj/celery

 def test_pickle_app(self):
     changes = dict(THE_FOO_BAR="bars", THE_MII_MAR="jars")
     self.app.conf.update(changes)
     saved = pickle.dumps(self.app)
     self.assertLess(len(saved), 2048)
     restored = pickle.loads(saved)
     self.assertDictContainsSubset(changes, restored.conf)

コード例 #12

ファイル: test_worker.py プロジェクト: AdrianRibao/celery

def create_message(channel, **data):
    data.setdefault("id", uuid())
    channel.no_ack_consumers = set()
    return Message(channel, body=pickle.dumps(dict(**data)),
                   content_type="application/x-python-serialize",
                   content_encoding="binary",
                   delivery_info={"consumer_tag": "mock"})

コード例 #13

ファイル: test_worker.py プロジェクト: OddBloke/celery

def create_message(backend, **data):
    data.setdefault("id", gen_unique_id())
    return Message(
        backend,
        body=pickle.dumps(dict(**data)),
        content_type="application/x-python-serialize",
        content_encoding="binary",
    )

コード例 #14

ファイル: test_app.py プロジェクト: tayfun/celery

 def test_pickle_app(self):
     changes = dict(THE_FOO_BAR="bars", THE_MII_MAR="jars")
     self.app.conf.update(changes)
     saved = pickle.dumps(self.app)
     assert len(saved) < 2048
     restored = pickle.loads(saved)
     for key, value in items(changes):
         assert restored.conf[key] == value

コード例 #15

ファイル: test_worker.py プロジェクト: yyz940922/celery

def create_message(channel, **data):
    data.setdefault('id', uuid())
    m = Message(body=pickle.dumps(dict(**data)),
                channel=channel,
                content_type='application/x-python-serialize',
                content_encoding='binary',
                delivery_info={'consumer_tag': 'mock'})
    m.accept = ['application/x-python-serialize']
    return m

コード例 #16

ファイル: test_app.py プロジェクト: yinlinzh/celery

 def test_pickle_app(self):
     changes = dict(THE_FOO_BAR='bars',
                    THE_MII_MAR='jars')
     self.app.conf.update(changes)
     saved = pickle.dumps(self.app)
     assert len(saved) < 2048
     restored = pickle.loads(saved)
     for key, value in items(changes):
         assert restored.conf[key] == value

コード例 #17

 def test_pickle_app(self):
     changes = {'THE_FOO_BAR': 'bars',
                'THE_MII_MAR': 'jars'}
     self.app.conf.update(changes)
     saved = pickle.dumps(self.app)
     assert len(saved) < 2048
     restored = pickle.loads(saved)
     for key, value in changes.items():
         assert restored.conf[key] == value

コード例 #18

ファイル: test_worker.py プロジェクト: auvipy/celery

def create_message(channel, **data):
    data.setdefault('id', uuid())
    m = Message(body=pickle.dumps(dict(**data)),
                channel=channel,
                content_type='application/x-python-serialize',
                content_encoding='binary',
                delivery_info={'consumer_tag': 'mock'})
    m.accept = ['application/x-python-serialize']
    return m

コード例 #19

ファイル: test_pickle.py プロジェクト: DotNetWebs/celery

    def test_pickle_regular_exception(self):
        exc = None
        try:
            raise RegularException('RegularException raised')
        except RegularException as exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        self.assertTrue(exception)
        self.assertIsInstance(exception, RegularException)
        self.assertTupleEqual(exception.args, ('RegularException raised', ))

コード例 #20

ファイル: test_pickle.py プロジェクト: Scalr/celery

    def test_pickle_regular_exception(self):
        exc = None
        try:
            raise RegularException('RegularException raised')
        except RegularException as exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        assert exception
        assert isinstance(exception, RegularException)
        assert exception.args == ('RegularException raised',)

コード例 #21

    def test_pickle_regular_exception(self):
        exc = None
        try:
            raise RegularException('RegularException raised')
        except RegularException as exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        self.assertTrue(exception)
        self.assertIsInstance(exception, RegularException)
        self.assertTupleEqual(exception.args, ('RegularException raised', ))

コード例 #22

    def test_pickle_regular_exception(self):
        exc = None
        try:
            raise RegularException('RegularException raised')
        except RegularException as exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        assert exception
        assert isinstance(exception, RegularException)
        assert exception.args == ('RegularException raised',)

コード例 #23

ファイル: test_pickle.py プロジェクト: mozilla/webifyme-lib

class TestPickle(unittest.TestCase):
    def test_pickle_regular_exception(self):
        exc = None
        try:
            raise RegularException("RegularException raised")
        except RegularException, exc_:
            exc = exc_

        pickled = pickle.dumps({"exception": exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get("exception")
        self.assertTrue(exception)
        self.assertIsInstance(exception, RegularException)
        self.assertTupleEqual(exception.args, ("RegularException raised", ))

コード例 #24

ファイル: test_pickle.py プロジェクト: wiennat/celery

    def test_pickle_arg_override_exception(self):

        exc = None
        try:
            raise ArgOverrideException('ArgOverrideException raised',
                                       status_code=100)
        except ArgOverrideException as exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        self.assertTrue(exception)
        self.assertIsInstance(exception, ArgOverrideException)
        self.assertTupleEqual(exception.args,
                              ('ArgOverrideException raised', 100))
        self.assertEqual(exception.status_code, 100)

コード例 #25

ファイル: test_app.py プロジェクト: Scalr/celery

    def test_pending_configuration__setattr(self):
        with self.Celery(broker='foo://bar') as app:
            app.conf.task_default_delivery_mode = 44
            app.conf.worker_agent = 'foo:Bar'
            assert not app.configured
            assert app.conf.worker_agent == 'foo:Bar'
            assert app.conf.broker_url == 'foo://bar'
            assert app._preconf['worker_agent'] == 'foo:Bar'

            assert app.configured
            reapp = pickle.loads(pickle.dumps(app))
            assert reapp._preconf['worker_agent'] == 'foo:Bar'
            assert not reapp.configured
            assert reapp.conf.worker_agent == 'foo:Bar'
            assert reapp.configured
            assert reapp.conf.broker_url == 'foo://bar'
            assert reapp._preconf['worker_agent'] == 'foo:Bar'

コード例 #26

ファイル: test_app.py プロジェクト: xmn1986/celery

    def test_pending_configuration__setattr(self):
        with self.Celery(broker='foo://bar') as app:
            app.conf.task_default_delivery_mode = 44
            app.conf.worker_agent = 'foo:Bar'
            self.assertFalse(app.configured)
            self.assertEqual(app.conf.worker_agent, 'foo:Bar')
            self.assertEqual(app.conf.broker_url, 'foo://bar')
            self.assertEqual(app._preconf['worker_agent'], 'foo:Bar')

            self.assertTrue(app.configured)
            reapp = pickle.loads(pickle.dumps(app))
            self.assertEqual(reapp._preconf['worker_agent'], 'foo:Bar')
            self.assertFalse(reapp.configured)
            self.assertEqual(reapp.conf.worker_agent, 'foo:Bar')
            self.assertTrue(reapp.configured)
            self.assertEqual(reapp.conf.broker_url, 'foo://bar')
            self.assertEqual(reapp._preconf['worker_agent'], 'foo:Bar')

コード例 #27

ファイル: test_pickle.py プロジェクト: Scalr/celery

    def test_pickle_arg_override_exception(self):

        exc = None
        try:
            raise ArgOverrideException(
                'ArgOverrideException raised', status_code=100,
            )
        except ArgOverrideException as exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        assert exception
        assert isinstance(exception, ArgOverrideException)
        assert exception.args == ('ArgOverrideException raised', 100)
        assert exception.status_code == 100

コード例 #28

ファイル: test_app.py プロジェクト: HideMode/celery

    def test_pending_configuration__setattr(self):
        with self.Celery(broker='foo://bar') as app:
            app.conf.task_default_delivery_mode = 44
            app.conf.worker_agent = 'foo:Bar'
            self.assertFalse(app.configured)
            self.assertEqual(app.conf.worker_agent, 'foo:Bar')
            self.assertEqual(app.conf.broker_url, 'foo://bar')
            self.assertEqual(app._preconf['worker_agent'], 'foo:Bar')

            self.assertTrue(app.configured)
            reapp = pickle.loads(pickle.dumps(app))
            self.assertEqual(reapp._preconf['worker_agent'], 'foo:Bar')
            self.assertFalse(reapp.configured)
            self.assertEqual(reapp.conf.worker_agent, 'foo:Bar')
            self.assertTrue(reapp.configured)
            self.assertEqual(reapp.conf.broker_url, 'foo://bar')
            self.assertEqual(reapp._preconf['worker_agent'], 'foo:Bar')

コード例 #29

ファイル: test_app.py プロジェクト: zhangyitony/celery

    def test_pending_configuration__setattr(self):
        with self.Celery(broker='foo://bar') as app:
            app.conf.task_default_delivery_mode = 44
            app.conf.worker_agent = 'foo:Bar'
            assert not app.configured
            assert app.conf.worker_agent == 'foo:Bar'
            assert app.conf.broker_url == 'foo://bar'
            assert app._preconf['worker_agent'] == 'foo:Bar'

            assert app.configured
            reapp = pickle.loads(pickle.dumps(app))
            assert reapp._preconf['worker_agent'] == 'foo:Bar'
            assert not reapp.configured
            assert reapp.conf.worker_agent == 'foo:Bar'
            assert reapp.configured
            assert reapp.conf.broker_url == 'foo://bar'
            assert reapp._preconf['worker_agent'] == 'foo:Bar'

コード例 #30

ファイル: test_chord.py プロジェクト: mahak/celery

    def test_init(self):
        from celery import chord
        from celery.utils.serialization import pickle

        @self.app.task(shared=False)
        def addX(x, y):
            return x + y

        @self.app.task(shared=False)
        def sumX(n):
            return sum(n)

        x = chord(addX.s(i, i) for i in range(10))
        # kwargs used to nest and recurse in serialization/deserialization
        # (#6810)
        assert x.kwargs['kwargs'] == {}
        assert pickle.loads(pickle.dumps(x)).kwargs == x.kwargs

コード例 #31

    def test_pickle_arg_override_exception(self):

        exc = None
        try:
            raise ArgOverrideException(
                'ArgOverrideException raised', status_code=100,
            )
        except ArgOverrideException as exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        assert exception
        assert isinstance(exception, ArgOverrideException)
        assert exception.args == ('ArgOverrideException raised', 100)
        assert exception.status_code == 100

コード例 #32

ファイル: test_pickle.py プロジェクト: DotNetWebs/celery

    def test_pickle_arg_override_exception(self):

        exc = None
        try:
            raise ArgOverrideException(
                'ArgOverrideException raised', status_code=100,
            )
        except ArgOverrideException as exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        self.assertTrue(exception)
        self.assertIsInstance(exception, ArgOverrideException)
        self.assertTupleEqual(exception.args, (
                              'ArgOverrideException raised', 100))
        self.assertEqual(exception.status_code, 100)

コード例 #33

ファイル: test_result.py プロジェクト: HideMode/celery

 def test_is_pickleable(self):
     ts = self.app.GroupResult(uuid(), [self.app.AsyncResult(uuid())])
     self.assertEqual(pickle.loads(pickle.dumps(ts)), ts)
     ts2 = self.app.GroupResult(uuid(), [self.app.AsyncResult(uuid())])
     self.assertEqual(pickle.loads(pickle.dumps(ts2)), ts2)

コード例 #34

 def test_is_pickleable(self):
     ts = self.app.GroupResult(uuid(), [self.app.AsyncResult(uuid())])
     assert pickle.loads(pickle.dumps(ts)) == ts
     ts2 = self.app.GroupResult(uuid(), [self.app.AsyncResult(uuid())])
     assert pickle.loads(pickle.dumps(ts2)) == ts2

コード例 #35

 def test_pickleable(self):
     assert pickle.loads(pickle.dumps(self.ts))

コード例 #36

ファイル: test_result.py プロジェクト: Aliced3645/celery

 def test_reduce(self):
     self.assertTrue(pickle.loads(pickle.dumps(self.ts)))

コード例 #37

ファイル: test_pickle.py プロジェクト: FreakTheMighty/celery

        exc = None
        try:
            raise RegularException("RegularException raised")
        except RegularException, exc_:
            exc = exc_

        pickled = pickle.dumps({"exception": exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get("exception")
        self.assertTrue(exception)
        self.assertIsInstance(exception, RegularException)
        self.assertTupleEqual(exception.args, ("RegularException raised", ))

    def test_pickle_arg_override_exception(self):

        exc = None
        try:
            raise ArgOverrideException("ArgOverrideException raised",
                    status_code=100)
        except ArgOverrideException, exc_:
            exc = exc_

        pickled = pickle.dumps({"exception": exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get("exception")
        self.assertTrue(exception)
        self.assertIsInstance(exception, ArgOverrideException)
        self.assertTupleEqual(exception.args, (
                              "ArgOverrideException raised", 100))
        self.assertEqual(exception.status_code, 100)

コード例 #38

ファイル: test_result.py プロジェクト: wido/celery

 def test_pickleable(self):
     assert pickle.loads(pickle.dumps(self.ts))

コード例 #39

ファイル: base.py プロジェクト: WoLpH/celery

 def _store_result(self, task_id, result, status, traceback=None):
     meta = {"status": status, "result": result, "traceback": traceback}
     self.set(self.get_key_for_task(task_id), pickle.dumps(meta))
     return result

コード例 #40

ファイル: base.py プロジェクト: WoLpH/celery

 def _save_taskset(self, taskset_id, result):
     self.set(self.get_key_for_taskset(taskset_id),
              pickle.dumps({"result": result}))
     return result

コード例 #41

ファイル: test_result.py プロジェクト: wido/celery

 def test_is_pickleable(self):
     ts = self.app.GroupResult(uuid(), [self.app.AsyncResult(uuid())])
     assert pickle.loads(pickle.dumps(ts)) == ts
     ts2 = self.app.GroupResult(uuid(), [self.app.AsyncResult(uuid())])
     assert pickle.loads(pickle.dumps(ts2)) == ts2

コード例 #42

ファイル: test_pickle.py プロジェクト: mozilla/webifyme-lib

        exc = None
        try:
            raise RegularException("RegularException raised")
        except RegularException, exc_:
            exc = exc_

        pickled = pickle.dumps({"exception": exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get("exception")
        self.assertTrue(exception)
        self.assertIsInstance(exception, RegularException)
        self.assertTupleEqual(exception.args, ("RegularException raised", ))

    def test_pickle_arg_override_exception(self):

        exc = None
        try:
            raise ArgOverrideException("ArgOverrideException raised",
                                       status_code=100)
        except ArgOverrideException, exc_:
            exc = exc_

        pickled = pickle.dumps({"exception": exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get("exception")
        self.assertTrue(exception)
        self.assertIsInstance(exception, ArgOverrideException)
        self.assertTupleEqual(exception.args,
                              ("ArgOverrideException raised", 100))
        self.assertEqual(exception.status_code, 100)

コード例 #43

ファイル: test_result.py プロジェクト: HideMode/celery

 def test_pickleable(self):
     self.assertTrue(pickle.loads(pickle.dumps(self.ts)))

コード例 #44

def create_message(backend, **data):
    data.setdefault("id", gen_unique_id())
    return Message(backend,
                   body=pickle.dumps(dict(**data)),
                   content_type="application/x-python-serialize",
                   content_encoding="binary")

コード例 #45

        exc = None
        try:
            raise RegularException('RegularException raised')
        except RegularException, exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        self.assertTrue(exception)
        self.assertIsInstance(exception, RegularException)
        self.assertTupleEqual(exception.args, ('RegularException raised', ))

    def test_pickle_arg_override_exception(self):

        exc = None
        try:
            raise ArgOverrideException('ArgOverrideException raised',
                                       status_code=100)
        except ArgOverrideException, exc_:
            exc = exc_

        pickled = pickle.dumps({'exception': exc})
        unpickled = pickle.loads(pickled)
        exception = unpickled.get('exception')
        self.assertTrue(exception)
        self.assertIsInstance(exception, ArgOverrideException)
        self.assertTupleEqual(exception.args,
                              ('ArgOverrideException raised', 100))
        self.assertEqual(exception.status_code, 100)

コード例 #46

ファイル: test_result.py プロジェクト: shangshanshi/celery

 def test_pickleable(self):
     self.assertTrue(pickle.loads(pickle.dumps(self.ts)))

コード例 #47

ファイル: test_result.py プロジェクト: zzzap/celery

 def test_is_pickleable(self):
     ts = self.app.GroupResult(uuid(), [self.app.AsyncResult(uuid())])
     self.assertEqual(pickle.loads(pickle.dumps(ts)), ts)
     ts2 = self.app.GroupResult(uuid(), [self.app.AsyncResult(uuid())])
     self.assertEqual(pickle.loads(pickle.dumps(ts2)), ts2)

コード例 #48

ファイル: base.py プロジェクト: aleszoulek/celery

 def _save_taskset(self, taskset_id, result):
     meta = {"result": result}
     self.set(self.get_key_for_taskset(taskset_id), pickle.dumps(meta))
     return result

コード例 #49

ファイル: picklefield.py プロジェクト: OpenPOWER-BigData/HDP-hue

def encode(value, compress_object=False, pickle_protocol=DEFAULT_PROTOCOL):
    return b64encode(maybe_compress(
        pickle.dumps(value, pickle_protocol), compress_object),
    )

コード例 #50

ファイル: base.py プロジェクト: aleszoulek/celery

 def _store_result(self, task_id, result, status, traceback=None):
     meta = {"status": status, "result": result, "traceback": traceback}
     self.set(self.get_key_for_task(task_id), pickle.dumps(meta))
     return result

コード例 #51

ファイル: test_result.py プロジェクト: zzzap/celery

 def test_reduce(self):
     self.assertTrue(pickle.loads(pickle.dumps(self.ts)))

コード例 #52

def encode(value, compress_object=False, pickle_protocol=DEFAULT_PROTOCOL):
    return b64encode(maybe_compress(
        pickle.dumps(value, pickle_protocol), compress_object),
    )