Ignore not processing error in interactive mode
330600
def on_task_status(self, task):
        """"""
        if not self.interactive:
            super(OneScheduler, self).on_task_status(task)

        try:
            procesok = task['track']['process']['ok']
        except KeyError as e:
            logger.error("Bad status pack: %s", e)
            return None

        if procesok:
            ret = self.on_task_done(task)
        else:
            ret = self.on_task_failed(task)
        if task['track']['fetch'].get('time'):
            self._cnt['5m_time'].event((task['project'], 'fetch_time'),
                                       task['track']['fetch']['time'])
        if task['track']['process'].get('time'):
            self._cnt['5m_time'].event((task['project'], 'process_time'),
                                       task['track']['process'].get('time'))
        self.projects[task['project']].active_tasks.appendleft((time.time(), task))
        return ret
232542
function invokeCommandError(command, isInternalCommand) {

  if (isInternalCommand) {
    return;
  }

  const cwd = process.cwd();
  logger.error(`No modules found for ${command}`);

  if (cwd.indexOf('skyux-spa') === -1) {
    logger.error(`Are you in a SKY UX SPA directory?`);
  } else if (!fs.existsSync('./node_modules')) {
    logger.error(`Have you ran 'npm install'?`);
  }

  process.exit(1);
}
1289831
def handle_connection_error(func):
    """"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except device.interface.NotFoundError as e:
            log.error('Connection error (try unplugging and replugging your device): %s', e)
            return 1
    return wrapper
4201
def _on_process_error(self, error):
        
        if self is None:
            return
        if error not in PROCESS_ERROR_STRING:
            error = -1
        if not self._prevent_logs:
            _logger().warning(PROCESS_ERROR_STRING[error])
419117
async def on_error(self, event_method, *args, **kwargs):
        
        print('Ignoring exception in {}'.format(event_method), file=sys.stderr)
        traceback.print_exc()
353992
def select_ignore_interrupts(iwtd, owtd, ewtd, timeout=None):

    ''' '''

    # if select() is interrupted by a signal (errno==EINTR) then
    # we loop back and enter the select() again.
    if timeout is not None:
        end_time = time.time() + timeout
    while True:
        try:
            return select.select(iwtd, owtd, ewtd, timeout)
        except InterruptedError:
            err = sys.exc_info()[1]
            if err.args[0] == errno.EINTR:
                # if we loop back we have to subtract the
                # amount of time we already waited.
                if timeout is not None:
                    timeout = end_time - time.time()
                    if timeout < 0:
                        return([], [], [])
            else:
                # something else caused the select.error, so
                # this actually is an exception.
                raise
1315469
def on_error(self, ex):
        
        if self._d:
            self._d.errback()
            self._d = None
1285217
def ignores(self, *args):
        
        for event in args:
            self._ignored.add(event.name)
527338
def silence_errors(f):
    
    @wraps(f)
    def wrapper(*args, **kwds):
        status = np.seterr(all='ignore')
        result = f(*args, **kwds)
        np.seterr(**status)
        return result
    return wrapper
1312116
def ignore_errors(self):
        
        new_command = copy.deepcopy(self)
        new_command._ignore_errors = True
        return new_command
255311
def _event_ignored(self, event):
        """"""
        # Ignore if another action (zoom, pan) is active
        if event.canvas.widgetlock.locked():
            return True

        # Ignore non-hiding pick events for the annotation box itself
        # (otherwise, draggable annotation boxes won't work) and pick
        # events not for the artists that this data cursor manages.
        if event.artist not in self.artists:
            return True

        if not self.hover:
            # Ignore pick events from other mouse buttons
            if event.mouseevent.button != self.display_button:
                return True

        return False
242649
function noOp (error) {
    if (error == null) return
    error = pruneErrorStack(error)
    nextTick(function () {
      if (isFunction(thunks.onerror)) thunks.onerror(error)
      else throw error
    })
  }
469215
function expressResponseError_silent(response, message) {
  let errorMessage = "there was an error in the request";
  if(message)
    errorMessage = message
  response.json({ success: false, error: errorMessage });
}
789750
def accept_line(event):
    "  "
    b = event.current_buffer
    b.accept_action.validate_and_handle(event.cli, b)
70826
protected void hideError() {

        if (hasError()) {
            CmsFadeAnimation.fadeOut(m_label.getElement(), new Command() {

                /**
                 * @see com.google.gwt.user.client.Command#execute()
                 */
                public void execute() {

                    setErrorVisible(false);
                }
            }, 300);
        }
    }
940484
def _handle_exclude(self, state, sls, saltenv, errors):
        '''
        
        '''
        if 'exclude' in state:
            exc = state.pop('exclude')
            if not isinstance(exc, list):
                err = ('Exclude Declaration in SLS {0} is not formed '
                       'as a list'.format(sls))
                errors.append(err)
            state.setdefault('__exclude__', []).extend(exc)
131897
function (is_ignore_errors) {

		var file_paths = [];

		// root of dependence source directory
		file_paths.push('./commands.json');
		// root of denhub-device directory
		file_paths.push(__dirname + '/../commands.json');

		var file = null;
		for (var i = 0, l = file_paths.length; i < l; i++) {
			try {
				file = require('fs').readFileSync(file_paths[i]);
			} catch (e) {
				continue;
			}
			if (file) break;
		}

		if (!file && !is_ignore_errors) {
			console.log(colors.bold.red('Error: Could not read the commands file.'));
			console.log(file_paths.join('\n'));
			console.log(colors.bold('If you never created it, please try the following command:'));
			console.log('$ denhub-device-generator --init\n');
			process.exit(255);
		}

		var commands = {};
		if (file) {
			try {
				commands = JSON.parse(file);
			} catch (e) {
				if (!is_ignore_errors) throw e;
				commands = null;
			}
		}

		return commands;

	}