Remove an observer to a valid signal.

        Parameters
        ----------
        signal : str
            a valid signal.
        observer : @func
            an obervation function to be removed.
966712
def _remove_observer(self, signal, observer):
        

        if observer in self._observers[signal]:
            self._observers[signal].remove(observer)
750462
def register_observer(self, observer, events=None):
        
        if events is not None and not isinstance(events, (tuple, list)):
            events = (events,)

        if observer in self._observers:
            LOG.warning("Observer '%r' already registered, overwriting for events"
                        " %r", observer, events)
        self._observers[observer] = events
1267754
def remove_callback(self, signal_name, callback):
		
		try:
			self.__direct_callbacks[signal_name].remove(callback)
		except KeyError:
			raise ValueError('Signal "%s" does not have the specified callback' % signal_name)
394624
def unregister_signals(self):
        """"""
        # Unregister Record signals
        if hasattr(self, 'update_function'):
            records_signals.before_record_insert.disconnect(
                self.update_function)
            records_signals.before_record_update.disconnect(
                self.update_function)
        self.unregister_signals_oaiset()
402724
def remove_listener(self, listener):
        
        internal_listener = self._internal_listeners.pop(listener)
        return self._client.remove_listener(internal_listener)
517366
def delete_entity_signal_handler(sender, instance, **kwargs):
    
    if instance.__class__ in entity_registry.entity_registry:
        Entity.all_objects.delete_for_obj(instance)
1106184
def kill(name, signal):
    '''
    
    '''
    if not exists(name):
        raise ContainerNotExists("The container (%s) does not exist!" % name)
    cmd = ['lxc-kill', '--name=%s' % name, signal]
    subprocess.check_call(cmd)
1053629
public void removeClientObserver (ClientObserver observer)
    {
        _clobservers.remove(observer);
        if (observer instanceof DetailedClientObserver) {
            _dclobservers.remove((DetailedClientObserver)observer);
        }
    }
1340253
def stopObserver(self):
        
        self._observer.isStopped = True
        self._observer.isRunning = False
552674
@Override
    public void removeObserver(final Observer<S, T> observer) {
        synchronized (OBSERVER_LOCK) {
            observers.remove(observer);
        }
    }
1110346
def pop_message(self, till=None):
        

        if till is not None and not isinstance(till, Signal):
            Log.error("Expecting a signal")
        return Null, self.pop(till=till)
843741
def do_signal(self, signame: str) -> None:
        """"""
        if hasattr(signal, signame):
            os.kill(os.getpid(), getattr(signal, signame))
        else:
            self._sout.write('Unknown signal %s\n' % signame)
1002472
def removeObserver(self, observer):
        
        with self._lock:
            self._weak_observers.remove(weakref.ref(observer))
            if len(self._weak_observers) == 0:
                self.stopThread()
59033
def remove(self, event=None):
        
        observers = self._pool.get(event)
        if observers:
            self._pool[event] = []
787185
def _notify_remove(self, slice_):
        """"""
        change = RemoveChange(self, slice_)
        self.notify_observers(change)
651835
public synchronized void removeObserver(final ApptentiveNotificationObserver observer) {
		for (ApptentiveNotificationObserverList observers : observerListLookup.values()) {
			observers.removeObserver(observer);
		}
	}
1016273
@Override
	public boolean remove(Object o) {
		boolean b = queue.remove(o);
		if (b){
			signalSizeReduced();
		}
		return b;
	}