twisted.internet.defer.maybeDeferred

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

165 Examples 7

Example 1

Project: awspider Source File: base.py
    def _reservationCacheErrback(self, error, func, kwargs, function_name, uuid):
        LOGGER.debug("Could not get reservation cache for %s" % uuid)
        kwargs["reservation_cache"] = None
        d = maybeDeferred(func, **kwargs)
        d.addCallback(self._callExposedFunctionCallback, function_name, uuid)
        d.addErrback(self._callExposedFunctionErrback, function_name, uuid)
        return d

Example 2

Project: twistar Source File: validation.py
Function: validate
    @classmethod
    def _validate(klass, obj):
        """
        Validate a given object using all of the set validators for the objects class.
        If errors are found, they will be recorded in the objects C{errors} property.

        @return: A C{Deferred} whose callback will receive the given object.

        @see: L{Errors}
        """
        ds = [defer.maybeDeferred(func, obj) for func in klass.VALIDATIONS]
        # Return the object when finished
        return defer.DeferredList(ds).addCallback(lambda results: obj)

Example 3

Project: python-tx-tftp Source File: util.py
Function: deferred
def deferred(func):
    """Decorates a function to ensure that it always returns a `Deferred`.

    This also serves a secondary docuementation purpose; functions decorated
    with this are readily identifiable as asynchronous.
    """
    @wraps(func)
    def wrapper(*args, **kwargs):
        return maybeDeferred(func, *args, **kwargs)
    return wrapper

Example 4

Project: petmail Source File: common.py
    def anyways(self, res, cb, *args, **kwargs):
        # always run the cleanup callback
        d = defer.maybeDeferred(cb, *args, **kwargs)
        if isinstance(res, failure.Failure):
            # let the original failure passthrough
            d.addBoth(lambda _: res)
        # otherwise the original result was success, so just return the
        # cleanup result
        return d

Example 5

Project: txmongo Source File: grid_file.py
Function: write_lines
    def writelines(self, sequence):
        """Write a sequence of strings to the file.

        Does not add separators.
        """
        iterator = iter(sequence)

        def iterate(_=None):
            try:
                return self.write(next(iterator)).addCallback(iterate)
            except StopIteration:
                return
        return defer.maybeDeferred(iterate)

Example 6

Project: nodeset.core Source File: observer.py
    def twist(self, observers, eventDict): 
        defers = []

        if config.Configurator['verbose']:
            log.msg("twist carousel %s, %s" % (observers, eventDict))
                
        for i in observers:
            defers.append(defer.maybeDeferred(i.run, eventDict))
                     
        return defers

Example 7

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 8

Project: wokkel Source File: test_ping.py
    def test_getDiscoInfoNode(self):
        """
        The ping namespace should not be returned for a node.
        """
        def cb(info):
            discoInfo = disco.DiscoInfo()
            for item in info:
                discoInfo.append(item)
            self.assertNotIn('urn:xmpp:ping', discoInfo.features)

        d = defer.maybeDeferred(self.protocol.getDiscoInfo,
                                JID('[email protected]/home'),
                                JID('pubsub.example.org'),
                                'test')
        d.addCallback(cb)
        return d

Example 9

Project: conn-check Source File: check_impl.py
@inlineCallbacks
def sequential_strategy(subchecks, pattern, results):
    """Run subchecks sequentially, skipping checks after the first failure.

    This is most useful when the failure of one check in the sequence
    would imply the failure of later checks -- for example, it probably
    doesn't make sense to run an SSL check if the basic TCP check failed.

    Use sequential_check to create a meta-check using this strategy.
    """
    local_results = FailureCountingResultWrapper(wrapped=results)
    failed = False
    for subcheck in subchecks:
        if failed:
            subcheck.skip(pattern, local_results)
        else:
            yield maybeDeferred(subcheck.check, pattern, local_results)
            if local_results.any_failed():
                failed = True

Example 10

Project: scrapy Source File: robotstxt.py
Function: process_request
    def process_request(self, request, spider):
        if request.meta.get('dont_obey_robotstxt'):
            return
        d = maybeDeferred(self.robot_parser, request, spider)
        d.addCallback(self.process_request_2, request, spider)
        return d

Example 11

Project: foolscap Source File: common.py
Function: tear_down
    def tearDown(self):
        for c in self.connections:
            if c.transport:
                c.transport.loseConnection()
        dl = []
        for s in self.servers:
            dl.append(defer.maybeDeferred(s.stopListening))
        for s in self.services:
            dl.append(defer.maybeDeferred(s.stopService))
        d = defer.DeferredList(dl)
        d.addCallback(flushEventualQueue)
        return d

Example 12

Project: vertex Source File: conncache.py
Function: clientconnectionmade
    def clientConnectionMade(self, protocol):
        def success(reason):
            self.cache.connectionMadeForKey(self.key, protocol)
            self.finishedExtraWork = True
            return protocol

        def failed(reason):
            self.lostAsFailReason = reason
            protocol.transport.loseConnection()
            return reason
        maybeDeferred(self.extraWork, protocol).addCallbacks(
            success, failed)

Example 13

Project: scrapyd Source File: test_spiderqueue.py
Function: test_list
    @inlineCallbacks
    def test_list(self):
        l = yield maybeDeferred(self.q.list)
        self.assertEqual(l, [])

        yield maybeDeferred(self.q.add, self.name, **self.args)
        yield maybeDeferred(self.q.add, self.name, **self.args)

        l = yield maybeDeferred(self.q.list)
        self.assertEqual(l, [self.msg, self.msg])

Example 14

Project: ants Source File: decorator.py
def defers(func):
    """Decorator to make sure a function always returns a deferred"""
    @wraps(func)
    def wrapped(*a, **kw):
        return defer.maybeDeferred(func, *a, **kw)
    return wrapped

Example 15

Project: pyrf Source File: twisted_async.py
    def sync_async(self, gen):
        def advance(result):
            try:
                d = gen.send(result)
                d = defer.maybeDeferred(lambda: d)
            except StopIteration:
                return result
            d.addCallback(advance)
            return d

        return advance(None)

Example 16

Project: awspider Source File: base.py
Function: callexposedfunction
    def callExposedFunction(self, func, kwargs, function_name, reservation_fast_cache=None, uuid=None):
        if uuid is not None:
            self.active_jobs[uuid] = True
        if self.functions[function_name]["get_reservation_uuid"]:
            kwargs["reservation_uuid"] = uuid 
        if self.functions[function_name]["check_reservation_fast_cache"] and \
                reservation_fast_cache is not None:
            kwargs["reservation_fast_cache"] = reservation_fast_cache
        elif self.functions[function_name]["check_reservation_fast_cache"]:
            kwargs["reservation_fast_cache"] = None
        d = maybeDeferred(func, **kwargs)
        d.addCallback(self._callExposedFunctionCallback, function_name, uuid)
        d.addErrback(self._callExposedFunctionErrback, function_name, uuid)
        return d

Example 17

Project: python-tx-tftp Source File: session.py
Function: nextblock
    def nextBlock(self, datagram):
        """Handle fresh data, attempt to write it to backend

        @type datagram: L{DATADatagram}

        """
        if self.timeout_watchdog is not None and self.timeout_watchdog.active():
            self.timeout_watchdog.cancel()
        self.blocknum += 1
        d = maybeDeferred(self.writer.write, datagram.data)
        d.addCallbacks(callback=self.blockWriteSuccess, callbackArgs=[datagram, ],
                       errback=self.blockWriteFailure)
        return d

Example 18

Project: ZenPacks.zenoss.OpenStackInfrastructure Source File: test_hostmap.py
Function: set_up
    def setUp(self):
        super(TestHostMap, self).setUp()

        def resolve_names(names):
            return defer.maybeDeferred(lambda: {
                'test1': '1.2.3.4',
                'test1.example.com': '1.2.3.4',
                'test2': '1.2.3.5',
                'test2.example.com': '1.2.3.5'
            })
        self._real_resolve_names = hostmap.resolve_names
        hostmap.resolve_names = resolve_names

Example 19

Project: vumi Source File: worker.py
Function: start_worker
    def startWorker(self):
        self.log.msg(
            'Starting a %s worker with config: %s'
            % (self.__class__.__name__, self.config))
        d = maybeDeferred(self._validate_config)
        then_call(d, self.setup_heartbeat)
        then_call(d, self.setup_middleware)
        then_call(d, self.setup_connectors)
        then_call(d, self.setup_worker)
        return d

Example 20

Project: conn-check Source File: check_impl.py
Function: check
    @inlineCallbacks
    def check(self, pattern, results):
        """Call the check function."""
        if not pattern.matches(self.name):
            returnValue(None)
        results.notify_start(self.name, self.info)
        start = time.time()
        try:
            if self.blocking:
                result = yield maybeDeferToThread(self.check_fn)
            else:
                result = yield maybeDeferred(self.check_fn)
            results.notify_success(self.name, time.time() - start)
            returnValue(result)
        except Exception:
            results.notify_failure(self.name, self.info,
                                   sys.exc_info(), time.time() - start)

Example 21

Project: pyutil Source File: testutil.py
Function: poll
    def poll(self, check_f, pollinterval=0.01):
        # Return a Deferred, then call check_f periodically until it returns
        # True, at which point the Deferred will fire.. If check_f raises an
        # exception, the Deferred will errback.
        d = defer.maybeDeferred(self._poll, None, check_f, pollinterval)
        return d

Example 22

Project: ooni-backend Source File: http_helpers.py
Function: execute_handler
    def _execute_handler(self, r, args, kwargs):
        if not self._finished:
            args = [self.decode_argument(arg) for arg in args]
            kwargs = dict((k, self.decode_argument(v, name=k))
                          for (k, v) in kwargs.iteritems())

            # This is where we do the patching
            # XXX this is somewhat hackish
            d = defer.maybeDeferred(self.all, *args, **kwargs)
            d.addCallbacks(self._execute_success, self._execute_failure)
            self.notifyFinish().addCallback(self.on_connection_close)

Example 23

Project: vumi-go Source File: action_dispatcher.py
Function: dispatch_action
    def dispatch_action(self, handler, campaign_key, obj_key, params):
        user_api = self.get_user_api(campaign_key)
        d = maybeDeferred(self.get_object_by_key, user_api, obj_key)

        if params is None:
            params = {}

        def action(obj):
            return handler(self, user_api, obj, **params)

        d.addCallback(action)
        return d

Example 24

Project: vertex Source File: conncache.py
Function: shut_down
    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 25

Project: scrapy Source File: feedexport.py
Function: close_spider
    def close_spider(self, spider):
        slot = self.slot
        if not slot.itemcount and not self.store_empty:
            return
        if self._exporting:
            slot.exporter.finish_exporting()
            self._exporting = False
        logfmt = "%s %%(format)s feed (%%(itemcount)d items) in: %%(uri)s"
        log_args = {'format': self.format,
                    'itemcount': slot.itemcount,
                    'uri': slot.uri}
        d = defer.maybeDeferred(slot.storage.store, slot.file)
        d.addCallback(lambda _: logger.info(logfmt % "Stored", log_args,
                                            extra={'spider': spider}))
        d.addErrback(lambda f: logger.error(logfmt % "Error storing", log_args,
                                            exc_info=failure_to_exc_info(f),
                                            extra={'spider': spider}))
        return d

Example 26

Project: foolscap Source File: referenceable.py
    def callRemoteOnly(self, _name, *args, **kwargs):
        # the remote end will not send us a response. The only error cases
        # are arguments that don't match the schema, or broken invariants. In
        # particular, DeadReferenceError will be silently consumed.
        d = defer.maybeDeferred(self._callRemote, _name, _callOnly=True,
                                *args, **kwargs)
        del d
        return None

Example 27

Project: wiremaps Source File: json.py
Function: renderhttp
    def renderHTTP(self, ctx):
        request = inevow.IRequest(ctx)
        if inevow.ICurrentSegments(ctx)[-1] != '':
            request.redirect(request.URLPath().child(''))
            return ''
        request.setHeader("Content-Type",
                          "application/json; charset=UTF-8")
        d = defer.maybeDeferred(self.data_json, ctx, None)
        d.addCallback(lambda x: self.render_json(ctx, x))
        return d

Example 28

Project: scrapyd Source File: test_spiderqueue.py
    @inlineCallbacks
    def test_add_pop_count(self):
        c = yield maybeDeferred(self.q.count)
        self.assertEqual(c, 0)

        yield maybeDeferred(self.q.add, self.name, **self.args)

        c = yield maybeDeferred(self.q.count)
        self.assertEqual(c, 1)

        m = yield maybeDeferred(self.q.pop)
        self.assertEqual(m, self.msg)

        c = yield maybeDeferred(self.q.count)
        self.assertEqual(c, 0)

Example 29

Project: foolscap Source File: test_crypto.py
Function: test_persist
    def testPersist(self):
        t1 = Target()
        s1,s2 = self.services
        port = allocate_tcp_port()
        s1.listenOn("tcp:%d:interface=127.0.0.1" % port)
        s1.setLocation("127.0.0.1:%d" % port)
        public_url = s1.registerReference(t1, "name")
        self.failUnless(public_url.startswith("pb:"))
        d = defer.maybeDeferred(s1.stopService)
        d.addCallback(self._testPersist_1, s1, s2, t1, public_url, port)
        return d

Example 30

Project: vumi-go Source File: vumi_app.py
Function: publish
    def publish(self, key, msg):
        callbacks = self.clients[key]
        if callbacks:
            callback = random.choice(callbacks)
            return maybeDeferred(callback, msg)
        else:
            return self.queue_in_backlog(key, msg)

Example 31

Project: ants Source File: feedexport.py
Function: close_spider
    def close_spider(self, spider):
        slot = self.slot
        if not slot.itemcount and not self.store_empty:
            return
        slot.exporter.finish_exporting()
        logfmt = "%%s %s feed (%d items) in: %s" % (self.format, slot.itemcount, slot.uri)
        d = defer.maybeDeferred(slot.storage.store, slot.file)
        d.addCallback(lambda _: log.spider_log(logfmt % "Stored", spider=spider))
        d.addErrback(log.spider_log, logfmt % "Error storing", spider=spider)
        return d

Example 32

Project: scrapyd Source File: test_spiderqueue.py
Function: test_clear
    @inlineCallbacks
    def test_clear(self):
        yield maybeDeferred(self.q.add, self.name, **self.args)
        yield maybeDeferred(self.q.add, self.name, **self.args)

        c = yield maybeDeferred(self.q.count)
        self.assertEqual(c, 2)

        yield maybeDeferred(self.q.clear)

        c = yield maybeDeferred(self.q.count)
        self.assertEqual(c, 0)

Example 33

Project: awspider Source File: pagegetter.py
    def _returnFreshData(self, 
            data, 
            request_hash, 
            url,  
            confirm_cache_write,
            http_history=None):
        LOGGER.debug("Got request %s for URL %s." % (request_hash, url))
        data["pagegetter-cache-hit"] = False
        data["content-sha1"] = hashlib.sha1(data["response"]).hexdigest()
        if http_history is not None and "content-sha1" in http_history:
            if http_history["content-sha1"] == data["content-sha1"]:
                return data
        d = maybeDeferred(self._storeData,
            data, 
            request_hash,  
            confirm_cache_write,
            http_history=http_history)
        d.addErrback(self._storeDataErrback, data, request_hash)
        return d

Example 34

Project: vumi Source File: protocol.py
    def on_pdu(self, pdu):
        """
        Handle a PDU that was received & decoded.

        :param dict pdu:
            The dict result one gets when calling ``smpp.pdu.unpack_pdu()``
            on the received PDU
        """
        self.emit('INCOMING << %r' % (pdu,))
        handler = getattr(self, 'handle_%s' % (command_id(pdu),),
                          self.on_unsupported_command_id)
        return maybeDeferred(handler, pdu)

Example 35

Project: awspider Source File: execution.py
Function: startcallback2
    def _startCallback2(self, data):
        if self.shutdown_trigger_id is not None:
            self.reportjobspeedloop = task.LoopingCall(self.reportJobSpeed)
            self.reportjobspeedloop.start(60)
            self.jobsloop = task.LoopingCall(self.executeJobs)
            self.jobsloop.start(1)
            if self.aws_sdb_coordination_domain is not None:
                self.peerCheckRequest()  
                d = maybeDeferred(self.coordinate)
                d.addCallback(self._startCallback3)
            else:
                self.queryloop = task.LoopingCall(self.query)
                self.queryloop.start(self.reservation_check_interval)

Example 36

Project: smokesignal Source File: smokesignal.py
def install_twisted():
    """
    If twisted is available, make `emit' return a DeferredList

    This has been successfully tested with Twisted 14.0 and later.
    """
    global emit, _call_partial
    try:
        from twisted.internet import defer
        emit = _emit_twisted
        _call_partial = defer.maybeDeferred
        return True
    except ImportError:
        _call_partial = lambda fn, *a, **kw: fn(*a, **kw)
        return False

Example 37

Project: txpostgres Source File: reconnection.py
Function: connectionrecovered
    def connectionRecovered(self):
        """
        Called when the connection has recovered.
        """
        self.connectionIsDead = False

        dl = []
        for handler in self.getRecoveryHandlers():
            d = defer.maybeDeferred(handler)
            d.addErrback(log.err)
            dl.append(d)

        return defer.gatherResults(dl)

Example 38

Project: wokkel Source File: test_ping.py
    def test_getDiscoInfo(self):
        """
        The ping namespace should be returned as a supported feature.
        """
        def cb(info):
            discoInfo = disco.DiscoInfo()
            for item in info:
                discoInfo.append(item)
            self.assertIn('urn:xmpp:ping', discoInfo.features)

        d = defer.maybeDeferred(self.protocol.getDiscoInfo,
                                JID('[email protected]/home'),
                                JID('pubsub.example.org'),
                                '')
        d.addCallback(cb)
        return d

Example 39

Project: Community-Zenpacks Source File: WBEMClient.py
    def _wbemExecQuery(self, query, namespace, instMap, qualifier):
        def parse(instances):
            results = {}
            if isinstance(instances, pywbem.CIMInstance):
                instances = [instances]
            for table, props in instMap[()]:
                results[table]=[self.parseInstance(i,props) for i in instances]
            return results

        d = defer.maybeDeferred(self._wbem.ExecQuery,
                                            'WQL',
                                            query,
                                            namespace=namespace)
        d.addCallback(parse)
        d.addErrback(self.parseError, classname, instMap)
        return d

Example 40

Project: python-tx-tftp Source File: session.py
Function: nextblock
    def nextBlock(self):
        """ACK datagram for the previous block has been received. Attempt to read
        the next block, that will be sent.

        """
        self.blocknum += 1
        d = maybeDeferred(self.reader.read, self.block_size)
        d.addCallbacks(callback=self.dataFromReader, errback=self.readFailed)
        return d

Example 41

Project: rpcudp Source File: protocol.py
    def _acceptRequest(self, msgID, data, address):
        if not isinstance(data, list) or len(data) != 2:
            raise MalformedMessage("Could not read packet: %s" % data)
        funcname, args = data
        f = getattr(self, "rpc_%s" % funcname, None)
        if f is None or not callable(f):
            msgargs = (self.__class__.__name__, funcname)
            log.err("%s has no callable method rpc_%s; ignoring request" % msgargs)
            return
        d = defer.maybeDeferred(f, address, *args)
        d.addCallback(self._sendResponse, msgID, address)

Example 42

Project: vumi Source File: endpoint_dispatchers.py
    def _mkhandler(self, handler_func, errback_func, connector_name):
        def handler(msg):
            d = maybeDeferred(self.get_config, msg)
            d.addCallback(handler_func, msg, connector_name)
            d.addErrback(errback_func, msg, connector_name)
            d.addErrback(self.default_errback, msg, connector_name)
            return d
        return handler

Example 43

Project: pth-toolkit Source File: deferredruntest.py
Function: run_user
    def _run_user(self, function, *args):
        """Run a user-supplied function.

        This just makes sure that it returns a Deferred, regardless of how the
        user wrote it.
        """
        d = defer.maybeDeferred(function, *args)
        return d.addErrback(self._got_user_failure)

Example 44

Project: txstatsd Source File: report.py
    def wrapped(self, function, report_function):
        def report_metrics(metrics):
            """For each metric returned, call C{report_function} with it."""
            for name, value in metrics.items():
                if self.instance_name:
                    name = self.instance_name + "." + name
                report_function(name, value)
            return metrics

        @wraps(function)
        def wrapper():
            """Wrap C{function} to report metrics or log a failure."""
            deferred = maybeDeferred(function)
            deferred.addCallback(report_metrics)
            deferred.addErrback(lambda failure: log.err(
                failure, "Error while processing %s" % function.func_name))
            return deferred
        return wrapper

Example 45

Project: wokkel Source File: test_ping.py
    def test_getDiscoItems(self):
        """
        Items are not supported by this handler, so an empty list is expected.
        """
        def cb(items):
            self.assertEquals(0, len(items))

        d = defer.maybeDeferred(self.protocol.getDiscoItems,
                                JID('[email protected]/home'),
                                JID('pubsub.example.org'),
                                '')
        d.addCallback(cb)
        return d

Example 46

Project: pika Source File: twisted_service.py
Function: read_item
    def _read_item(self, item, queue, callback):
        """Callback function which is called when an item is read."""
        d = queue.get()
        d.addCallback(self._read_item, queue, callback)
        d.addErrback(self._read_item_err)
        (channel, deliver, props, msg,) = item

        log.msg('%s (%s): %s' % (deliver.exchange, deliver.routing_key, repr(msg)), system='Pika:<=')
        d = defer.maybeDeferred(callback, item)
        d.addCallbacks(
            lambda _: channel.basic_ack(deliver.delivery_tag),
            lambda _: channel.basic_nack(deliver.delivery_tag)
        )

Example 47

Project: vumi Source File: txriak_manager.py
Function: run_map_reduce
    def run_map_reduce(self, mapreduce, mapper_func=None, reducer_func=None):
        def map_results(raw_results):
            deferreds = []
            for row in raw_results:
                deferreds.append(maybeDeferred(mapper_func, self, row))
            return gatherResults(deferreds)

        mapreduce_done = mapreduce.run(timeout=self.mapreduce_timeout)
        if mapper_func is not None:
            mapreduce_done.addCallback(map_results)
        if reducer_func is not None:
            mapreduce_done.addCallback(lambda r: reducer_func(self, r))
        return mapreduce_done

Example 48

Project: vumi-go Source File: vumi_app.py
    @inlineCallbacks
    def flush_backlog(self, key, message_class, callback):
        backlog_key = self.backlog_key(key)
        while True:
            obj = yield self.redis.rpop(backlog_key)
            if obj is None:
                break
            yield maybeDeferred(callback, message_class.from_json(obj))

Example 49

Project: scrapyd Source File: poller.py
Function: poll
    @inlineCallbacks
    def poll(self):
        if self.dq.pending:
            return
        for p, q in self.queues.iteritems():
            c = yield maybeDeferred(q.count)
            if c:
                msg = yield maybeDeferred(q.pop)
                returnValue(self.dq.put(self._message(msg, p)))

Example 50

Project: foolscap Source File: promise.py
Function: deliver
    def _deliver(self, methname, args, kwargs, resolver):
        # the resolver will be fired with both success and Failure
        t = self._target
        if isinstance(t, Promise):
            resolver(t._send(methname, args, kwargs))
        elif isinstance(t, Failure):
            resolver(t)
        else:
            d = defer.maybeDeferred(self._deliverOneMethod,
                                    methname, args, kwargs)
            d.addBoth(resolver)
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4