Either (if callble is None) remove all callables,
        which were added alongside observer,
        or remove callable `callble` which was added alongside
        the observer `observer`.
973410
def remove_observer(self, observer, callble=None):
        
        to_remove = []
        for poc in self.observers:
            _, obs, clble = poc
            if callble is not None:
                if (obs is observer) and (callble == clble):
                    to_remove.append(poc)
            else:
                if obs is observer:
                    to_remove.append(poc)
        for r in to_remove:
            self.observers.remove(*r)
1347176
def cancel(self):
        
        LOG.debug('cancelling %s', self)
        self._cancelled = True
        self.clear_callbacks()  # not strictly necessary, but may release references
        while True:
            try:
                self._waitables.get_nowait().put_nowait(self.sentinel)
            except queue.Empty:
                break
388195
def remove_listener(self, callback):
        
        listeners = filter(lambda x: x['callback'] == callback, self.listeners)
        for l in listeners:
            self.listeners.remove(l)
208393
def clear_callbacks(obj):
    """"""
    callbacks = obj._callbacks
    if isinstance(callbacks, dllist):
        # Help the garbage collector by clearing all links.
        callbacks.clear()
    obj._callbacks = None
470041
protected function removeCall(Call $call)
    {
        $call->getProcedure()->removeCall($call);
        unset($this->callInvocationIndex[$call->getInvocationRequestId()]);
        unset($this->callRequestIndex[$call->getCallMessage()->getRequestId()]);
        if ($call->getCancelMessage()) {
            unset($this->callCancelIndex[$call->getCancelMessage()->getRequestId()]);
        }
        if ($call->getInterruptMessage()) {
            unset($this->callInterruptIndex[$call->getInterruptMessage()->getRequestId()]);
        }
    }
133101
def cancel(self):
        
        if self.cancelled:
            raise error.AlreadyCancelled
        elif self.called:
            raise error.AlreadyCalled
        else:
            self.canceller(self)
            self.cancelled = 1
            if self.debug:
                self._str = str(self)
            del self.func, self.args, self.kw
867854
def unregister_callback(callback_id):
    """"""
    global _callbacks
    obj = _callbacks.pop(callback_id, None)
    threads = []
    if obj is not None:
        t, quit = obj
        quit.set()
        threads.append(t)
    for t in threads:
        t.join()
1065517
boolean removeObserver(ApptentiveNotificationObserver observer) {
		int index = indexOf(observer);
		if (index != -1) {
			observers.remove(index);
			return true;
		}
		return false;
	}
1362080
public function remove_callable($class)
	{
		if (($key = array_search($class, $this->callables, true)))
		{
			unset($this->callables[$key]);
		}

		return $this;
	}
358982
def decode_call(self, call):
        
        # Callable name is None when callable is part of exclude list
        if call is None:
            return None
        itokens = call.split(self._callables_separator)
        odict = {}
        for key, value in self._clut.items():
            if value in itokens:
                odict[itokens[itokens.index(value)]] = key
        return self._callables_separator.join([odict[itoken] for itoken in itokens])
837240
def delete(observer)
      old_size = @stack.size
      @stack.delete_if do |o|
        o[:observer] == observer
      end
      old_size == @stack.size ? nil : observer
    end
1124153
public void cleanupAttachmentsForCall(Context context, UUID callId) {
        File dir = getAttachmentsDirectoryForCall(callId, false);
        Utility.deleteDirectory(dir);
    }
951082
private void closeCallback(AddOnModel addOnModel, IzouSoundLine izouSoundLine) {
        debug("removing soundline " + izouSoundLine + " from " + addOnModel);
        Predicate<WeakReference<IzouSoundLineBaseClass>> removeFromList =
                weakReference -> weakReference.get() != null && weakReference.get().equals(izouSoundLine);
        synchronized (permanentUserReadWriteLock) {
            if (permanentAddOn != null && permanentAddOn.equals(addOnModel) && permanentLines != null) {
                permanentLines.removeIf(removeFromList);
                if (permanentLines.isEmpty()) {
                    permanentLines = null;
                    permissionWithoutUsage();
                }
            }
        }
        List<WeakReference<IzouSoundLineBaseClass>> weakReferences = nonPermanent.get(addOnModel);
        if (weakReferences != null) {
            weakReferences.removeIf(removeFromList);
            synchronized (mutingLock) {
                if (mutingManager != null && mutingManager.getMuting().equals(addOnModel)) {
                    mutingManager = mutingManager.remove(izouSoundLine);
                }
            }
        }
        submit(this::tidy);
    }
563126
def remove_callback(self, callback):
        """"""
        if callback in self.callbacks:
            self.callbacks.remove(callback)
552674
@Override
    public void removeObserver(final Observer<S, T> observer) {
        synchronized (OBSERVER_LOCK) {
            observers.remove(observer);
        }
    }
59033
def remove(self, event=None):
        
        observers = self._pool.get(event)
        if observers:
            self._pool[event] = []
1267276
def removeCallback(cls, eventType, func, record=None):
        
        callbacks = cls.callbacks()
        callbacks.setdefault(eventType, [])
        for i in xrange(len(callbacks[eventType])):
            my_func, my_record, _ = callbacks[eventType][i]
            if func == my_func and record == my_record:
                del callbacks[eventType][i]
                break