:returns: an RtreeFilter
2969
def rtree_filter(self):
        
        return RtreeFilter(self.src_filter.sitecol,
                           self.oqparam.maximum_distance,
                           self.src_filter.filename)
403360
def filter_by(self, string):
        """"""

        self._reatach()
        if string == '':
            self.filter_remove()
            return

        self._expand_all()
        self.treeview.selection_set('')

        children = self.treeview.get_children('')
        for item in children:
            _, detached = self._detach(item)
            if detached:
                self._detached.extend(detached)
        for i, p, idx in self._detached:
            # txt = self.treeview.item(i, 'text')
            self.treeview.detach(i)
        self.filter_on = True
1264059
public void setFilter (SiteTreeFilter filter) {
		this.filter = filter;
		SiteNode root = getRoot();
		setFilter(filter, root);
		// Never filter the root node
		root.setFiltered(false);
	}
1293078
@Override
  public Tree normalizeWholeTree(Tree tree, TreeFactory tf) {
    return tree.prune(emptyFilter, tf).spliceOut(aOverAFilter, tf);
  }
1032876
def tree(self):
        
        from cmdtree.tree import CmdTree
        if self._tree is None:
            self._tree = CmdTree()
        return self._tree
701940
def get_tree(self):
        """"""
        self.ignore.append(inspect.currentframe())
        return self._get_tree(self.root, self.maxdepth)
1056542
def get_tree(cls, parent=None):
        
        if parent:
            depth = parent.get_depth() + 1
            results = [parent]
        else:
            depth = 1
            results = []
        cls._get_tree_recursively(results, parent, depth)
        return results
748252
def filter_pythons(path):
    # type: (Union[str, vistir.compat.Path]) -> Iterable
    """"""
    if not isinstance(path, vistir.compat.Path):
        path = vistir.compat.Path(str(path))
    if not path.is_dir():
        return path if path_is_python(path) else None
    return filter(path_is_python, path.iterdir())
323353
def filter(self, **kwargs):
        
        self._filters.append(ReadsAlignmentsFilter(**kwargs).filter)
        return self
410813
def get_filter(self):
        
        return self.filter_form_cls(self.request.GET,
                                    runtime_context=self.get_runtime_context(),
                                    use_filter_chaining=self.use_filter_chaining)
1269921
def filter(self, q, parents=None):
        
        if self.node.leaf and self.node.filtered:
            # TODO: subject filters?
            q = q.where((self.parent.var,
                         self.predicate,
                         self.var))
            # TODO: inverted nodes
            q = self.filter_value(q, self.var)
        elif self.parent is not None:
            q = q.where((self.parent.var, self.predicate, self.var))

            if parents is not None:
                parents = [URIRef(p) for p in parents]
                q = q.filter(self.parent.var.in_(*parents))

        # TODO: forbidden nodes.
        for child in self.children:
            q = child.filter(q)
        return q
196960
def get_trees_as_list(self):
        
        mytrees = []
        if self.constituency_layer is not None:
            for tree in self.constituency_layer.get_trees():
                mytrees.append(tree)
                return mytrees
1307254
def device_filter(self):
        
        if isinstance(self._device_filter, str):
            return self._decode_query(self._device_filter)
        return self._device_filter
576213
def formatted_filters(self):
        
        if not self._formatted_filters:
            filters = deepcopy(self.filters)
            self._formatted_filters = self._format_filter(filters, self._and_props)
        return self._formatted_filters
222208
def get_tree_from_initramfs(root=None):
    
    from insights import run
    return run(MultipathConfTreeInitramfs, root=root).get(MultipathConfTreeInitramfs)
925541
def get_tree_root(self):
        
        root = self
        while root.up is not None:
            root = root.up
        return root
264243
def filter(self, callback=None):
        
        if callback:
            return self.__class__(list(filter(callback, self.items)))

        return self.__class__(list(filter(None, self.items)))