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
3
Example 1
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
3
Example 2
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
3
Example 3
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
3
Example 4
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
3
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
3
Example 6
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
3
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)
3
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
3
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
3
Example 10
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
3
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
3
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)])
3
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)
3
Example 14
def deferred_sleep(timeout):
d = Deferred()
def callbackDeferred():
d.callback(True)
reactor.callLater(timeout, callbackDeferred)
return d
3
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)
3
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
3
Example 17
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
3
Example 18
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()
3
Example 19
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
3
Example 20
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
3
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
3
Example 22
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()
3
Example 23
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)
3
Example 24
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
3
Example 25
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
3
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
3
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
3
Example 28
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()
3
Example 29
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
3
Example 30
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
3
Example 31
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
3
Example 32
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
3
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)
3
Example 34
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()
3
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
3
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
3
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))
3
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
3
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
3
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())
3
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
3
Example 42
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
3
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
3
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
3
Example 45
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
3
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)
3
Example 47
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
3
Example 48
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
3
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
3
Example 50
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()