Set REJECT in VCF line, or add it if there is something else.
162561
def _set_reject(line):
    """"""
    if line.startswith("#"):
        return line
    parts = line.split("\t")
    if parts[6] == "PASS":
        parts[6] = "REJECT"
    else:
        parts[6] += ";REJECT"
    return "\t".join(parts)
293600
def setIfMissing(self, key, value):
        """"""
        if self.get(key) is None:
            self.set(key, value)
        return self
308749
def rejected(self, value):
        
        assert (isinstance(value, bool))
        self._rejected = value
        if value:
            self._timeouted = False
            self._acknowledged = False
            self._cancelled = True
799135
def reject(self, callback):
        
        if self._use_as_callable(callback):
            return self.filter(lambda item: not callback(item))

        return self.filter(lambda item: item != callback)
533568
def log_reject( self, block_id, vtxindex, op, op_data ):
        

        debug_op = self.sanitize_op( op_data )
        if 'history' in debug_op:
            del debug_op['history']

        log.debug("REJECT %s at (%s, %s) data: %s", op_get_opcode_name( op ), block_id, vtxindex,
                ", ".join( ["%s='%s'" % (k, debug_op[k]) for k in sorted(debug_op.keys())] ))

        return
401234
def call_reject_if(attributes, options)
      return false if destroy_flag?(attributes)

      attributes = attributes.with_indifferent_access
      blank_proc = proc { |attrs| attrs.all? { |_key, value| value.blank? } }
      options[:reject_if] = blank_proc if options[:reject_if] == :all_blank
      case callback = options[:reject_if]
      when Symbol
        method(callback).arity.zero? ? send(callback) : send(callback, attributes)
      when Proc
        callback.call(attributes)
      else
        false
      end
    end
1079208
public void reject(final String errorCode, final Map<String, Object> messageVariables, final String defaultMessage) {
        reject(new String[]{errorCode}, messageVariables, defaultMessage);
    }
534824
def _fix_set_options(cls, options):
        """"""
        optional_set_options = ('ignore', 'select')
        mandatory_set_options = ('add_ignore', 'add_select')

        def _get_set(value_str):
            """Split `value_str` by the delimiter `,` and return a set.

            Removes any occurrences of '' in the set.
            Also expand error code prefixes, to avoid doing this for every
            file.

            """
            return cls._expand_error_codes(set(value_str.split(',')) - {''})

        for opt in optional_set_options:
            value = getattr(options, opt)
            if value is not None:
                setattr(options, opt, _get_set(value))

        for opt in mandatory_set_options:
            value = getattr(options, opt)
            if value is None:
                value = ''

            if not isinstance(value, Set):
                value = _get_set(value)

            setattr(options, opt, value)

        return options
378054
def reject_insert(self, s_pappid, order_id, reason, redirect_url=None):
        
        return self._post(
            'rejectinsert',
            data={
                's_pappid': s_pappid,
                'order_id': order_id,
                'reason': reason,
                'url': redirect_url,
            },
        )
1010993
def reject!(connected_at, code, reason)
      self.update_node!(connected_at,
        connected: false,
        updated: false,
        websocket_connection: {
          opened: false,
          close_code: code,
          close_reason: reason,
        },
      )
      info "Rejected connection for node #{@node.to_path} at #{connected_at} with code #{code}: #{reason}"
    rescue => exc
      error exc
    end
87994
def reject(self, *, requeue=True):
        
        self.sender.send_BasicReject(self.delivery_tag, requeue)
541296
function rejectPromise(promise, value) {
  if (promise.state !== PENDING) {return;}

  setValue(promise, value);
  setState(promise, UNFULFILLED);

  setImmediate(function() {
    setState(promise, FAILED);
    invokeFunctions(promise);
  });
}
747904
public void reject(final String[] errorCodes, final Map<String, Object> messageVariables, final String defaultMessage) {
        
        String[] codes = new String[0];
        for(String errorCode : errorCodes) {
            codes = Utils.concat(codes, messageCodeGenerator.generateCodes(errorCode, getObjectName()));
        }
        addError(new CsvError(getObjectName(), codes, messageVariables, defaultMessage));
    }
347209
protected void setError(int newPosition, String error,
      boolean currentExisting) {
    if (!currentExisting) {
      newAdvancedValueSumList[newPosition] = operations.getZero1();
      newAdvancedValueSumOfLogsList[newPosition] = operations.getZero2();
      newAdvancedValueSumOfSquaresList[newPosition] = operations.getZero1();
      newAdvancedValueMinList[newPosition] = operations.getZero1();
      newAdvancedValueMaxList[newPosition] = operations.getZero1();
      newAdvancedValueNList[newPosition] = 0;
    }
    newErrorNumber[newPosition]++;
    if (newErrorList[newPosition].containsKey(error)) {
      newErrorList[newPosition].put(error,
          newErrorList[newPosition].get(error) + 1);
    } else {
      newErrorList[newPosition].put(error, 1);
    }
  }
1372086
public void setError(String v) {
    if (GrammarError_Type.featOkTst
        && ((GrammarError_Type) jcasType).casFeat_error == null)
      jcasType.jcas.throwFeatMissing("error", "cogroo.uima.GrammarError");
    jcasType.ll_cas.ll_setStringValue(addr,
        ((GrammarError_Type) jcasType).casFeatCode_error, v);
  }
244646
def reject(lst, *values):
    """"""
    lst = List.from_maybe(lst)
    values = frozenset(List.from_maybe_starargs(values))

    ret = []
    for item in lst:
        if item not in values:
            ret.append(item)
    return List(ret, use_comma=lst.use_comma)
494950
def reject(self, reason):
        """"""
        if self._state != 'pending':
            raise RuntimeError('Promise is no longer pending.')

        self.reason = reason
        self._state = 'rejected'
        errbacks = self._errbacks
        self._errbacks = None
        for errback in errbacks:
            errback(reason)