def test_fail_deferred1(self): a = Deferred() d1 = Deferred().add_callback(lambda r: a.callback(r+2))\ .add_errback(a.callback) d1.callback('bla') self.assertIsInstance(a.result.error, TypeError) self.assertIsInstance(d1.result.error, TypeError) mute_failure(self, a.result)
def test_then1(self): a = Deferred() d1 = Deferred() d2 = d1.then().add_callback(lambda r: a.callback(r + 2)) d1.callback(1) self.assertEqual(a.result, 3) self.assertEqual(d1.result, 1) self.assertEqual(d2.result, 3)
def test_coroutine1(self): d1 = Deferred() a = maybe_async(c_summation(d1)) d1.callback(1) yield a self.assertEqual(a.result, 3) self.assertEqual(d1.result, 1)
def get_callback(self, task_id): with self.lock: callbacks = self.callbacks when_done = callbacks.get(task_id) if not when_done: # No deferred, create one and check again callbacks[task_id] = when_done = Deferred() return when_done
def close(self): '''Stop listening for messages. :meth:`unsubscribe` from all :attr:`channels` and :attr:`patterns` and close the subscriber connection with redis. ''' d = Deferred() loop = self.connection_pool.get_event_loop() loop.call_soon_threadsafe(self._close, d) return d
def unsubscribe(self, *channels): '''Un-subscribe from a list of ``channels`` or ``channel patterns``. It returns an asynchronous component which results in the number of channels this handler is subscribed to. ''' d = Deferred() loop = self.connection_pool.get_event_loop() loop.call_soon_threadsafe(self._unsubscribe, channels, d) return d
def test_json_with_async_string2(self): d = Deferred() astr = wsgi.AsyncString(d) response = wsgi.Json({'bla': astr}) self.assertEqual(len(response.children), 1) result = response.render() self.assertIsInstance(result, Deferred) d.callback('ciao') result = yield result self.assertEqual(result, json.dumps({'bla': 'ciao'}))
def test_fail_coroutine1(self): d1 = Deferred() a = maybe_async(c_summation(d1)) d1.callback('bla') try: yield a except TypeError: pass else: raise TypeError self.assertEqual(d1.result, 'bla')
def _close(self, future): if self._connection: d = Deferred() exc_info = None try: yield self._unsubscribe((), d) yield d except Exception: exc_info = sys.exc_info() self._connection.close() self._reset() future.callback(exc_info)
def _execute(self, command, *args): if not self._connection: client = self.client() pool = client.connection_pool consumer = yield pool.request(client, 'ping', (), release_connection=False).on_finished self.parser = consumer._request.parser connection = consumer.connection connection.set_consumer(None) connection.set_consumer(self) self.fire_event('pre_request') d = Deferred() yield self._connection_msg(command, args, d)
def subscribe(self, *channels): '''Subscribe to a list of ``channels`` or ``channel patterns``. It returns an asynchronous component which results in the number of channels this handler is subscribed to. If this is the first time the method is called by this handler, than the :class:`PubSub` starts listening for messages which are fired via the ``on_message`` event. ''' d = Deferred() loop = self.connection_pool.get_event_loop() loop.call_soon_threadsafe(self._subscribe, channels, d) return d
def async_func(loop, value): p = Deferred() loop.call_later(0.01, p.callback, value) return p
def test_coroutine(self): loop = new_event_loop(iothreadloop=False) d = Deferred() loop.call_soon(main, d, loop, 1) loop.run_until_complete(d) self.assertEqual(d.result, 9)
def __init__(self, headers, parser, transport=None): self.headers = headers self.parser = parser self.transport = transport self.buffer = b'' self.on_message_complete = Deferred()