Exclude items in `self.excludes`
545469
def filterAcceptsRow(self, source_row, source_parent):
        """"""
        model = self.sourceModel()
        item = model.items[source_row]
        key = getattr(item, "filter", None)
        if key is not None:
            regex = self.filterRegExp()
            if regex.pattern():
                match = regex.indexIn(key)
                return False if match == -1 else True

        # --- Check if any family assigned to the plugin is in allowed families
        for role, values in self.includes.items():
            includes_list = [([x] if isinstance(x, (list, tuple)) else x)
                             for x in getattr(item, role, None)]
            return any(include in values for include in includes_list)

        for role, values in self.excludes.items():
            data = getattr(item, role, None)
            if data in values:
                return False

        return super(ProxyModel, self).filterAcceptsRow(
            source_row, source_parent)
1215277
def _filter_none(items):
    """"""
    type_ = list if isinstance(items, list) else tuple
    return type_(filter(_not_none, items))
499230
def normalize_excludes(excludes):
    """"""
    return [os.path.normpath(os.path.abspath(exclude)) for exclude in excludes]
1219441
def _is_excluded(self, path, dir_only):
        """"""

        return self.npatterns and self._match_excluded(path, self.npatterns)
743745
def is_excluded(self, path, exclude=None):
        
        for pattern in (exclude or self.exclude_pattern):
            if path.match(pattern):
                return True
        else:
            return False
421068
def is_excluded(root, excludes):
    
    sep = os.path.sep
    if not root.endswith(sep):
        root += sep
    for exclude in excludes:
        if root.startswith(exclude):
            return True
    return False
105811
def get_prepared_include_exclude(attributes):
        
        attrs = dict()
        for attr in ('__include__', '__exclude__'):
            attrs[attr] = tuple([item.name for item in
                                 attributes.get(attr, tuple())])
        return attrs['__include__'], attrs['__exclude__']
997769
private void excludeByFeatCount(IntIntDenseVector[][] counts) {
        for (int t=0; t<included.length; t++) {
            for (int c = 0; c < included[t].length; c++) {
                for (int k = 0; k < included[t][c].length; k++) {
                    boolean exclude = (counts[t][c].get(k) < prm.featCountCutoff);
                    if (exclude) {
                        included[t][c][k] = 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;
    }
}
58572
def _filter_attrs(attrs, ignored_attrs):
    
    return dict((k, v) for k, v in attrs.items() if k not in ignored_attrs)
572681
function excludeIncludeKeys(objA, objB, excludeKeys, includeKeys) {
  let keysA = Object.keys(objA);
  let keysB = Object.keys(objB);

  if (excludeKeys) {
    keysA = keysA.filter(key => excludeKeys.indexOf(key) === -1);
    keysB = keysB.filter(key => excludeKeys.indexOf(key) === -1);
  } else if (includeKeys) {
    keysA = keysA.filter(key => includeKeys.indexOf(key) !== -1);
    keysB = keysB.filter(key => includeKeys.indexOf(key) !== -1);
  }

  return [keysA, keysB];
}
1178104
function without(list, test, removedFn) {
 
   return withoutInner(list, removedFn || noop);
 
   function withoutInner(subList, removedFn) {
      return subList  
         ?  ( test(head(subList)) 
                  ? (removedFn(head(subList)), tail(subList)) 
                  : cons(head(subList), withoutInner(tail(subList), removedFn))
            )
         : emptyList
         ;
   }               
}
666958
def all_without(self, x):
        

        _args = []

        for arg in self.all:
            if _is_collection(x):
                for _x in x:
                    if _x not in arg:
                        _args.append(arg)
                        break
            else:
                if x not in arg:
                    _args.append(arg)

        return ArgsList(_args, no_argv=True)
304653
def without(self, *keys):
        
        items = copy(self.items)

        keys = reversed(sorted(keys))

        for key in keys:
            del items[key]

        return self.__class__(items)
37573
def recursive_exclude(self, dir, pattern):
        
        match = translate_pattern(os.path.join(dir, '**', pattern))
        return self._remove_files(match.match)
15516
def filter_exclusions file_paths
      file_paths.reject do |path|
        exclude_file_patterns.any? { |pattern| File.fnmatch("#{pattern}", path) || File.fnmatch("**/#{pattern}", path) }
      end
    end
89747
function excludeFiles(list, regex) {
        var ret = [];
        for (var i=0; i < list.length; i++) {
            if (!regex.test(list[i].dst)) {
                ret.push(list[i]);
            }
        }
        return ret;
    }