docs: def disconnect(self, callback=None, sender=None, senders=None, key=None, keys=None, weak=True):
          '''
          *This method is a coroutine.*
  
          Disconnects the callback from the signal. If no arguments are
          supplied for ``sender``, ``senders``, ``key``, or ``keys`` -- the callback is
          completely disconnected. Otherwise, only the supplied ``senders`` and ``keys``
          are disconnected for the callback.
  
          .. Note::
  
              the argument ``weak`` must be the same as when the callback was
              connected to the signal.
          '''
          weak_callback = yield from self._get_ref(callback, weak)
  
          if (sender is None) and (senders is None) and (key is None) and (keys is None):
              # removing from _all signals
              # need a lock because we are changing the size of the dict
              if weak_callback in self._all:
                  with (yield from self._lock_all):
                      self._all.remove(weak_callback)
  
              with (yield from self._lock_by_senders):
                  sender_keys = list(self._by_senders.keys())
              for sender in sender_keys:
                  yield from self._disconnect_from_sender(weak_callback, sender, is_id=True)
  
              with (yield from self._lock_by_keys):
                  key_keys = list(self._by_keys.keys())
              for key in key_keys:
                  yield from self._disconnect_from_key(weak_callback, key)
  
          else:
              # only disconnect from specific senders/keys
              if sender is not None:
                  yield from self._disconnect_from_sender(weak_callback, sender)
  
              if senders is not None:
                  for sender in senders:
                      yield from self._disconnect_from_sender(weak_callback, sender)
  
              if key is not None:
                  yield from self._disconnect_from_key(weak_callback, key)
  
              if keys is not None:
                  for key in keys:
                      yield from self._disconnect_from_key(weak_callback, key)