def _handle_event(self, event_type, args=(), respond_to=False):
     """handles event dispatch"""
     for event in self.events[event_type]:
         if self.config['threaded']:
             threads.deferToThread(self._event, event, args, respond_to)
         else:
             defer.execute(self._event, event, args, respond_to)

 def handle_line(self, line):
     """Deal with a line of input."""
     # TODO this should be part of debug output in the irc shell, too, and
     # not baked in here
     log.msg("received: " + repr(line))
     from twisted.internet import defer
     # XXX this is here cause it allows exceptions to actually be caught; be more careful with that in general
     defer.execute(self._handle_line, line)

 def _start_tasks(self):
     """starts all tasks"""
     if self.tasks:
         for task in self.tasks:
             func, repeat, scale = self.tasks[task]
             if self.config['threaded']:
                 threads.deferToThread(self._task, task, func, repeat, scale)
             else:
                 defer.execute(self._task, task, func, repeat, scale)

 def _handle_command(self, channel, nick, host, msg):
     """handles command dispatch"""
     msg = msg.split()
     command = self.commands.get(msg[0][1:].lower(), None)
     if command:
         if self._check_permission(command._restrict, nick, host):
             if self.config['threaded']:
                 threads.deferToThread(self._command, command, channel, nick, host, msg)
             else:
                 defer.execute(self._command, command, channel, nick, host, msg)

 def listen(self, protocolFactory):
     """
     Implement L{IStreamServerEndpoint.listen} to listen on a TCP socket
     """
     return defer.execute(
         self._reactor.listenTCP, self._port, protocolFactory, backlog=self._backlog, interface=self._interface
     )

 def wrapper(*args, **kwargs):
     assert len(kwargs) == 0, (
         "The Provisioning API is meant to be used via XML-RPC, "
         "for now, so its methods are prevented from use with "
         "keyword arguments, which XML-RPC does not support.")
     # TODO: Convert exceptions into Faults.
     return defer.execute(func, *args)

    def loadModel(self, path, request):
        """Load a model, for the given path and request.

        @rtype: L{Deferred}
        """
        from twisted.internet.defer import execute
        return execute(self.loadModelNow, path, request)

 def wrapper(*args, **kwargs):
     if not _testing:
         return deferToThreadPool(reactor, _threadpool,
                                  run_in_tx, fun, *args, **kwargs)
     else:
         # No threading during testing
         return defer.execute(run_in_tx, fun, *args, **kwargs)

 def listen(self, protocolFactory):
     return defer.execute(twisted.listenTLS,
                          self._reactor,
                          self._port,
                          protocolFactory,
                          self._credentials,
                          backlog=self._backlog,
                          interface=self._interface)

 def listen(self, protocolFactory):
     """
     Implement L{IStreamServerEndpoint.listen} to listen on a UNIX socket.
     """
     return defer.execute(self._reactor.listenUNIX, self._address,
                          protocolFactory,
                          backlog=self._backlog,
                          mode=self._mode,
                          wantPID=self._wantPID)

 def callRemote(self, method, *args, **kw):
     if hasattr(self.interfaceClass, method):
         result = defer.execute(self._callMethod, method, *args, **kw)
         return result
     elif self.failWhenNotImplemented:
         return defer.fail(
             Failure(NotImplementedError,
                     "No Such Method in Interface: %s" % method))
     else:
         return defer.succeed(None)

    def get_state(self):
        """
        Reads state from the file.

        :returns: `Deferred` that fires with the current state.
        """
        def _read():
            if os.path.exists(self.filename):
                return open(self.filename).read()

        return defer.execute(_read)

 def lookupAddress(self, name, timeout=None):
     """
     The twisted function which is called when an A record lookup is
     requested.
     :param name: The domain name being queried for (e.g. example.org).
     :param timeout: Time in seconds to wait for the query response.
     (optional, default: None)
     :return: A DNS response for the record query.
     """
     log.msg("Query for %s" % name)
     d = defer.execute(queryAddress, name)
     return d

    def connectionMade(self):

        if not self.factory.retrieved_file_queue:
            # Create once, queue persists in the factory
            self.factory.retrieved_file_queue = collections.deque('', SEARCH_SIZE)

        # Only need to scan the local directory during startup
        if len(self.factory.retrieved_file_queue) == 0:
            d = defer.execute(self._process_local_files)
            d.addErrback(self._process_local_files_errback)
            d.addCallback(lambda ignore: self._change_directory())    # suppress the returned result
        else:
            self._change_directory()

    def freeze_commit(self, events):
        """Unfreezes the frozen path, sending received events if not dirty.

        If events for that path happened:
            - return True
        else:
            - push the here received events, return False
        """
        if self._processor.frozen_path is None:
            raise ValueError("Committing with nothing frozen!")

        d = defer.execute(self._processor.freeze_commit, events)
        return d

    def run(self):

        d = defer.execute(self.__callbacks[0], *self.__args)
        if not self.__err_back:
            self.__err_back = self.on_error
        d.addErrback(self.__err_back)

        for cb in self.__callbacks[1:]:
            d.addCallback(cb)

        self.__reactor.callLater(self.__interval, self.run)

        if not self.__reactor.running:
            self.__reactor.run()

def execute_db_retriever(engine, database, **kwargs):
    log.msg("Get db data is called with %s:%s" % (engine, database))

    def callback():
        headerRow = ["name", "city", "country"]
        dataRows = [["Lionel", "Rosario", "Argentina"], ["Andres", "Albacete", "Spain"]]
        stream = Stream()
        stream.configs = dict(kwargs)
        stream.configs["engine"] = engine
        stream.configs["database"] = database
        db = DatabaseRetriever(stream)
        dataRows = db.execute()
        result = {"headerRow": stream.configs["columns"], "dataRows": dataRows}
        return result

    return defer.execute(callback)

    def setup_display(self, result=None):
        def func0(result=None):
            self.surface = pygame.display.set_mode(DISPLAY_SIZE)
            self.surface.fill((0, 0, 0))
            self.background = pygame.Surface(DISPLAY_SIZE)
            self.background.fill((0, 0, 0))

        def func1(result=None):
            return threads.deferToThread(self.handle_display)

        def func2(result=None):
            c = task.LoopingCall(func1)
            c.start(FPS, now=False)

        d = defer.execute(func0)
        d.addCallback(func2)
        return d

def get_buddyicon(flickr, data, size=48):
    """Lookup the buddyicon from the data in @data using @flickr and resize it
    to @size pixels."""

    global __buddy_cache
    if __buddy_cache is None:
        folder = os.path.join (get_cache_path(), "postr")
        if not os.path.exists(folder):
            os.makedirs(folder)
        path = os.path.join (folder, "buddyicons")
        try:
            __buddy_cache = bsddb3.hashopen(path, "c")
        except bsddb3.db.DBInvalidArgError:
            # The database needs upgrading, so delete it
            os.remove(path)
            __buddy_cache = bsddb3.hashopen(path, "c")

    def load_thumb(page, size):
        loader = GdkPixbuf.PixbufLoader()
        loader.set_size (size, size)
        loader.write(page)
        loader.close()
        return loader.get_pixbuf()

    def got_data(page, url, size):
        __buddy_cache[url] = page
        return load_thumb(page, size)

    if int(data.get("iconfarm")) > 0:
        url = "http://farm%s.static.flickr.com/%s/buddyicons/%s.jpg" % (data.get("iconfarm"), data.get("iconserver"), data.get("nsid"))
    else:
        url = "http://www.flickr.com/images/buddyicon.jpg"

    if __buddy_cache.has_key(url):
        return defer.execute(load_thumb, __buddy_cache[url], size)
    else:
        deferred = getPage(url)
        deferred.addCallback(got_data, url, size)
        deferred.addErrback(log.err)
        return deferred

 def abort(self, taskid):
     """
     Remove a task from the queue if it has not been run already.
     """
     if not isinstance(taskid, int):
         return defer.fail(failure.Failure(TypeError("an integer task id expected: %r" % taskid)))
     try:
         self.scheduler.pop_task(taskid)
     except IndexError as e:
         if taskid in list(self.finishedResults.keys()):
             d = defer.fail(IndexError("Task Already Completed"))
         elif taskid in self.abortPending:
             d = defer.fail(IndexError("Task Already Aborted"))
         elif taskid in self._pendingTaskIDs():# task is pending
             self.abortPending.append(taskid)
             d = defer.succeed(None)
         else:
             d = defer.fail(e)
     else:
         d = defer.execute(self._doAbort, taskid)
     
     return d