docs: def Receive(self, replytype, chain=None, **kw):
          """This method allows code to act in a synchronous manner, it waits to 
          return until the deferred fires but it doesn't prevent other queued 
          calls from being executed.  Send must be called first, which sets up 
          the chain/factory.  
          
          WARNING: If defer is set to True, must either call Receive
          immediately after Send (ie. no intervening Sends) or pass
          chain in as a paramter.
          
          Parameters:
              replytype -- TypeCode
          KeyWord Parameters:
              chain -- processing chain, optional
              
          """        
          chain = chain or self.chain
          d = chain.flow.deferred
          if self.trace:
              def trace(soapdata):
                  print >>self.trace, "_" * 33, time.ctime(time.time()), "RESPONSE:"
                  print >>self.trace, soapdata
                  return soapdata
              
              d.addCallback(trace)
              
          chain.processResponse(d, replytype, **kw)
          if self.defer:
              return d
  
          failure = []
          append = failure.append
          def errback(result):
              """Used with Response method to suppress 'Unhandled error in 
              Deferred' messages by adding an errback.
              """
              append(result)
              return None
          
          d.addErrback(errback)
  
          # spin reactor
          while not d.called:
              reactor.runUntilCurrent()
              t2 = reactor.timeout()
              t = reactor.running and t2
              reactor.doIteration(t)
  
          pyobj = d.result
          if len(failure):
              failure[0].raiseException()
          
          return pyobj