def findall(node, filter_=None, stop=None, maxlevel=None, mincount=None, maxcount=None):
return _findall(node, filter_=filter_, stop=stop,<EOL>maxlevel=maxlevel, mincount=mincount, maxcount=maxcount)<EOL>
Search nodes matching `filter_` but stop at `maxlevel` or `stop`.

Return tuple with matching nodes.

Args:
    node: top node, start searching.

Keyword Args:
    filter_: function called with every `node` as argument, `node` is returned if `True`.
    stop: stop iteration at `node` if `stop` function returns `True` for `node`.
    maxlevel (int): maximum decending in the node hierarchy.
    mincount (int): minimum number of nodes.
    maxcount (int): maximum number of nodes.

Example tree:

>>> from anytree import Node, RenderTree, AsciiStyle
>>> f = Node("f")
>>> b = Node("b", parent=f)
>>> a = Node("a", parent=b)
>>> d = Node("d", parent=b)
>>> c = Node("c", parent=d)
>>> e = Node("e", parent=d)
>>> g = Node("g", parent=f)
>>> i = Node("i", parent=g)
>>> h = Node("h", parent=i)
>>> print(RenderTree(f, style=AsciiStyle()).by_attr())
f
|-- b
|   |-- a
|   +-- d
|       |-- c
|       +-- e
+-- g
    +-- i
        +-- h

>>> findall(f, filter_=lambda node: node.name in ("a", "b"))
(Node('/f/b'), Node('/f/b/a'))
>>> findall(f, filter_=lambda node: d in node.path)
(Node('/f/b/d'), Node('/f/b/d/c'), Node('/f/b/d/e'))

The number of matches can be limited:

>>> findall(f, filter_=lambda node: d in node.path, mincount=4)  # doctest: +ELLIPSIS
Traceback (most recent call last):
  ...
anytree.search.CountError: Expecting at least 4 elements, but found 3. ... Node('/f/b/d/e'))
>>> findall(f, filter_=lambda node: d in node.path, maxcount=2)  # doctest: +ELLIPSIS
Traceback (most recent call last):
  ...
anytree.search.CountError: Expecting 2 elements at maximum, but found 3. ... Node('/f/b/d/e'))