twisted.internet.defer.Deferred

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

176 Examples 7

Example 1

Project: curler Source File: client.py
Function: submit
    def _submit(self, cmd, function, data, unique_id):

        def _submitted(x, d):
            self._register(x[1], _GearmanJobHandle(d))

        d = self.protocol.send(cmd,
                               function + "\0" + unique_id + "\0" + data)

        rv = defer.Deferred()
        d.addCallback(_submitted, rv)

        return rv

Example 2

Project: sydent Source File: peer.py
Function: pushupdates
    def pushUpdates(self, sgAssocs):
        body = {'sgAssocs': sgAssocs}

        reqDeferred = self.sydent.replicationHttpsClient.postJson(self.servername,
                                                                  self.port,
                                                                  '/_matrix/identity/replicate/v1/push',
                                                                  body)

        updateDeferred = twisted.internet.defer.Deferred()

        reqDeferred.addCallback(self._pushSuccess, updateDeferred=updateDeferred)
        reqDeferred.addErrback(self._pushFailed, updateDeferred=updateDeferred)

        return updateDeferred

Example 3

Project: ants Source File: http11.py
Function: cb_bodyready
    def _cb_bodyready(self, txresponse, request):
        # deliverBody hangs for responses without body
        if txresponse.length == 0:
            return txresponse, '', None

        def _cancel(_):
            txresponse._transport._producer.loseConnection()

        d = defer.Deferred(_cancel)
        txresponse.deliverBody(_ResponseReader(d, txresponse, request))
        return d

Example 4

Project: twitty-twister Source File: test_twitter.py
Function: filter
    def filter(self, delegate, args=None):
        """
        Returns the deferred, which can be fired in tests at will.
        """
        self.delegate = delegate
        self.filterCalls.append(args)
        self.deferred = defer.Deferred()
        return self.deferred

Example 5

Project: ZenPacks.zenoss.Microsoft.Windows Source File: twisted_utils.py
def sleep(seconds):
    '''
    Return a deferred that is called in given seconds.
    '''
    d = Deferred()
    reactor.callLater(seconds, d.callback, None)
    return d

Example 6

Project: doubanbot Source File: doubanapi.py
Function: parsed
    def __parsed(self, hdef, parser):
        deferred = defer.Deferred()
        hdef.addCallbacks(
            callback=lambda p: deferred.callback(parser(str(p))),
            errback=lambda e: deferred.errback(e))
        return deferred

Example 7

Project: Comet Source File: test_log.py
    def test_log_debug_level_debug(self):
        log.LEVEL = log.Levels.DEBUG
        self.assertFalse(self.observer.messages)
        d = log.debug(DUMMY_MESSAGE)
        self.assertIsInstance(d, defer.Deferred)
        return d.addCallback(self._check_log_full)

Example 8

Project: vncdotool Source File: client.py
    def _expectCompare(self, image, box, maxrms):
        image = image.crop(box)

        hist = image.histogram()
        if len(hist) == len(self.expected):
            sum_ = 0
            for h, e in zip(hist, self.expected):
                sum_ += (h - e) ** 2
            rms = math.sqrt(sum_ / len(hist))

            log.debug('rms %s', int(rms))
            if rms <= maxrms:
                return self

        self.deferred = Deferred()
        self.deferred.addCallback(self._expectCompare, box, maxrms)
        self.framebufferUpdateRequest(incremental=1)  # use box ~(x, y, w - x, h - y)?

        return self.deferred

Example 9

Project: archivczsk Source File: client.py
@callFromThread
def getTextInput(session, title, text=""):
    def getTextInputCB(word):
        if word is None:
            d.callback('')
        else:
            d.callback(word)
    d = defer.Deferred()
    session.openWithCallback(getTextInputCB, VirtualKeyBoard, title=title, text=text)
    return d

Example 10

Project: deblaze Source File: test_twisted.py
Function: test_preprocessor
    def test_preprocessor(self):
        d = defer.Deferred()

        def pp(sr):
            self.assertIdentical(sr, self.service_request)
            d.callback(None)

        gw = _twisted.TwistedGateway({'echo': lambda x: x}, preprocessor=pp)
        self.service_request = gateway.ServiceRequest(None, gw.services['echo'], None)

        gw.preprocessRequest(self.service_request)

        return d

Example 11

Project: Telephus Source File: pool.py
    def pushRequest(self, req, retries=None, keyspace=None):
        if keyspace is None:
            keyspace = self.keyspace
        retries = retries if retries is not None else self.request_retries
        req_d = defer.Deferred()
        self.pushRequest_really(req, keyspace, req_d, retries)
        return req_d

Example 12

Project: eliot Source File: test_twisted.py
    @withActionContext
    def test_addCallbacksCallbackToDeferred(self):
        """
        L{DeferredContext.addCallbacks} passes the given callback and its
        corresponding arguments to the wrapped L{Deferred}'s
        C{addCallbacks}.
        """
        called = []
        def f(value, x, y):
            called.append((value, x, y))
        result = Deferred()
        context = DeferredContext(result)
        context.addCallbacks(f, lambda x: None, (1,), {"y": 2})
        result.callback(0)
        self.assertEqual(called, [(0, 1, 2)])

Example 13

Project: txrdq Source File: test_pool.py
    def testCallbackedDeferredFiresWithTheRightResult(self):
        """
        The pool must correctly pass the original deferred callback result
        through any callbacks it might have added.
        """
        pool = DeferredPool()
        d = Deferred()
        pool.add(d)
        pool.notifyWhenEmpty()
        expectedValue = object()
        d.callback(expectedValue)
        self.assertIdentical(d.result, expectedValue)

Example 14

Project: GlobaLeaks Source File: utility.py
Function: deferred_sleep
def deferred_sleep(timeout):
    d = Deferred()

    def callbackDeferred():
        d.callback(True)

    reactor.callLater(timeout, callbackDeferred)

    return d

Example 15

Project: distributed-frontera Source File: utils.py
    def schedule(self, delay=0.0):
        if self._call is None:
            d = Deferred()
            d.addCallback(self)
            if self._errfunc:
                d.addErrback(self.error)
            self._call = reactor.callLater(delay, d.callback, None)

Example 16

Project: obfsproxy Source File: test_socks5.py
    def _connectClassIPv4(self, addr, port, klass, *args):
        self.assertEqual(addr, "127.0.0.1")
        self.assertEqual(port, 9050)
        self.connectDeferred = defer.Deferred()
        self.connectDeferred.addCallback(self._connectIPv4)
        return self.connectDeferred

Example 17

Project: treq Source File: multipart.py
Function: startproducing
    def startProducing(self, consumer):
        """
        Start a cooperative task which will read bytes from the input file and
        write them to C{consumer}.  Return a L{Deferred} which fires after all
        bytes have been written.

        @param consumer: Any L{IConsumer} provider
        """
        self._task = self._cooperate(self._writeLoop(consumer))
        d = self._task.whenDone()

        def maybeStopped(reason):
            reason.trap(task.TaskStopped)
            return defer.Deferred()
        d.addCallbacks(lambda ignored: None, maybeStopped)
        return d

Example 18

Project: python-twisted-binary-file-transfer-demo Source File: client.py
Function: display_response
    def _display_response(self, lines = None):
        """ Displays a server response. """
        
        if lines:
            for line in lines:
                print '%s' % (line)
            
        self._prompt()
        self.factory.deferred = defer.Deferred()

Example 19

Project: hyper-h2 Source File: twisted-server.py
Function: wait_for_flow_control
    def wait_for_flow_control(self, stream_id):
        """
        Returns a Deferred that fires when the flow control window is opened.
        """
        d = Deferred()
        self._flow_control_deferreds[stream_id] = d
        return d

Example 20

Project: socorro Source File: sb_pop3dnd.py
Function: add_message
    def addMessage(self, content, flags=(), date=None):
        """Add the given message to this mailbox."""
        msg = self.storage.makeMessage(self.getUIDNext(True),
                                       content.read())
        msg.date = date
        self.storage.addMessage(msg)
        self.store(MessageSet(long(msg.id), long(msg.id)), flags, 1, True)
        msg.recent = True
        msg.store()
        self.recent_count += 1
        self.unseen_count += 1

        for listener in self.listeners:
            listener.newMessages(self.getMessageCount(),
                                 self.getRecentCount())
        d = defer.Deferred()
        reactor.callLater(0, d.callback, self.storage.keys().index(msg.id))
        return d

Example 21

Project: txamqp Source File: server.py
    def _dispatchWork(self, w):
        # Just assume that it may take a long time
        results = self.operations[w.op](w.num1, w.num2)
        d = defer.Deferred()
        reactor.callLater(0, d.callback, results)
        return d

Example 22

Project: Community-Zenpacks Source File: twisted_client.py
Function: init
    def __init__(self, creds, operation, method, object, payload):
        self.creds = creds
        self.operation = operation
        self.method = method
        self.object = object
        self.payload = payload
        self.protocol = lambda: WBEMClient()
        self.deferred = defer.Deferred()

Example 23

Project: rollingpin Source File: ssh.py
Function: init
    def __init__(self, log, command, *args, **kwargs):
        self.log = log
        self.command = command
        self.finished = Deferred()
        self.result = StringIO.StringIO()
        self.reason = None

        SSHChannel.__init__(self, *args, **kwargs)

Example 24

Project: gemuo Source File: client.py
Function: connect
def connect(host, port, *args, **keywords):
    d = defer.Deferred()

    c = ClientCreator(reactor, UOProtocol, *args, **keywords)
    e = c.connectTCP(host, port)
    e.addCallback(lambda client: d.callback(Client(client)))
    e.addErrback(lambda f: d.errback(f))

    return d

Example 25

Project: openross Source File: middleware.py
Function: process_chain
def process_chain(callbacks, input, *a, **kw):
    """ Return a deferred built by chaining callbacks"""
    d = defer.Deferred()
    for x in callbacks:
        d.addCallback(x, *a, **kw)
    d.callback(input)
    return d

Example 26

Project: sylkserver Source File: backend.py
    def _janus_send_request(self, req):
        data = json.dumps(req.as_dict())
        if JanusConfig.trace_janus:
            self.factory.janus_logger.msg("OUT", ISOTimestamp.now(), data)
        self.sendMessage(data)
        d = defer.Deferred()
        self._janus_pending_transactions[req.transaction_id] = (req, d)
        return d

Example 27

Project: txdbus Source File: test_authentication.py
    def expectDisconnect(self):
        self.disconnect_d = defer.Deferred()

        def timeout():
            self.fail()
            d = self.disconnect_d
            self.disconnect_d = None
            d.errback(Exception('Disconnect timed out'))

        self.disconnect_timeout = reactor.callLater(2, timeout)

        self.disconnect_d.addCallback( lambda _: self.succeed() )

        return self.disconnect_d

Example 28

Project: autologin Source File: scrapyutils.py
Function: init
    def __init__(self, crawl_d, crawler):
        self.crawl_d = crawl_d
        self.crawler = crawler

        crawler.signals.connect(self._on_item_scraped, signals.item_scraped)
        crawler.signals.connect(self._on_error, signals.spider_error)

        crawl_d.addCallback(self._on_finished)
        crawl_d.addErrback(self._on_error)

        self.closed = False
        self._items_available = Deferred()
        self._items = collections.deque()

Example 29

Project: twisted-gears Source File: client.py
Function: send
    def send(self, cmd, *args):
        """Send a command and get a deferred waiting for the response."""
        self.send_raw(cmd, *args)
        d = defer.Deferred()
        self.deferreds.append(d)
        return d

Example 30

Project: gazouilleur Source File: ircclient_with_names.py
Function: names
    def _names(self, channel):
        channel = channel.lower()
        d = defer.Deferred()
        if channel not in self._namescallback:
            self._namescallback[channel] = ([], [])
        self._namescallback[channel][0].append(d)
        self.sendLine("NAMES %s" % channel)
        return d

Example 31

Project: fedmsg-notify Source File: daemon.py
Function: get_icon
    def get_icon(self, icon):
        icon_file = self._icon_cache.get(icon)
        if not icon_file:
            icon_id = str(uuid.uuid5(uuid.NAMESPACE_URL, str(icon)))
            filename = os.path.join(self.cache_dir, icon_id)
            if not os.path.exists(filename):
                log.debug('Downloading icon: %s' % icon)
                d = downloadPage(str(icon), filename)
                d.addCallbacks(self.cache_icon, errback=log.error,
                               callbackArgs=(icon, filename))
                return d
            else:
                self._icon_cache[icon] = filename
        d = defer.Deferred()
        d.callback(None)
        return d

Example 32

Project: graphite Source File: cloud.py
Function: input
  def input(self,key,value):
    queue = self.getQueue(key)
    if queue:
      queue.enqueue(key,value)
      if self.busyDefer:
        d = self.busyDefer
        self.busyDefer = None
        d.callback(0)
    else:
      if self.busyDefer: return self.busyDefer
      print 'All agents are busy, please hold the line and the next available representative will be with you shortly.'
      self.busyDefer = Deferred()
      return self.busyDefer

Example 33

Project: carbon Source File: client.py
  def queueSpaceCallback(self, result):
    if self.queueFull.called:
      log.clients('%s send queue has space available' % self.connectedProtocol)
      self.queueFull = Deferred()
      self.queueFull.addCallback(self.queueFullCallback)
      state.events.cacheSpaceAvailable()
    self.queueHasSpace = Deferred()
    self.queueHasSpace.addCallback(self.queueSpaceCallback)

Example 34

Project: pyload Source File: TTwisted.py
Function: init
    def __init__(self, client_class, iprot_factory, oprot_factory=None):
        self._client_class = client_class
        self._iprot_factory = iprot_factory
        if oprot_factory is None:
            self._oprot_factory = iprot_factory
        else:
            self._oprot_factory = oprot_factory

        self.recv_map = {}
        self.started = defer.Deferred()

Example 35

Project: prometheus_async Source File: test_tx.py
    @pytest.inlineCallbacks
    def test_deferred(self, fg):
        """
        Incs and decs if its passed a Deferred.
        """
        d = tx.track_inprogress(fg, Deferred())

        assert 1 == fg._val

        d.callback(42)
        rv = yield d

        assert 42 == rv
        assert 0 == fg._val

Example 36

Project: txAMQP Source File: test_heartbeat.py
    def test_heartbeat(self):
        """
        Test that heartbeat frames are sent and received
        """
        d = Deferred()
        def checkPulse(dummy):
            self.assertTrue(self.client.called_send_hb,
                        "A heartbeat frame was recently sent")
            self.assertTrue(self.client.called_reschedule_check,
                        "A heartbeat frame was recently received")
        d.addCallback(checkPulse)
        reactor.callLater(3, d.callback, None)
        return d

Example 37

Project: crochet Source File: test_api.py
    def test_later_failure_result(self):
        """
        wait() raises the exception the Deferred fired with, in the case
        where the Deferred is fired after wait() is called.
        """
        d = Deferred()
        dr = EventualResult(d, None)
        l = []
        done = append_in_thread(l, dr.wait)
        time.sleep(0.1)
        d.errback(RuntimeError())
        done.wait()
        self.assertEqual((l[0], l[1].__class__), (False, RuntimeError))

Example 38

Project: scrapy Source File: test_downloadermiddleware_robotstxt.py
    def _get_emptybody_crawler(self):
        crawler = self.crawler
        crawler.settings.set('ROBOTSTXT_OBEY', True)
        response = Response('http://site.local/robots.txt')
        def return_response(request, spider):
            deferred = Deferred()
            reactor.callFromThread(deferred.callback, response)
            return deferred
        crawler.engine.download.side_effect = return_response
        return crawler

Example 39

Project: jolicloud-daemon Source File: filesystem.py
def input_stream_read_deferred(in_stream, count, io_priority=0, cancellable=None):
    d = defer.Deferred()
    def callback(in_stream, async_result):
        try:
            bytes = in_stream.read_finish(async_result)
        except gio.Error:
            d.errback()
        else:
            d.callback(bytes)
    # the argument order seems a bit weird here ...
    in_stream.read_async(count, callback, io_priority, cancellable)
    return d

Example 40

Project: vertex Source File: conncache.py
    def shutdown(self):
        """
        Disconnect all cached connections.

        @returns: a deferred that fires once all connection are disconnected.
        @rtype: L{Deferred}
        """
        self._shuttingDown = {key: Deferred()
                              for key in self.cachedConnections.keys()}
        return DeferredList(
            [maybeDeferred(p.transport.loseConnection)
             for p in self.cachedConnections.values()]
             + self._shuttingDown.values())

Example 41

Project: txyoga Source File: test_collection.py
    def _verifyExposedAttributes(self, _):
        # Yes, this has to be synchronous (one by one), because
        # getElement tacks a lot of ugly state on to the test case. It
        # really should return a nice (deferred) response object...
        # See issue #33
        def verifyElementExposure(_):
            for attribute in self.elementClass.exposedAttributes:
                self.assertIn(attribute, self.responseContent)

        d = defer.Deferred()

        names = [r["name"] for r in self.responseContent["results"]]
        for name in names:
            d.addCallback(lambda _: self.getElement(name))
            d.addCallback(verifyElementExposure)

        d.callback(None)
        return d

Example 42

Project: pixelated-user-agent Source File: test_mail_service.py
Function: test_send_mail
    def test_send_mail(self):
        when(InputMail).from_dict(ANY(), ANY()).thenReturn(self.mail)
        when(self.mail_sender).sendmail(ANY()).thenReturn(defer.Deferred())

        sent_deferred = self.mail_service.send_mail(mail_dict())

        verify(self.mail_sender).sendmail(self.mail)

        sent_deferred.callback('Assume sending mail succeeded')

        return sent_deferred

Example 43

Project: protobuf-rpc Source File: tx.py
    def _call_method( self, methodDescriptor, rpcController, request, responseClass, done ):
        self.id += 1
        d = Deferred()
        d.addCallback( self.unserialize_response, responseClass, rpcController)
        d.addCallback( done )
        self._pending[ self.id ] = d
        rpc = Rpc()
        rpcRequest = rpc.request.add()
        rpcRequest.method = methodDescriptor.containing_service.name + '.' + methodDescriptor.name
        rpcRequest.serialized_request = request.SerializeToString()
        rpcRequest.id = self.id
        return rpc

Example 44

Project: khashmir Source File: krpc.py
    def sendRequest(self, method, args):
        # make message
        # send it
        msg = {TID : chr(self.mtid), TYP : REQ,  REQ : method, ARG : args}
        self.mtid = (self.mtid + 1) % 256
        str = bencode(msg)
        d = Deferred()
        self.tids[msg[TID]] = d
        def timeOut(tids = self.tids, id = msg[TID]):
            if tids.has_key(id):
                df = tids[id]
                del(tids[id])
                print ">>>>>> KRPC_ERROR_TIMEOUT"
                df.errback(KRPC_ERROR_TIMEOUT)
        reactor.callLater(KRPC_TIMEOUT, timeOut)
        self.transport.write(str, self.addr)
        return d

Example 45

Project: pyutil Source File: testutil.py
Function: poll
    def _poll(self, res, check_f, pollinterval):
        if check_f():
            return True
        d = defer.Deferred()
        d.addCallback(self._poll, check_f, pollinterval)
        reactor.callLater(pollinterval, d.callback, None)
        return d

Example 46

Project: pika Source File: twisted_connection.py
    def channel(self, channel_number=None):
        """Create a new channel with the next available channel number or pass
        in a channel number to use. Must be non-zero if you would like to
        specify but it is recommended that you let Pika manage the channel
        numbers.

        Return a Deferred that fires with an instance of a wrapper around the
        Pika Channel class.

        :param int channel_number: The channel number to use, defaults to the
                                   next available.

        """
        d = defer.Deferred()
        base_connection.BaseConnection.channel(self, d.callback, channel_number)
        return d.addCallback(TwistedChannel)

Example 47

Project: pc-bot Source File: test_log.py
Function: post
    def _post(self, url, body):
        """A mock post implementation for testing.

        Asserts that the URL is the target's URL. Keeps track of the
        request body under ``self.request_body``. Sets ``self.post_deferred``
        to a new Deferred, and returns it. (The caller is expected to fire
        this at some point.)
        """
        self.assertEqual(url, self.target._url)
        self.request_body = body
        self.post_deferred = d = defer.Deferred()
        return d

Example 48

Project: pappy-proxy Source File: manglecmds.py
Function: edit_file
def edit_file(fname, front=False):
    global edit_queue
    # Adds the filename to the edit queue. Returns a deferred that is fired once
    # the file is edited and the editor is closed
    d = defer.Deferred()
    if front:
        edit_queue = [(fname, d)] + edit_queue
    else:
        edit_queue.append((fname, d))
    return d

Example 49

Project: bnw Source File: xmpp_tester.py
    def stanzaRecv(self):
        d = defer.Deferred()
        if self.queue:
            d.callback(self.queue.pop(0))
        else:
            self.listeners.append(d)
        return d

Example 50

Project: CouchPotatoServer Source File: memutil.py
Function: init
    def __init__(self, f, numsamples=2**7, iterspersample=2**4, *args, **kwargs):
        """
        @param f a callable; If it returns a deferred then the memory will not
            be measured and the next iteration will not be started until the
            deferred fires; else the memory will be measured and the next
            iteration started when f returns.
        """
        self.f = f
        self.numsamples = numsamples
        self.iterspersample = iterspersample
        self.args = args
        self.kwargs = kwargs
        # from twisted
        from twisted.internet import defer
        self.d = defer.Deferred()
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4