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
3
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
3
Example 2
@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)
3
Example 3
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
3
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
3
Example 5
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)
3
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
3
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)
3
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
3
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
3
Example 10
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
3
Example 11
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
3
Example 12
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)
3
Example 13
@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])
3
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
3
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)
3
Example 16
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
3
Example 17
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
3
Example 18
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
3
Example 19
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
3
Example 20
@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)
3
Example 21
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
3
Example 22
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)
3
Example 23
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
3
Example 24
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())
3
Example 25
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
3
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
3
Example 27
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
3
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)
3
Example 29
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
3
Example 30
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)
3
Example 31
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
3
Example 32
@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)
3
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
3
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)
3
Example 35
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)
3
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
3
Example 37
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)
3
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
3
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
3
Example 40
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
3
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)
3
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
3
Example 43
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)
3
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
3
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
3
Example 46
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)
)
3
Example 47
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
3
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))
3
Example 49
@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)))
3
Example 50
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)