[Twisted-Python] inlineCallbacks: multiple yielding same Defferred behaviour

Sergey V. Gerasimov sergun at gmail.com
Mon Jan 28 04:37:36 EST 2013

Hi Laurens,


Thanks for your reply!


I need something like this.

A server that processes requests and handles situation when there are 2
requests with same key.


class Server(object):

                def __init__(self):

                                self.requestsInProgress = {} # dict: key ->
Deferred with result



                def request(self, key):

                               in_progress = key in self.requests

                               if in_progress:

                                               d = self.requestsInProgress

                                               result = yield d


                                               d = process_request(key)

                                               self.requests[key] = d

                                               result = yield d

                                               del self.requestsInProgress



How can I implement the logic correctly?


In my opinion it's very simple and clear concept to consider Deferred just
like deferred execution of some action. In this case you should be able to
get it's result (doing yield) many times (why not?).



I have deal with Task-based programming and async functions (mechanism
similar to Deferred and inlineCallbacks decorated functions in Twisted) in
Microsoft  .NET.

MS people have implemented Task (analogue of Deferred) in the way I



From: Laurens Van Houtven [mailto:_ at lvh.cc] 
Sent: Monday, January 28, 2013 12:47 PM
To: sergun at gmail.com; Twisted general discussion
Subject: Re: [Twisted-Python] inlineCallbacks: multiple yielding same
Defferred behaviour


I'm not entirely sure why you feel this is unintuitive or why you should
need a workaround; in any other case, deferreds work pretty much the same

When reading this code, the first question that pops up in my head is: why
are you doing this instead of just using the result that you already have
(and assigned to a name)? How did this  waiting-twice-on-one-deferred


On Mon, Jan 28, 2013 at 8:47 AM, Sergey V. Gerasimov <sergun at gmail.com>

It's not intuitively clear why multiple yielding the same Defferred in
function decorated with defer.inlineCallbacks get different results:



def f():

                d = defer.succeed(1)

                result = yield d

print result

                result = yield d

print result






Probably we SHOULD NOT think if "d" was or was not yielded before when using


Are they some workarounds?


Twisted-Python mailing list
Twisted-Python at twistedmatrix.com




-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://twistedmatrix.com/pipermail/twisted-python/attachments/20130128/7c276bff/attachment-0001.htm 

More information about the Twisted-Python mailing list