Filters by a verb.
776758
public function byVerb(Verb $verb): self
    {
        $this->filter['verb'] = $verb->getId()->getValue();

        return $this;
    }
856483
def filter(self, *args):
    '''

    '''
    if len(args) == 1 and isinstance(args[0], Filter):
      filter = args[0]
    else:
      filter = Filter(*args)

    # ensure filter gets attr values the same way the rest of the query does.
    filter.object_getattr = self.object_getattr
    self.filters.append(filter)
    return self
1098880
function ( args ) {
		var result = 0;

		array.each( args, function ( verb ) {
			verb = verb.toLowerCase();

			if ( regex.get_headers.test( verb ) ) {
				result |= 4;
			}
			else if ( regex.put_post.test( verb ) ) {
				result |= 2;
			}
			else if ( regex.patch.test( verb ) ) {
				result |= 8;
			}
			else if ( regex.del.test( verb ) ) {
				result |= 1;
			}
		});

		return result;
	}
674922
function _filter(file) {
            return !LanguageManager.getLanguageForPath(file.fullPath).isBinary() ||
                MainViewFactory.findSuitableFactoryForPath(file.fullPath);
        }
1290716
def filter_records(root, head, update, filters=()):
    """"""
    root, head, update = freeze(root), freeze(head), freeze(update)
    for filter_ in filters:
        root, head, update = filter_(root, head, update)

    return thaw(root), thaw(head), thaw(update)
443912
def filter(cls, iterable, cond, *a, **kw):
    

    return cls(x for x in iterable if cond(x, *a, **kw))
617687
def BROADCAST_FILTER_AND(*funcs):
        
        return lambda u, command, *args, **kwargs: all(f(u, command, *args, **kwargs) for f in funcs)
347191
def lexeme(self, verb, parse=True):
        
        a = []
        b = self.lemma(verb, parse=parse)
        if b in self:
            a = [x for x in self[b] if x != ""]
        elif parse is True: # rule-based
            a = self.find_lexeme(b)
        u = []; [u.append(x) for x in a if x not in u]
        return u
915491
def filter_that(self, criteria, data):
        '''
            
        '''
        import re
        prog = re.compile(criteria)

        return True if prog.match(data) else False
384802
def _in(self, *lst):
        """"""
        self.terms.append('in (%s)' % ', '.join(['"%s"' % x for x in lst]))
        return self
685016
def filter_embeddings(embeddings, vocab, dim):
    
    if not isinstance(embeddings, dict):
        return
    _embeddings = np.zeros([len(vocab), dim])
    for word in vocab:
        if word in embeddings:
            word_idx = vocab[word]
            _embeddings[word_idx] = embeddings[word]

    return _embeddings
652956
def filter(self, object, *args, **kw):
    '''
    
    '''
    for plugin in self.plugins:
      object = plugin.handle(object, *args, **kw)
      if object is None:
        return object
    return object
56073
def _where(self, filter_fn):
        '''  '''
        assert callable(filter_fn), 'filter_fn needs to be callable'
        return VList(i for i in self if filter_fn(i()))
329798
def filter(self, func):
        """"""
        return self.__class__(list(filter(func,self.res)),
                              name="filtered %s"%self.listname)
710699
def Filter(self, match=None, **_):
    """"""
    arg = self.stack.pop(-1)

    # Filters can be specified as a comma separated list.
    for filter_name in match.group(1).split(","):
      filter_object = ConfigFilter.classes_by_name.get(filter_name)
      if filter_object is None:
        raise FilterError("Unknown filter function %r" % filter_name)

      if not filter_object.sensitive_arg:
        logging.debug("Applying filter %s for %s.", filter_name, arg)
      arg = filter_object().Filter(arg)
      precondition.AssertType(arg, Text)

    self.stack[-1] += arg
607421
def filter(cls, start_position="", max_results="", qb=None, **kwargs):
        
        return cls.where(build_where_clause(**kwargs),
                         start_position=start_position, max_results=max_results, qb=qb)
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;
    }
}