Resets the handlers for particular signals to the default

   * signals: An array of signal names to reset the handlers for
553454
def reset_handlers_for(signals)
        logger.debug "Resetting signal handlers for #{signals.inspect}"
        signals.each {|signal| Signal.trap signal, "DEFAULT" }
      end
1200044
def instance_signals_and_handlers(cls, instance):
        """"""
        isignals = cls._signals.copy()

        ihandlers = cls._build_instance_handler_mapping(
            instance,
             cls._signal_handlers
        )
        return isignals, ihandlers
233714
def reset(self):
        
        self.operations = []
        self._last_overflow = 'WRAP'
        self.overflow(self._default_overflow or self._last_overflow)
857862
def reset(self):
        
        _eval_script(self._client, RESET, self._name, self._signal)
        self._delete_signal()
253256
public void removeHandlers() {
    Iterator<HandlerRegistration> it = registrations.iterator();
    while (it.hasNext()) {
      HandlerRegistration r = it.next();

      /*
       * must remove before we call removeHandler. Might have come from nested
       * ResettableEventBus
       */
      it.remove();

      r.removeHandler();
    }
  }
872727
private void cancelSignals() {
        Iterator<String> keys = this.signals.keySet().iterator();
        while (keys.hasNext()) {
            cancelSignal(keys.next());
        }
    }
551942
def reset_all(self):
        
        for item in self.inputs:
            setattr(self, "_%s" % item, None)
        self.stack = []
186652
def reset(self):
        
        self.__mem.reset()
        self.__cpu.reset()
        self.__tainter.reset()

        # Instructions pre and post handlers.
        self.__instr_handler_pre = None, None
        self.__instr_handler_post = None, None

        self.__set_default_handlers()
693612
def clear(self):
        
        with self._hlock:
            self.handlers.clear()
        with self._mlock:
            self.memoize.clear()
504752
def reset_everything(self, payload):
        """"""
        kill_signal = signals['9']
        self.process_handler.kill_all(kill_signal, True)
        self.process_handler.wait_for_finish()
        self.reset = True

        answer = {'message': 'Resetting current queue', 'status': 'success'}
        return answer
584926
def reset():
    
    if hasattr(ray.worker.global_worker, "signal_counters"):
        ray.worker.global_worker.signal_counters = defaultdict(lambda: b"0")
799331
def enable_sig_handler(signal_name, handler):
    '''
    
    '''
    if hasattr(signal, signal_name):
        signal.signal(getattr(signal, signal_name), handler)
1143619
public void clearHandlers() {

        for (Map<String, CmsAttributeHandler> handlers : m_handlers) {
            for (CmsAttributeHandler handler : handlers.values()) {
                handler.clearHandlers();
            }
            handlers.clear();
        }
        m_handlers.clear();
        m_handlers.add(new HashMap<String, CmsAttributeHandler>());
        m_handlerById.clear();
    }
1002588
def remove_handler_if_not_configured(self, dict_config, requested_handlers, handler_name, check_key) -> None:
        
        try:
            if not dict_config["handlers"][handler_name][check_key]:
                dict_config["handlers"].pop(handler_name)
                if handler_name in requested_handlers:
                    requested_handlers.remove(handler_name)
        except KeyError:
            # Ignore key errors
            pass
49930
static void initDefaultHandlers() {
		if (config != null && config.getDefaultHandlers() != null) {
			defaultHandlers = getHandlersFromExecList(config.getDefaultHandlers());
			handlerListById.put("defaultHandlers", defaultHandlers);
		}
	}
1235989
def enable_signals(self):
        '''
        
        '''
        signal_dict = self.settings[self.signal_key] or {}
        for i in signal_dict.keys():
            sig_module, signal_class = self.import_class_from_path(i)
            for j in signal_dict[i]:
                recv_module, recv_coro = self.import_class_from_path(j)
                signal_class.register(recv_coro)
1104614
def _handle_signals(self):
        
        signal.signal(signal.SIGTERM, signal.SIG_DFL)
        signal.signal(signal.SIGINT, signal.SIG_IGN)