twisted.internet.task.deferLater

Here are the examples of the python api twisted.internet.task.deferLater taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

125 Examples 7

Example 1

Project: mythbox Source File: loopback.py
def _loopbackAsyncContinue(ignored, server, serverToClient, client,
                           clientToServer, pumpPolicy):
    # Clear the Deferred from each message queue, since it has already fired
    # and cannot be used again.
    clientToServer._notificationDeferred = None
    serverToClient._notificationDeferred = None

    # Schedule some more byte-pushing to happen.  This isn't done
    # synchronously because no actual transport can re-enter dataReceived as
    # a result of calling write, and doing this synchronously could result
    # in that.
    from twisted.internet import reactor
    return deferLater(
        reactor, 0,
        _loopbackAsyncBody,
        server, serverToClient, client, clientToServer, pumpPolicy)

Example 2

Project: ccs-calendarserver Source File: test_http.py
    def testTimeout_betweenRequests(self):
        cxn = self.connect(betweenRequestsTimeOut=0.3)
        cmds = [[]]
        data = ""

        cxn.client.write("GET / HTTP/1.1\r\n\r\n")
        cmds[0] += [('init', 'GET', '/', (1, 1), 0, ()),
                    ('contentComplete',)]
        self.compareResult(cxn, cmds, data)

        response = TestResponse()
        response.headers.setRawHeaders("Content-Length", ("0",))
        cxn.requests[0].writeResponse(response)
        response.finish()

        data += "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"

        self.compareResult(cxn, cmds, data)
        return deferLater(reactor, 0.5, self.assertDone, cxn)  # Wait for timeout

Example 3

Project: trigger Source File: __init__.py
Function: monitor_result
    def monitor_result(self, result, reactor):
        """
        Loop periodically or until the factory stops to monitor the results
        and return them.
        """
        log.msg('>>>>> monitor_result() called')
        log.msg('>>>>> self.all_done = %s' % self.all_done)
        if self.all_done:
            log.msg('>>>>> SENDING RESULTS: %r' % self.results)
            log.msg('>>>>> SENDING  ERRORS: %r' % self.errors)
            #return self.results
            return dict(result=self.results, errors=self.errors)
        return task.deferLater(reactor, 0.5, self.monitor_result, result, reactor)

Example 4

Project: golem Source File: ranking.py
    def __end_round(self):
        logger.debug("End gossip round")
        try:
            self.received_gossip = self.client.collect_gossip() + self.received_gossip
            self.__make_prev_rank()
            self.working_vec = {}
            self.__add_gossip()
            self.__check_finished()
        finally:
            deferLater(self.reactor, self.round_oracle.sec_to_break(), self.__make_break)

Example 5

Project: PSO2Proxy Source File: GlobalChat.py
Function: signedon
        def signedOn(self):
            for command in ircSettings.get_key('autoexec'):
                self.sendLine(command)
                print("[IRC-AUTO] >>> %s" % command)
            task.deferLater(reactor, 15, self.joinChan)
            print("[GlobalChat] Joining channels in 15 seconds...")

Example 6

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def testCancelRemovesFromQueue(self):
        """
        Cancelling a job should remove it from the queue.
        """
        def eb(failure):
            self.assertEqual(failure.value.state, Job.CANCELLED)

        dq = ResizableDispatchQueue(self.slow, 1)
        dq.put('a', 1)
        deferred = dq.put('b', 2)
        deferred.addErrback(eb)
        deferred.cancel()
        yield task.deferLater(reactor, 0.1, dq.pause)
        pendingJobs = dq.pending()
        self.assertEqual(pendingJobs, [])

Example 7

Project: btcx Source File: mtgox.py
    def send_signed_call(self, call, params=None, item='BTC', **kwargs):
        if self.connected:
            return self.client.signed_call(call, params, item, **kwargs)
        else:
            print("Client is not connected! Retrying in one second")
            task.deferLater(reactor, 1, self.send_signed_call, call,
                    params, item, **kwargs)

Example 8

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def _stopAndTest(self, when, dq, expectedPending):
        pendingJobs = yield task.deferLater(reactor, when, dq.stop)
        pendingArgs = [p.jobarg for p in pendingJobs]
        self.assertEqual(sorted(expectedPending), sorted(pendingArgs))
        self.assertEqual(dq.size(), (0, len(pendingJobs)))

Example 9

Project: OpenBazaar-Server Source File: wireprotocol.py
Function: on_connection_made
        def on_connection_made(self):
            if self.connection is None or self.connection.state == State.CONNECTING:
                return task.deferLater(reactor, .1, self.on_connection_made)
            if self.connection.state == State.CONNECTED:
                self.addr = str(self.connection.dest_addr[0]) + ":" + str(self.connection.dest_addr[1])
                self.log.info("connected to %s" % self.addr)

Example 10

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def testPauseStop(self):
        items = range(3)
        dq = ResizableDispatchQueue(self.slow, 1)
        map(dq.put, items)
        d1 = task.deferLater(reactor, 0.1, dq.pause)
        d2 = self._stopAndTest(0.15, dq, [1, 2])
        yield d1
        yield d2

Example 11

Project: golem Source File: ranking.py
    def __init_stage(self):
        try:
            logger.debug("New gossip stage")
            self.__push_local_ranks()
            self.finished = False
            self.global_finished = False
            self.step = 0
            self.finished_neighbours = set()
            self.__init_working_vec()
        finally:
            deferLater(self.reactor, self.round_oracle.sec_to_round(), self.__new_round)

Example 12

Project: spinoff Source File: async.py
Function: sleep
def sleep(seconds=0, reactor=reactor):
    """A simple helper for asynchronously sleeping a certain amount of time.

    Standard usage:
        sleep(1.0).addCallback(on_wakeup)

    inlineCallbacks usage:
        yield sleep(1.0)

    """
    return task.deferLater(reactor, seconds, lambda: None)

Example 13

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def testPauseWidenResumeStop(self):
        items = range(3)
        dq = ResizableDispatchQueue(self.slow, 1)
        map(dq.put, items)
        d1 = task.deferLater(reactor, 0.1, dq.pause)
        reactor.callLater(0.2, dq.setWidth, 2)
        reactor.callLater(0.5, dq.resume)
        d2 = self._stopAndTest(0.6, dq, [])
        yield d1
        yield d2

Example 14

Project: golem Source File: service.py
Function: wait_for_session
    def _wait_for_session(self, host, port):
        deferred = Deferred()

        def on_success(result):
            if result:
                deferred.callback(result)
            else:
                retry()

        def retry(*_):
            conn_deferred = task.deferLater(self.reactor, self.retry_timeout,
                                            self.factory.get_session, host, port,
                                            timeout=self.conn_timeout)
            conn_deferred.addCallbacks(on_success, retry)

        retry()
        return deferred

Example 15

Project: vumi-go Source File: jsbox_send.py
    @inlineCallbacks
    def send_to_conv(self, conv, msg):
        publisher = self._publishers[conv.conversation_type]
        yield publisher.publish_message(msg)
        # Give the reactor time to actually send the message.
        yield deferLater(reactor, self.SEND_DELAY, lambda: None)

Example 16

Project: wader Source File: huawei_k4505.py
Function: enable_radio
    def enable_radio(self, enable):
        """
        Enables the radio according to ``enable``

        It will not enable it if it's already enabled and viceversa
        """

        def check_if_necessary(status):
            if (status == 1 and enable) or (status == 0 and not enable):
                return defer.succeed('OK')

            d = super(HuaweiK4505Wrapper, self).enable_radio(enable)
            d.addCallback(lambda x: deferLater(reactor, 5, lambda: x))
            return d

        d = self.get_radio_status()
        d.addCallback(check_if_necessary)
        return d

Example 17

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def testPuttingMoreThanWidthOnlyDispatchesWidth(self):
        """
        Make sure that if we put 5 things onto a queue whose width is 3
        that shortly thereafter there are 3 jobs underway and 2 pending.
        """
        dq = ResizableDispatchQueue(self.slow, 3)
        for value in range(5):
            reactor.callLater(0.01, dq.put, value)
        yield task.deferLater(reactor, 0.1, self._testSize, dq, (3, 2))
        yield dq.stop()

Example 18

Project: lbry Source File: sqlite_helpers.py
def rerun_if_locked(f):

    def rerun(err, *args, **kwargs):
        if err.check(sqlite3.OperationalError) and err.value.message == "database is locked":
            log.warning("database was locked. rerunning %s with args %s, kwargs %s",
                        str(f), str(args), str(kwargs))
            return task.deferLater(reactor, 0, wrapper, *args, **kwargs)
        return err

    def wrapper(*args, **kwargs):
        d = f(*args, **kwargs)
        d.addErrback(rerun, *args, **kwargs)
        return d

    return wrapper

Example 19

Project: sllurp Source File: llrp.py
    def send_DELETE_ACCESSSPEC(self, placeHolderArg, readSpecParam,
                               writeSpecParam, stopParam, accessSpecID=1,
                               onCompletion=None):
        # logger.info('Deleting current accessSpec.')
        self.sendLLRPMessage(LLRPMessage(msgdict={
            'DELETE_ACCESSSPEC': {
                'Ver': 1,
                'Type': 41,
                'ID': 0,
                'AccessSpecID': accessSpecID  # ONE AccessSpec
            }}))

        # Hackfix to chain startAccess to send_DELETE, since appending a
        # deferred doesn't seem to work...
        task.deferLater(reactor, 0, self.startAccess, readWords=readSpecParam,
                        writeWords=writeSpecParam, accessStopParam=stopParam,
                        accessSpecID=accessSpecID)

Example 20

Project: worker Source File: test_data.py
    @trigger("bad-trigger")
    @inlineCallbacks
    def testTriggersCheckService(self):
        service = TriggersCheck(self.db)
        service.start()
        yield self.db.saveTrigger(self.trigger.id, {})
        yield self.db.addTriggerCheck(self.trigger.id)
        worker.ERROR_TIMEOUT = 0.01
        yield deferLater(reactor, worker.PERFORM_INTERVAL * 2, lambda: None)
        self.flushLoggedErrors()
        yield service.stop()

Example 21

Project: txpostgres Source File: retrying.py
    def _callWithDelay(self, delay):
        # if the delay is 0, call the function synchronously
        if not delay:
            self._inProgress = defer.maybeDeferred(
                self._f, *self._args, **self._kw)
        else:
            self._inProgress = task.deferLater(
                self.reactor, delay, self._f, *self._args, **self._kw)
        self._inProgress.addCallbacks(self._deferred.callback, self._err)

Example 22

Project: powerstrip-flocker Source File: adapter.py
def loop_until(predicate):
    """Call predicate every 0.1 seconds, until it returns something ``Truthy``.

    :param predicate: Callable returning termination condition.
    :type predicate: 0-argument callable returning a Deferred.

    :return: A ``Deferred`` firing with the first ``Truthy`` response from
        ``predicate``.
    """
    d = maybeDeferred(predicate)

    def loop(result):
        if not result:
            d = deferLater(reactor, 0.1, predicate)
            d.addCallback(loop)
            return d
        return result
    d.addCallback(loop)
    return d

Example 23

Project: splash Source File: mockserver.py
Function: render_get
    def render_GET(self, request):
        request.setHeader(b"Content-Type", b"image/gif")
        request.setHeader(b"Cache-Control", b"no-cache, must-revalidate")
        request.setHeader(b"Pragma", b"no-cache")
        request.write(b"GIF89a")
        n = getarg(request, "n", 1, type=float)
        d = deferLater(reactor, n, lambda: (request, n))
        d.addCallback(self._delayedRender)
        return NOT_DONE_YET

Example 24

Project: deluge Source File: core.py
    def enable(self):

        # reduce typing, assigning some values to self...
        self.config = deluge.configmanager.ConfigManager('autoadd.conf', DEFAULT_PREFS)
        self.config.run_converter((0, 1), 2, self.__migrate_config_1_to_2)
        self.config.save()
        self.watchdirs = self.config['watchdirs']

        component.get('EventManager').register_event_handler(
            'PreTorrentRemovedEvent', self.__on_pre_torrent_removed
        )

        # Dict of Filename:Attempts
        self.invalid_torrents = {}
        # Loopingcall timers for each enabled watchdir
        self.update_timers = {}
        deferLater(reactor, 5, self.enable_looping)

Example 25

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def testPauseAddStop(self):
        items = range(3)
        dq = ResizableDispatchQueue(self.slow, 1)
        map(dq.put, items)
        d1 = task.deferLater(reactor, 0.1, dq.pause)
        reactor.callLater(0.12, dq.put, None)
        reactor.callLater(0.14, dq.put, 'hello')
        reactor.callLater(0.16, dq.put, 'world')
        d2 = self._stopAndTest(0.18, dq, [1, 2, None, 'hello', 'world'])
        yield d1
        yield d2

Example 26

Project: carbon Source File: test_client.py
  def test_send_datapoint(self):
    def assert_sent():
      sent_data = self.transport.value()
      sent_datapoints = decode_sent(sent_data)
      self.assertEqual([datapoint], sent_datapoints)

    datapoint = ('foo.bar', (1000000000, 1.0))
    self.protocol.sendDatapoint(*datapoint)
    return deferLater(reactor, 0.1, assert_sent)

Example 27

Project: calvin-base Source File: append_server.py
    def bootstrap(self, addrs):
        """
        Bootstrap the server by connecting to other known nodes in the network.

        Args:
            addrs: A `list` of (ip, port) `tuple` pairs.  Note that only IP addresses
                   are acceptable - hostnames will cause an error.
        """
        # if the transport hasn't been initialized yet, wait a second
        if self.protocol.transport is None:
            return task.deferLater(reactor, .2, self.bootstrap, addrs)
        else:
            _log.debug("AppendServer.bootstrap(%s)" % addrs)
            return Server.bootstrap(self, addrs)

Example 28

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def testPauseStopResume(self):
        """
        Pause a queue, then stop it, then check that trying to resume it
        gets a C{QueueStopped} exception.
        """
        items = range(3)
        dq = ResizableDispatchQueue(self.slow, 1)
        map(dq.put, items)
        d1 = task.deferLater(reactor, 0.1, dq.pause)
        d2 = self._stopAndTest(0.2, dq, [1, 2])
        d3 = task.deferLater(reactor, 0.3, dq.resume)
        yield d1
        yield d2
        yield self.failUnlessFailure(d3, QueueStopped)

Example 29

Project: golem Source File: ranking.py
Function: new_round
    def __new_round(self):
        logger.debug("New gossip round")
        try:
            self.__set_k()
            self.step += 1
            gossip = self.__prepare_gossip()
            if len(self.neighbours) > 0:
                send_to = random.sample(self.neighbours, self.k)
                self.client.send_gossip(gossip, send_to)
            self.received_gossip = [gossip]
        finally:
            deferLater(self.reactor, self.round_oracle.sec_to_end_round(), self.__end_round)

Example 30

Project: smokesignal Source File: tests_twisted.py
def asynchronous_failure(target):
    """
    Fail asynchronously
    """
    def err():
        {}['key_error']

    return task.deferLater(reactor, 0, err)

Example 31

Project: golem Source File: ranking.py
Function: make_break
    def __make_break(self):
        logger.debug("Gossip round finished")
        try:
            self.__check_global_finished()
        except Exception:
            deferLater(self.reactor, self.round_oracle.sec_to_round(), self.__new_round)
            raise

        if self.global_finished:
            try:
                self.client.collect_gossip()
                self.client.collect_stopped_peers()
                self.__save_working_vec()
            finally:
                deferLater(self.reactor, self.round_oracle.sec_to_new_stage(), self.__init_stage)
        else:
            deferLater(self.reactor, self.round_oracle.sec_to_round(), self.__new_round)

Example 32

Project: smokesignal Source File: tests_twisted.py
Function: delay
def delay(target):
    """
    Succeed after a delay
    """
    def done():
        return 'delay done'

    return task.deferLater(reactor, 15, done)

Example 33

Project: mythbox Source File: tcp.py
Function: lose_connection
    def loseConnection(self, connDone=failure.Failure(main.CONNECTION_DONE)):
        """
        Stop accepting connections on this port.

        This will shut down the socket and call self.connectionLost().  It
        returns a deferred which will fire successfully when the port is
        actually closed, or with a failure if an error occurs shutting down.
        """
        self.disconnecting = True
        self.stopReading()
        if self.connected:
            self.deferred = deferLater(
                self.reactor, 0, self.connectionLost, connDone)
            return self.deferred

Example 34

Project: vumi Source File: test_vumi_model_migrator.py
def post_migrate_function_deferred(obj):
    """
    Post-migrate-function for use in tests.
    """
    from twisted.internet import reactor
    return deferLater(reactor, 0.1, post_migrate_function, obj)

Example 35

Project: wader Source File: qualcomm.py
Function: enable_radio
    def enable_radio(self, enable):
        d = self.get_radio_status()

        def get_radio_status_cb(status):
            if status in [0, 4] and enable:
                self.send_at('AT+CFUN=1')
                # delay here to give the device chance to wake up
                return deferLater(reactor, 2, lambda: None)

            elif status == 1 and not enable:
                return self.send_at('AT+CFUN=4')

        d.addCallback(get_radio_status_cb)
        return d

Example 36

Project: txrdq Source File: test_rdq.py
Function: testsetwidthtozeroafterinitiallynonzero
    @defer.inlineCallbacks
    def testSetWidthToZeroAfterInitiallyNonZero(self):
        """
        Make sure that a queue whose width is initially non-zero and which
        is then set to zero width does not then begin to process any added
        jobs.
        """
        dq = ResizableDispatchQueue(self.slow, 3)
        yield task.deferLater(reactor, 0.01, dq.setWidth, 0)
        reactor.callLater(0.01, dq.put, 'aaa')
        reactor.callLater(0.01, dq.put, 'bbb')
        yield task.deferLater(reactor, 0.05, self._testSize, dq, (0, 2))
        remaining = yield dq.stop()
        self.assertEqual(['aaa', 'bbb'], [job.jobarg for job in remaining])

Example 37

Project: btcx Source File: mtgox.py
Function: send_request
    def send_request(self, json_msg):
        if self.connected:
            self.client.sendMessage(json_msg)
        else:
            print("Client is not connected! Retrying in one second")
            task.deferLater(reactor, 1, self.send_request, json_msg)

Example 38

Project: vmw.vco Source File: client.py
Function: wait
    def __wait(self, pred, poll, target=None):
        _async = target is not None
        def __checkPred(res):
            if res:
                target.callback(self)
                return res
            else:
                task.deferLater(reactor, poll, self.__wait, pred, poll, target)
                return

        if _async:
            return pred().addCallback(__checkPred)
        else:
            while not pred():
                time.sleep(poll)
            return True

Example 39

Project: shinysdr Source File: test_top.py
    @defer.inlineCallbacks
    def test_monitor_vfo_change(self):
        freq1 = 1e6
        freq2 = 2e6
        dev = simulate.SimulatedDevice(freq=freq1, allow_tuning=True)
        top = Top(devices={'s1': dev})
        self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq1)
        dev.set_freq(freq2)
        yield deferLater(the_reactor, 0.1, lambda: None)  # wait for tune delay
        self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq2)

Example 40

Project: trigger Source File: cmds.py
Function: monitor_result
    def monitor_result(self, result, reactor):
        """
        Loop periodically or until the factory stops to check if we're
        ``all_done`` and then return the results.
        """
        # Once we're done, return the results
        if self.all_done:
            return self.results

        # Otherwise tell the reactor to call me again after 0.5 seconds.
        return task.deferLater(reactor, 0.5, self.monitor_result, result, reactor)

Example 41

Project: nagcat Source File: scheduler.py
    def schedule(self, runnable, delay=None):
        """(re)schedule a top level runnable"""
        if delay is None:
            delay = runnable.repeat

        if not delay:
            log.error("Task %s has no repeat value.", runnable)
        else:
            log.debug("Scheduling %s in %s seconds.", runnable, delay)
            deferred = task.deferLater(reactor, delay, runnable.start)
            deferred.addBoth(lambda x: self.schedule(runnable))

Example 42

Project: pika Source File: twisted_service.py
Function: task
    def task(self, msg):
        """
        Method for a time consuming task.

        This function must return a deferred. If it is successfull,
        a `basic.ack` will be sent to AMQP. If the task was not completed a
        `basic.nack` will be sent. In this example it will always return
        successfully after a 2 second pause.
        """
        return task.deferLater(reactor, 2, lambda: log.msg("task completed"))

Example 43

Project: ccs-calendarserver Source File: test_http.py
    def testTimeout_idleRequest(self):
        cxn = self.connect(idleTimeOut=0.3)
        cmds = [[]]
        data = ""

        cxn.client.write("GET / HTTP/1.1\r\n\r\n")
        cmds[0] += [('init', 'GET', '/', (1, 1), 0, ()),
                    ('contentComplete',)]
        self.compareResult(cxn, cmds, data)

        return deferLater(reactor, 0.5, self.assertDone, cxn)  # Wait for timeout

Example 44

Project: treq Source File: test_treq_integration.py
    def tearDown(self):
        def _check_fds(_):
            # This appears to only be necessary for HTTPS tests.
            # For the normal HTTP tests then closeCachedConnections is
            # sufficient.
            fds = set(reactor.getReaders() + reactor.getReaders())
            if not [fd for fd in fds if isinstance(fd, Client)]:
                return

            return deferLater(reactor, 0, _check_fds, None)

        return self.pool.closeCachedConnections().addBoth(_check_fds)

Example 45

Project: txrdq Source File: test_rdq.py
Function: test_pause
    @defer.inlineCallbacks
    def testPause(self):
        items = range(3)
        dq = ResizableDispatchQueue(self.slow, 1)
        map(dq.put, items)
        reactor.callLater(0.2, self._testPaused, dq)
        yield task.deferLater(reactor, 0.1, dq.pause)
        pendingJobs = dq.pending()
        self.assertEqual([p.jobarg for p in pendingJobs], [1, 2])

Example 46

Project: vumi Source File: fake_connection.py
Function: wait0
def wait0(r=None):
    """
    Wait zero seconds to give the reactor a chance to work.

    Returns its (optional) argument, so it's useful as a callback.
    """
    from twisted.internet import reactor
    return deferLater(reactor, 0, lambda: r)

Example 47

Project: scrapy Source File: mockserver.py
    def deferRequest(self, request, delay, f, *a, **kw):
        def _cancelrequest(_):
            # silence CancelledError
            d.addErrback(lambda _: None)
            d.cancel()

        d = deferLater(reactor, delay, f, *a, **kw)
        request.notifyFinish().addErrback(_cancelrequest)
        return d

Example 48

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def testPauseResumeStop(self):
        """
        Pause a queue, then resume it, then stop it and check its contents.
        """
        items = range(3)
        dq = ResizableDispatchQueue(self.slow, 1)
        map(dq.put, items)
        d1 = task.deferLater(reactor, 0.1, dq.pause)
        reactor.callLater(0.5, dq.resume)
        reactor.callLater(0.51, self._testNotPaused, dq)
        d2 = self._stopAndTest(0.6, dq, [2])
        yield d1
        yield d2

Example 49

Project: Tor2web Source File: stats.py
    def update_stats(self, run_again=True):
        yesterday = date.today() - timedelta(1)
        hidden_services = list()
        for k in self:
            hidden_services.append(({'id': k, 'access_count': self[k]}))

        self.yesterday_stats = json.dumps({'date': yesterday.strftime('%Y-%m-%d'),
                                           'hidden_services': hidden_services})
        self.clear()

        next_time = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) + \
                    timedelta(days=1)
        next_delta = (next_time - datetime.now()).total_seconds()
        deferLater(reactor, next_delta, self.update_stats)

Example 50

Project: txrdq Source File: test_rdq.py
    @defer.inlineCallbacks
    def testPausePlayAroundResumeStop(self):
        # As above, with some playing around while paused.
        items = range(3)
        dq = ResizableDispatchQueue(self.slow, 1)
        map(dq.put, items)
        d1 = task.deferLater(reactor, 0.1, dq.pause)
        reactor.callLater(0.12, dq.setWidth, 100)
        reactor.callLater(0.16, dq.setWidth, 0)
        reactor.callLater(0.2, dq.setWidth, 2)
        reactor.callLater(0.5, dq.resume)
        d2 = self._stopAndTest(0.6, dq, [])
        yield d1
        yield d2
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3