contains any of...
546353
function(a, b) {
      var keys = Object.keys(b)
        , i = 0
        , l = keys.length
        , val;

      for (; i < l; i++) {
        val = b[keys[i]];
        if (has(a, val)) return true;
      }

      return false;
    }
199497
def any(*validators):
    """"""
    def validate_any(fields):
        errors = {}
        for validator in validators:
            validation_errors = validator(fields)
            if not validation_errors:
                return
            errors.update(validation_errors)
        return errors

    validate_any.__doc__ = " or ".join(validator.__doc__ for validator in validators)
    return validate_any
92456
public static <T, R> boolean contains(Collection<T> data, R what, Function<T, R> function) {
        if (data == null) return false;
        for (T o : data) {
            if (Utils.equal(function.apply(o), what)) {
                return true;
            }
        }
        return false;
    }
668802
def any(self, func):
        
        return any([func(k, v) for k, v in self.items()])
77040
def ContainsAny(self, *values):
    
    self._awql = self._CreateMultipleValuesCondition(values, 'CONTAINS_ANY')
    return self._query_builder
413076
def contains(self, element, key=lambda x: x):
        
        return self.select(key).any(lambda x: x == key(element))
1218789
def contains(self, em):
        '''
            
        '''
        for rootNode in self.getRootNodes():
            if rootNode.contains(em):
                return True

        return False
151614
def contains_one_of(*fields):
    """"""
    message = 'Must contain any one of the following fields: {0}'.format(', '.join(fields))

    def check_contains(endpoint_fields):
        for field in fields:
            if field in endpoint_fields:
                return

        errors = {}
        for field in fields:
            errors[field] = 'one of these must have a value'
        return errors
    check_contains.__doc__ = message
    return check_contains
1364023
public static function contains($value, $anyOfThis)
    {

        $anyOfThis = (array)$anyOfThis;

        foreach ($anyOfThis as $needle) {

            if (is_scalar($value)) {
                if (mb_strpos("$value", $needle) !== false) {
                    return true;
                }
                continue;
            }

            if (is_array($value)) {
                if (in_array($needle, array_values($value))) {
                    return true;
                }
            }

            if (!$value instanceof \Traversable) {
                return false;
            }

            foreach ($value as $key=>$haystack) {
                if ($haystack == $needle) {
                    return true;
                }
            }
        }

        return false;

    }
916076
function any (data) {
    if (array(data)) {
      return testArray(data, true);
    }

    assert.object(data);

    return testObject(data, true);
  }
51761
def contains(self, column, value):
        
        df = self.df[self.df[column].str.contains(value) == True]
        if df is None:
            self.err("Can not select contained data")
            return
        self.df = df
382598
function any(target, fn) {
  var keys = Object.keys(target);
  for(var i = 0, len = keys.length; i < len; i++) {
    var key = keys[i];
    var value = target[key];
    if(fn(value, key)) return true;
  }
  return false;
}
650120
def has_any? subject, &block
      found = subjects.include? subject
      yield if found && block
      found
    end
840127
def selectcontains(table, field, value, complement=False):
    """"""

    return selectop(table, field, value, operator.contains,
                    complement=complement)
992626
def _containing_contigs(self, hits):
        ''''''
        return {hit.ref_name for hit in hits if self._contains(hit)}
812418
def contains(self, url: str):
        ''''''

        try:
            self.get_one(url)
        except NotFound:
            return False
        else:
            return True
855661
def p_feature_contains(self, t):
        """"""

        t[0] = Feature(t[1], t[2], Features(t[4]), line=t.lineno(1))