gevent.hub.LoopExit: This operation would block forever about gevent HOT 3 OPEN

class Ticker(threading.Thread):
    def __init__(self, period, callback, *args, **kwargs):
        self._run_on_start = kwargs.pop("run_on_start", True)
        super(Ticker, self).__init__(*args, **kwargs)
        self._period = period
        self._callback = callback
        self._hand = True

    def stop(self):
        self._hand = False

    def run(self):
        while self._hand:
            if not self._run_on_start:
                time.sleep(self._period)

            try:
                self._callback()
            except BaseException:
                log.error(traceback.format_exc())

            if self._run_on_start:
                time.sleep(self._period)

class Persister(gevent.greenlet.Greenlet):
    def __init__(self):
        super(Persister, self).__init__()

        self._queue = gevent.queue.Queue()
        self._complete = gevent.event.Event()

        self._session = Session()

    def __getattribute__(self, item):
        """
        Wrap functions with logging
        """
        if item.startswith('_'):
            return object.__getattribute__(self, item)
        else:
            try:
                return object.__getattribute__(self, item)
            except AttributeError:
                try:
                    attr = object.__getattribute__(self, "_%s" % item)
                    if callable(attr):
                        def defer(*args, **kwargs):
                            dc = DeferredCall(attr, args, kwargs)
                            self._queue.put(dc)

                        return defer
                    else:
                        return object.__getattribute__(self, item)
                except AttributeError:
                    return object.__getattribute__(self, item)
  
    def _run(self):
        log.info("Persister listening")

        while not self._complete.is_set():
            try:
                data = self._queue.get(block=True, timeout=1)
            except gevent.queue.Empty:
                continue
            else:
                try:
                    data.fn(*data.args, **data.kwargs)
                    self._session.commit()
                except Exception:
                    # Catch-all because all kinds of things can go wrong and
                    # our behaviour is the same: log the exception, the data
                    # that caused it, then try to go back to functioning.
                    log.exception(
                        "Persister exception persisting data: %s" %
                        (data.fn,))

                    self._session.rollback()

    def stop(self):
        self._complete.set()