.. deprecated:: 2.0
       Use :any:`BSP.contains` instead.
166944
def bsp_contains(node: tcod.bsp.BSP, cx: int, cy: int) -> bool:
    
    return node.contains(cx, cy)
371203
def _bsd_stp(br, state, iface):
    '''
    
    '''
    kernel = __grains__['kernel']
    if kernel == 'NetBSD':
        cmd = _tool_path('brconfig')
    else:
        cmd = _tool_path('ifconfig')

    if not br or not iface:
        return False

    return __salt__['cmd.run']('{0} {1} {2} {3}'.format(cmd, br, state, iface),
                               python_shell=False)
292407
def _contains_egg_info(
        s, _egg_info_re=re.compile(r'([a-z0-9_.]+)-([a-z0-9_.!+-]+)', re.I)):
    
    return bool(_egg_info_re.search(s))
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
1203636
def _filter_contains(self, term, field_name, field_type, is_not):
        
        if field_type == 'text':
            term_list = term.split()
        else:
            term_list = [term]

        query = self._or_query(term_list, field_name, field_type)
        if is_not:
            return xapian.Query(xapian.Query.OP_AND_NOT, self._all_query(), query)
        else:
            return query
131462
def any(pred: Callable, xs: Iterable):
    
    b = find_first(pred, xs)

    return True if b is not None else False
996482
function (set, excepts, onlys) {
    debug("~ #filterOut");
    var hasExcepts = excepts && excepts.length > 0;
    if (onlys) {
        if (hasExcepts) {
            return onlys.filter(function (oel){
                return !excepts.some(function (eel) { return eel === oel;});
            });
        } else {
            return onlys;
        }
    }
    if (hasExcepts) {
        return set.filter(function (oel){
            return !excepts.some(function (eel) { return eel === oel;});
        });
    } else {
        return set;
    }
}
810593
function containsAnyOf(str, substrList) {
  for(var i in substrList) if (contains(str, substrList[i])) return true;
  return false;
}
1244774
def must_contain(self, value, q, strict=False):
        """"""
        if value is not None:
            if value.find(q) != -1:
                return
        self.shout('Value %r does not contain %r', strict, value, q)
626547
def contains(self, string):
        
        # Check that self.weld_type is a string type
        vectype = self.weld_type
        if isinstance(vectype, WeldVec):
            elem_type = vectype.elemType
            if isinstance(elem_type, WeldChar):
                return SeriesWeld(
                    grizzly_impl.contains(
                        self.expr,
                        elem_type,
                        string
                    ),
                    WeldBit(),
                    self.df,
                    self.column_name
                )
        raise Exception("Cannot call to_lower on non string type")
682203
def contains_list(longer, shorter):
    """"""
    if len(longer) <= len(shorter):
        return False
    for a, b in zip(shorter, longer):
        if a != b:
            return False
    return True
1284248
@Override
  public boolean contains(IVersion version)
  {
    for (IVersionRange range : ranges) {
      if (range.contains(version)) {
        return true;
      }
    }
    return false;
  }
901106
@Override
  public boolean contains(IVersion version)
  {

    // Can the versions be compared?
    if (!(version instanceof SemanticVersion)) {
      return false;
    }

    // We always want the extended version on the left, since it has the
    // more complex code.
    if (this.version instanceof ExtendedSemanticVersion) {
      switch (operator) {
        case ">":
          return this.version.lessThan(version);
        case ">=":
          return this.version.lessThanOrEqualTo(version);
        case "<":
          return this.version.greaterThan(version);
        case "<=":
          return this.version.greaterThanOrEqualTo(version);
        default:
          throw new IllegalArgumentException("Invalid operator: " + operator);
      }
    }
    else {
      switch (operator) {
        case "<":
          return ((SemanticVersion) version).lessThan(this.version);
        case "<=":
          return ((SemanticVersion) version).lessThanOrEqualTo(this.version);
        case ">":
          return ((SemanticVersion) version).greaterThan(this.version);
        case ">=":
          return ((SemanticVersion) version).greaterThanOrEqualTo(this.version);
        default:
          throw new IllegalArgumentException("Invalid operator: " + operator);
      }
    }
  }
855661
def p_feature_contains(self, t):
        """"""

        t[0] = Feature(t[1], t[2], Features(t[4]), line=t.lineno(1))
367554
def _get_all_containing(self, containing_contigs, name, exclude=None, max_depth=10):
        ''''''
        contains_name = set()
		
        # failsafe to prevent infinite recursion
        if max_depth < 0:
            return contains_name
		
        if name in containing_contigs:
            for containing_contig in containing_contigs[name]:
                # if we have a contains b and b contains a, then this stops infinite recursion
                if containing_contig==exclude:
                    continue
                contains_name.add(containing_contig)
                new_names = self._get_all_containing(containing_contigs, containing_contig, exclude=name,max_depth=max_depth-1)
                new_names.discard(name)
                contains_name.update(new_names)
        return contains_name
1120750
def any_contains_any(strings, candidates):
    """"""
    for string in strings:
        for c in candidates:
            if c in string:
                return True
275718
def ismatch(self, s):
        
        if self._ismatchfun(s) and self._compiled_pattern.match(s):
            return True
        return False