Differences between revisions 1 and 5 (spanning 4 versions)
Revision 1 as of 2008-05-07 19:56:23
Size: 1062
Editor: GlennTarbox
Comment:
Revision 5 as of 2008-11-14 13:41:51
Size: 1756
Editor: anonymous
Comment: converted to 1.6 markup
Deletions are marked like this. Additions are marked like this.
Line 1: Line 1:
## page was renamed from GlennTarbox/TwistedTalk/100 Twisted Deconstructed
Line 8: Line 9:
[[Navigation(slides)]] <<Navigation(slides)>>
Line 10: Line 11:
 * We got &ldquo;Both Kinds&rdquo;
  * I/O Bound - Twisted's Domain
  * Compute Bound - Twisted Can Help
== We got Both Kinds ==
Line 14: Line 13:
 * Non-Blocking Calls
  * Register Callback - O.registerCallback(fn, *args, **kargs)
   * &ldquo;fn&rdquo; can be function or method
   * def fn(result, *args, **kargs) &larr; signature of callback
 * I/O Bound
 * Compute Bound

== Waiting For Answers ==
 1. Just Wait... wasn't doing nothin' anyway
 1. Spawn Process
 1. Spawn Thread
 1. Non-blocking calls and "a plan"

== Non-Blocking Calls ==
  * Register Callback
{{{#!python
O.registerCallback(fn, *args, **kargs) # fn can be function or method

def fn(result, *args, **kargs)
  print "important message: ", result
}}}
Line 19: Line 32:
   * d `=` O.meth(...)
   * d.addCallback(fn,*args,**kargs)
   * d.addCallback(fn2, ...)
   * d.addErrback(errfn,...)
{{{#!python
d = O.doComplicatedLengthyCalc(a, b, c) # returns deferred
def gotResult(result)
  print "important message: ", result
  return "a more important message"
d.addCallback(gotResult) # first callback
def gotResult2(result, i2, s2, specialLabel)
   print "gotResult2 returns: ", result # will print "a more important message"
   print i2, s2, specialLabel # will print "2, string2, special"
d.addCallback(gotResult2, 2, "string2", specialLabel="special")
d.addErrback(errfn,...) # exception handling for deferreds
}}}

This is a very important passage... but don't hurt your brain!!
Line 27: Line 50:
...
Line 29: Line 51:
[[Navigation(siblings)]] <<Navigation(siblings)>>

Concurrency

We got Both Kinds

  • I/O Bound
  • Compute Bound

Waiting For Answers

  1. Just Wait... wasn't doing nothin' anyway
  2. Spawn Process
  3. Spawn Thread
  4. Non-blocking calls and "a plan"

Non-Blocking Calls

  • Register Callback

   1 O.registerCallback(fn, *args, **kargs) # fn can be function or method
   2 
   3 def fn(result, *args, **kargs)
   4   print "important message: ", result
  • Use Deferreds

   1 d = O.doComplicatedLengthyCalc(a, b, c) # returns deferred
   2 def gotResult(result)
   3   print "important message: ", result
   4   return "a more important message"
   5 d.addCallback(gotResult)             # first callback
   6 def gotResult2(result, i2, s2, specialLabel)
   7    print "gotResult2 returns: ", result # will print "a more important message"
   8    print i2, s2, specialLabel               # will print "2, string2, special"
   9 d.addCallback(gotResult2, 2, "string2", specialLabel="special")
  10 d.addErrback(errfn,...)    # exception handling for deferreds

This is a very important passage... but don't hurt your brain!!

If you need to call a method that returns a deferred within your callback chain, just return that deferred, and the result of the secondary deferred's processing chain will become the result that gets passed to the next callback of the primary deferreds processing chain

DsageNg/TwistedTalk/100_Twisted_Deconstructed (last edited 2008-11-14 13:41:51 by anonymous)