Assign a selection of scenarios as `exclude: True` in meta
506501
def _exclude_on_fail(self, df):
        """"""
        idx = df if isinstance(df, pd.MultiIndex) else _meta_idx(df)
        self.meta.loc[idx, 'exclude'] = True
        logger().info('{} non-valid scenario{} will be excluded'
                      .format(len(idx), '' if len(idx) == 1 else 's'))
845279
public void map(Story story, MetaFilter metaFilter) {
        if (metaFilter.allow(story.getMeta())) {
            boolean allowed = false;
            for (Scenario scenario : story.getScenarios()) {
                // scenario also inherits meta from story
                Meta inherited = scenario.getMeta().inheritFrom(story.getMeta());
                if (metaFilter.allow(inherited)) {
                    allowed = true;
                    break;
                }
            }
            if (allowed) {
                add(metaFilter.asString(), story);
            }
        }
    }
1261860
def selectnotin(table, field, value, complement=False):
    """"""

    return select(table, field, lambda v: v not in value,
                  complement=complement)
71982
def should_exclude(self, filename) -> bool:
        
        for skip_glob in self.skip_globs:
            if self.filename_matches_glob(filename, skip_glob):
                return True
        return False
1128925
public void setExcludeProps(Collection<String> excludeProps) {
        if (null == this.excludeProps) {
            this.excludeProps = new ArrayList<>();
        }
        this.excludeProps.clear();
        this.excludeProps.addAll(excludeProps);
    }
997477
def exclude(self):
        
        exclude = self.VERSIONED_EXCLUDE

        if super(VersionedAdmin, self).exclude is not None:
            # Force cast to list as super exclude could return a tuple
            exclude = list(super(VersionedAdmin, self).exclude) + exclude

        return exclude
1148929
def _check(self, args):
        """"""
        if sum(bool(args[arg]) for arg in self._mapping) > 1:
            raise DocoptExit(_('These options are mutually exclusive: {0}',
                               ', '.join(self._mapping)))
1023901
def exclude_file(self, file):
        """"""
        for pattern in self.compiled_exclude_files:
            if (pattern.match(file)):
                return(True)
        return(False)
868084
public function setExcludeSelf($s = 'true'){
        if ($s == 'true' || (is_bool($s) && $s == true)){
            $this->options['ExcludeMe'] = 'true';
        } else if ($s == 'false' || (is_bool($s) && $s == false)){
            $this->options['ExcludeMe'] = 'false';
        } else {
            return false;
        }
    }
333538
def _discover_meta_cols(self, **kwargs):
        """"""
        cols = set(['exclude'])
        for arg, value in kwargs.items():
            if isstr(value) and value in self.meta.columns:
                cols.add(value)
        return list(cols)
478083
def filter_excluded_fields(fields, Meta, exclude_dump_only):
    
    exclude = list(getattr(Meta, "exclude", []))
    if exclude_dump_only:
        exclude.extend(getattr(Meta, "dump_only", []))

    filtered_fields = OrderedDict(
        (key, value) for key, value in fields.items() if key not in exclude
    )

    return filtered_fields
816517
public void addExclude(String exclude) {

        exclude = normalizePath(exclude);
        m_excludes.add(exclude);
        m_allPaths.add(exclude);
    }
1220598
function(match, negative) {
            if (!negative) {
              negative = false;
            }
            var p = (negative) ? this.permissions.exclude : this.permissions.include;
            return (p.indexOf(match) !== -1);
          }
571564
def with(opts)
      new_options =
        if opts.key?(:meta)
          opts.merge(meta: meta.merge(opts[:meta]))
        else
          opts
        end

      new(dataset, options.merge(new_options))
    end
405898
def _build_exclusion_list(exclude):
    """"""
    mod_files = []
    if exclude:
        for mod in exclude:
            mdir = None
            mod_file = None
            for token in mod.split("."):
                try:
                    mfile, mdir, _ = imp.find_module(token, mdir and [mdir])
                    if mfile:
                        mod_file = mfile.name
                        mfile.close()
                except ImportError:
                    msg = "Source for module {mod_name} could not be found"
                    raise ValueError(msg.format(mod_name=mod))
            if mod_file:
                mod_files.append(mod_file.replace(".pyc", ".py"))
    return mod_files
688400
def selectisnot(table, field, value, complement=False):
    """"""

    return selectop(table, field, value, operator.is_not, complement=complement)
860264
def bake(self):
        
        options = self.options
        default_exclude_list = options.pop('default_exclude')
        options_exclude_list = options.pop('exclude')
        excludes = default_exclude_list + options_exclude_list
        x_list = options.pop('x')

        exclude_args = ['--exclude={}'.format(exclude) for exclude in excludes]
        x_args = tuple(('-x', x) for x in x_list)
        self._ansible_lint_command = sh.ansible_lint.bake(
            options,
            exclude_args,
            sum(x_args, ()),
            self._playbook,
            _env=self.env,
            _out=LOG.out,
            _err=LOG.error)