Remove filter with the given name from a cyvcf2 record
435135
def cyvcf_remove_filter(rec, name):
    
    if rec.FILTER:
        filters = rec.FILTER.split(";")
    else:
        filters = []
    new_filters = [x for x in filters if not str(x) == name]
    if len(new_filters) == 0:
        new_filters = ["PASS"]
    rec.FILTER = new_filters
    return rec
981463
def delete_filter(filter_class)
      index = @filters.index { |f| f.class.name == filter_class.name }
      @filters.delete_at(index) if index
    end
1359215
def exclude_by_filter(self, filename, module_name):
        '''
        
        '''
        for exclude_filter in self._exclude_filters:  # : :type exclude_filter: ExcludeFilter
            if exclude_filter.is_path:
                if glob_matches_path(filename, exclude_filter.name):
                    if exclude_filter.exclude:
                        pydev_log.debug("File %s ignored by filter %s" % (filename, exclude_filter.name))
                    return exclude_filter.exclude
            else:
                # Module filter.
                if exclude_filter.name == module_name or module_name.startswith(exclude_filter.name + '.'):
                    return exclude_filter.exclude
        return None
344479
boolean removeFilteredPolicy(String sec, String ptype, int fieldIndex, String... fieldValues) {
        boolean ruleRemoved = model.removeFilteredPolicy(sec, ptype, fieldIndex, fieldValues);
        if (!ruleRemoved) {
            return false;
        }

        if (adapter != null && autoSave) {
            try {
                adapter.removeFilteredPolicy(sec, ptype, fieldIndex, fieldValues);
            } catch (Error e) {
                if (!e.getMessage().equals("not implemented")) {
                    throw e;
                }
            }

            if (watcher != null) {
                // error intentionally ignored
                watcher.update();
            }
        }

        return true;
    }
827209
def _already_cutoff_filtered(in_file, filter_type):
    
    filter_file = "%s-filter%s.vcf.gz" % (utils.splitext_plus(in_file)[0], filter_type)
    return utils.file_exists(filter_file)
783633
function filter(name, options) {
  return utils.through.obj(function(file, enc, next) {
    if (file.isNull()) {
      next();
      return;
    }

    var basename = path.basename(file.history[0]);
    var stem = basename.slice(0, -3);

    if (basename === name || stem === name) {
      next(null, file);
    } else {
      next();
    }
  });
}
374646
def remove_values(self, names):
        """"""
        for name in names:
            self.shellwidget.remove_value(name)
        self.shellwidget.refresh_namespacebrowser()
897966
def remove_filter(self, filter_attr):
        
        filter_attr = self._get_mapping(filter_attr)
        new_filters = []
        remove_chain = False

        for flt in self._filters:
            if isinstance(flt, tuple):
                if flt[0] == filter_attr:
                    remove_chain = True
                else:
                    new_filters.append(flt)
            else:
                # this is a ChainOperator
                if remove_chain is False:
                    new_filters.append(flt)
                else:
                    remove_chain = False

        self._filters = new_filters
382172
def drop_it(title, filters, blacklist):
    
    title = title.lower()
    matched = False
    for f in filters:
        if re.match(f, title):
            matched = True
    if not matched:
        return True
    for b in blacklist:
        if re.match(b, title):
            return True
    return False
670444
def _remove_column(self, name):
        
        self._columns = filter(lambda c: c.name != name, self._columns)

        return self
663119
def __remove_pyc_pyo(fname):
    """"""
    if osp.splitext(fname)[1] == '.py':
        for ending in ('c', 'o'):
            if osp.exists(fname+ending):
                os.remove(fname+ending)
900410
def polygon_filter_rm(self, filt):
        
        if not isinstance(filt, (PolygonFilter, int, float)):
            msg = "`filt` must be a number or instance of PolygonFilter!"
            raise ValueError(msg)

        if isinstance(filt, PolygonFilter):
            uid = filt.unique_id
        else:
            uid = int(filt)
        # remove item
        self.config["filtering"]["polygon filters"].remove(uid)
714092
def remove_parameter(self, name):
		
		if name in self.__query:
			self.__query.pop(name)
207036
def unregisterFilter(self, column):
        
        if self._filters.has_key(column):
            del self._filters[column]
216241
def copy_filter(filter)
      buffer = {exclude: {}, include: {}}

      filter[:exclude].each do |part|
        buffer[:exclude][part[0]] = part[1].dup
      end

      filter[:include].each do |part|
        buffer[:include][part[0]] = part[1].dup
      end

      return buffer
    end
800091
def remove_filter_set(self, filter_name):
        
        if filter_name in self._filter_sets:
            del self._filter_sets[filter_name]
        else:
            raise ValueError('Unknown filter set name.')
1000532
def dfilter(fn, record):
    
    return dict([(k, v) for k, v in record.items() if fn(v)])