unregister handler (removing callback function)
198175
def unhandle(self, handler):
        
        with self._hlock:
            try:
                self._handler_list.remove(handler)
            except ValueError:
                raise ValueError("Handler is not handling this event, so cannot unhandle it.")
        return self
168759
def unregister(cls, plugin):
        
        plugs = getattr(cls, '_%s__plugins' % cls.__name__, {})
        try:
            plugs.pop(plugin.name())
        except AttributeError:
            pass
        except ValueError:
            pass
1164324
def remove_request_init_listener(self, fn, *args, **kwargs):
        
        self._request_init_callbacks.remove((fn, args, kwargs))
1059733
def unregister_signal_handlers():
    
    signal.signal(SIGNAL_STACKTRACE, signal.SIG_IGN)
    signal.signal(SIGNAL_PDB, signal.SIG_IGN)
54669
def _unregisterHandler(self, handler, shutdown=True):
        
        if handler in self._handlers:
            self._handlers.remove(handler)
            self._logger.removeHandler(handler)
            if shutdown:
                try:
                    handler.close()
                except KeyError:
                    # Depending on the Python version, it's possible for this call
                    # to fail most likely because some logging module objects get
                    # garbage collected before the VSGLogger object is.
                    pass
213727
def remove_handler(self, handler):
        
        try:
            self._events[handler.type].remove(handler)
            return True
        except ValueError:
            return False
1126225
def unregister(self, event):
        
        if self.running:
            raise RuntimeError("Can't unregister while running")
        self._handlers.pop(event, None)
922612
function(event, handler) {
    return events.off({
      listeners: this._listeners,
      event: event,
      handler: handler
    });
  }
735779
def register_callback(self, callback, remove=False):
        """"""

        # (Un)Register the callback.
        if remove and callback in self.callbacks:
            self.callbacks.remove(callback)
        elif not remove and callback not in self.callbacks:
            self.callbacks.append(callback)
1120341
public void unregisterCallback(String importer) {
        if (   importer == null
            || !m_callbacks.getReference().containsKey(importer)
            || m_unregistered.getReference().contains(importer))
        {
            return;
        }
        if (m_done.get()) return;

        int [] rstamp = new int[]{0};
        NavigableMap<String,ChannelChangeCallback> rprev = null;
        NavigableMap<String,ChannelChangeCallback> rnext = null;

        int [] ustamp = new int[]{0};
        NavigableSet<String> uprev = null;
        NavigableSet<String> unext = null;

        synchronized(m_undispatched) {
            do {
                rprev = m_callbacks.get(rstamp);
                rnext = ImmutableSortedMap.<String,ChannelChangeCallback>naturalOrder()
                        .putAll(Maps.filterKeys(rprev, not(equalTo(importer))))
                        .build();
            } while (rprev.containsKey(importer) && !m_callbacks.compareAndSet(rprev, rnext, rstamp[0], rstamp[0]+1));

            do {
                uprev = m_unregistered.get(ustamp);
                unext = ImmutableSortedSet.<String>naturalOrder()
                        .addAll(Sets.filter(uprev, not(equalTo(importer))))
                        .add(importer)
                        .build();
            } while (!uprev.contains(importer) && m_unregistered.compareAndSet(uprev, unext, ustamp[0], ustamp[0]+1));

            Iterator<ImporterChannelAssignment> itr = m_undispatched.iterator();
            while (itr.hasNext()) {
                final ImporterChannelAssignment assignment = itr.next();
                if (unext.contains(assignment.getImporter())) {
                    itr.remove();
                }
            }
        }
    }
1176149
void unregister(AbstractAppHandle handle) {
    for (Map.Entry<String, AbstractAppHandle> e : secretToPendingApps.entrySet()) {
      if (e.getValue().equals(handle)) {
        String secret = e.getKey();
        secretToPendingApps.remove(secret);
        break;
      }
    }

    unref();
  }
398159
public void unregisterCallback(UOWScopeCallback callback)
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "unregisterCallback", new Object[]{callback, this});
        
        _callbackManager.removeCallback(callback);
        
        if (tc.isEntryEnabled()) Tr.exit(tc, "unregisterCallback");
    }
798637
def UnregisterFlowProcessingHandler(self, timeout=None):
    """"""
    if self.flow_processing_request_handler_thread:
      self.flow_processing_request_handler_stop = True
      self.flow_processing_request_handler_thread.join(timeout)
      if self.flow_processing_request_handler_thread.isAlive():
        raise RuntimeError("Flow processing handler did not join in time.")
      self.flow_processing_request_handler_thread = None
307660
function off (state, eventName, handler) {
  if (arguments.length === 2) {
    state.emitter.removeAllListeners(eventName)
  } else {
    state.emitter.removeListener(eventName, handler)
  }

  return state.api
}
738362
def UnregisterMessageHandler(self, timeout=None):
    """"""
    if self.handler_thread:
      self.handler_stop = True
      self.handler_thread.join(timeout)
      if self.handler_thread.isAlive():
        raise RuntimeError("Message handler thread did not join in time.")
      self.handler_thread = None
68852
function deleteDelegatedHandler(eventOptions = {}) {
    const { key } = eventOptions;
    const def = defs.get(this);

    if (key && key in def.keys) {
        triggerOne(this, '_asterisk:remove', eventOptions);
    }
}
826753
public static function unregister()
    {
        $nc = '\\' . get_called_class();

        App::off('error',     array( $nc, 'renderError' ));
        App::off('terminate', array( $nc, 'renderPerformance' ));
        App::off('terminate', array( $nc, 'renderClasses' ));

        if (false === empty(self::$displayErrors)) {
            function_exists('init_set') && ini_set('display_errors', self::$displayErrors);

            self::$displayErrors = null;
        }
    }