Deadlock when adding watch callback in a callback about python-etcd3 HOT 2 OPEN

def run(self):
    try:
        for response in self._watch_response_iterator:
            if response.created:
                self._watch_id_callbacks[response.watch_id] = self._callback
                self._watch_id_queue.put(response.watch_id)   # Return the new watch id to user

            callback = self._watch_id_callbacks.get(response.watch_id)
            if callback:
                for event in response.events:
                    callback(events.new_event(event))  # Invoked user-defined callbacks
    except grpc.RpcError as e:
        # ...

def add_callback(self, key, callback, range_end=None, start_revision=None, progress_notify=False,
                 filters=None, prev_kv=False):
    with self._watch_id_lock:
        # ....
        self._watch_requests_queue.put((request, callback))
        return self._watch_id_queue.get(timeout=self.timeout)  # Deadlock if invoked by `Watcher.run`

import random
import threading

import etcd3

class EtcdClient(object):

    def __init__(self, host='127.0.0.1', port=2379, timeout=None):
        random.seed()
        self._etcds = [etcd3.client(host=host, port=port, timeout=timeout),
                       etcd3.client(host=host, port=port, timeout=timeout)]
        self._watcher_idents = {etcd.watcher.ident: etcd
                                for etcd in self._etcds}
        assert self._watcher_idents.keys()[0] != self._watcher_idents.keys()[1]

    @property
    def _etcd(self):
        current_ident = threading.current_thread().ident
        if current_ident not in self._watcher_idents:
            return self._etcds[random.randint(0, 1)]  # Load balancing ;-P
        else:
            for watcher_idents, etcd in self._watcher_idents.items():
                if watcher_idents != current_ident:
                    return etcd  # Use the other client to handle the request

    def add_watch_callback(self, *args, **kwargs):
        etcd = self._etcd
        watch_id = etcd.add_watch_callback(self.task_key_prefix,
                                           _inner_callback,
                                           range_end=range_end)
        return etcd, watch_id  # The user should treat this tuple as a whole at all time

    def cancel_watch(self, watch_id):
        etcd, watch_id = watch_id
        etcd.cancel_watch(watch_id)