Comparing result based on expectation if arg_type is "VALUE"
        Args: Anything
        Return: Boolean
961186
def __value_compare(self, target):
        
        if self.expectation == "__ANY__":
            return True
        elif self.expectation == "__DEFINED__":
            return True if target is not None else False
        elif self.expectation == "__TYPE__":
            return True if type(target) == self.target_type else False #pylint:disable=unidiomatic-typecheck
        elif self.expectation == "__INSTANCE__":
            return True if isinstance(target, self.target_type.__class__) else False
        else:
            return True if target == self.expectation else False
374556
def verify_any(df, check, *args, **kwargs):
    
    result = check(df, *args, **kwargs)
    try:
        assert np.any(result)
    except AssertionError as e:
        msg = '{} not true for any'.format(check.__name__)
        e.args = (msg, df)
        raise
    return df
1371248
def istrue(self, *args):
        
        def is_true(val):
            if val is True:
                return True
            val = str(val).lower().strip()
            return val in ('true', 'yes', '1')
        return all(self._arg_factory(is_true, args))
637138
def contains_any(self, other):
        
        return self.value == other.value or self.value & other.value
976031
def matches(value, pattern):
    
    # types must match exactly
    if type(value) != type(pattern):
        return False

    # primitive value, such as None, True, False etc
    if not isinstance(value, ast.AST) and not isinstance(pattern, ast.AST):
        return value == pattern

    fields = [
        (field, getattr(pattern, field))
        for field in pattern._fields
        if hasattr(pattern, field)
    ]
    for field_name, field_value in fields:
        if not matches(getattr(value, field_name), field_value):
            return False
    return True
1260005
def generate_any_value?(lm, hm)
      (lm.nil? || lm.is_a?(HQMF::AnyValue)) && (hm.nil? || hm.is_a?(HQMF::AnyValue))
    end
380797
function isValidNumber(value: any): boolean {
  return typeof value === 'number' && value === value && value !== Infinity && value !== -Infinity
}
1089493
def has_any():
    ""
    return get_first(has_ctypes_iocp, has_iocp, has_stdlib_kqueue, has_kqueue, 
                        has_stdlib_epoll, has_epoll, has_poll, has_select)
1247567
def check(self, value):
        
        if self._inclusive:
            return False if self._min <= value <= self._max else True
        else:
            return False if value > self._max or value < self._min else True
120379
function or() {
    var predicates = Array.prototype.slice.call(arguments, 0);
    if (!predicates.length) {
      throw new Error('empty list of arguments to or');
    }

    return function orCheck() {
      var values = Array.prototype.slice.call(arguments, 0);
      return predicates.some(function (predicate) {
        try {
          return check.fn(predicate) ?
            predicate.apply(null, values) : Boolean(predicate);
        } catch (err) {
          // treat exceptions as false
          return false;
        }
      });
    };
  }
1343922
def check_argument_types(cllable = None, call_args = None, clss = None, caller_level = 0):
    
    return _check_caller_type(False, cllable, call_args, clss, caller_level+1)
1326503
def is_type(type_, *p):
    
    try:
        for i in p:
            if i.type_ != type_:
                return False

        return True
    except:
        pass

    return False
33709
def satisfy_exact_match(self, args, kwargs):
        

        if self.args is None and self.kwargs is None:
            return False
        elif self.args is _any and self.kwargs is _any:
            return True
        elif args == self.args and kwargs == self.kwargs:
            return True
        elif len(args) != len(self.args) or len(kwargs) != len(self.kwargs):
            return False

        if not all(x == y or y == x for x, y in zip(args, self.args)):
            return False

        for key, value in self.kwargs.items():
            if key not in kwargs:
                return False
            elif not (kwargs[key] == value or value == kwargs[key]):
                return False

        return True
266492
def __get_type(self, expectation, options):
        
        if "is_custom_func" in options.keys():
            setattr(self, "mtest", expectation)
            return "CUSTOMFUNC"
        elif "is_substring" in options.keys():
            return "SUBSTRING"
        elif "is_regex" in options.keys():
            return "REGEX"
        elif isinstance(expectation, type):
            return "TYPE"
        else:
            return "VALUE"
1088741
def check_arg_types(funcname, *args):
    """"""
    hasstr = hasbytes = False
    for arg in args:
        if isinstance(arg, str):
            hasstr = True
        elif isinstance(arg, bytes):
            hasbytes = True
        else:
            raise TypeError('{0}() argument must be str or bytes, not {1}'
                            .format(funcname, arg.__class__.__name__))
    if hasstr and hasbytes:
        raise TypeError("Can't mix strings and bytes in path components")
1021952
function(args, types) {
		this._validating = true;
		var is = this._match(args, types);
		this._validating = false;
		return is;
	}
21759
def equals(self, data):
        

        if isinstance(data, six.string_types):
            return self._add_condition('=', data, types=[int, str])
        elif isinstance(data, list):
            return self._add_condition('IN', ",".join(map(str, data)), types=[str])

        raise QueryTypeError('Expected value of type `str` or `list`, not %s' % type(data))