code: def close(self, **kw):
          
  
          # we're already closed; nothing to do
          if self.state == 'CLOSED':
              return defer.succeed(None)
  
          # someone already called close() but we're not closed yet
          if self._closing_deferred:
              d = defer.Deferred()
  
              def closed(arg):
                  d.callback(arg)
                  return arg
              self._closing_deferred.addBoth(closed)
              return d
  
          # actually-close the circuit
          self._closing_deferred = defer.Deferred()
  
          def close_command_is_queued(*args):
              return self._closing_deferred
          d = self._torstate.close_circuit(self.id, **kw)
          d.addCallback(close_command_is_queued)
          return d
docs: This asks Tor to close the underlying circuit object. See
          :meth:`txtorcon.torstate.TorState.close_circuit`
          for details.
  
          You may pass keyword arguments to take care of any Flags Tor
          accepts for the CLOSECIRCUIT command. Currently, this is only
          "IfUnused". So for example: circ.close(IfUnused=True)
  
          :return: Deferred which callbacks with this Circuit instance
              ONLY after Tor has confirmed it is gone (not simply that the
              CLOSECIRCUIT command has been queued). This could be a while
              if you included IfUnused.