🔍 Search

Search methods for Trees.

Search by	One node	One or more nodes
General method	`find`, `find_child`	`findall`, `find_children`
Node name	`find_name`, `find_child_by_name`	`find_names`
Node path	`find_path`, `find_full_path`, `find_relative_path`	`find_paths`, `find_relative_path`
Node attributes	`find_attr`	`find_attrs`

bigtree.tree.search

findall

findall(
    tree, condition, max_depth=0, min_count=0, max_count=0
)

Search tree for nodes matching condition (callable function).

Examples:

>>> from bigtree import Node, findall
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> findall(root, lambda node: node.age > 62)
(Node(/a, age=90), Node(/a/b, age=65))

Parameters:

Name	Type	Description	Default
`tree`	`BaseNode`	tree to search	required
`condition`	`Callable`	function that takes in node as argument, returns node if condition evaluates to `True`	required
`max_depth`	`int`	maximum depth to search for, based on the `depth` attribute, defaults to None	`0`
`min_count`	`int`	checks for minimum number of occurrences, raise SearchError if the number of results do not meet min_count, defaults to None	`0`
`max_count`	`int`	checks for maximum number of occurrences, raise SearchError if the number of results do not meet min_count, defaults to None	`0`

Returns:

Type	Description
`Tuple[T, ...]`	(Tuple[BaseNode, ...])

find

find(tree, condition, max_depth=0)

Search tree for single node matching condition (callable function).

Examples:

>>> from bigtree import Node, find
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find(root, lambda node: node.age == 65)
Node(/a/b, age=65)
>>> find(root, lambda node: node.age > 5)
Traceback (most recent call last):
    ...
bigtree.utils.exceptions.SearchError: Expected less than 1 element(s), found 4 elements
(Node(/a, age=90), Node(/a/b, age=65), Node(/a/c, age=60), Node(/a/c/d, age=40))

Parameters:

Name	Type	Description	Default
`tree`	`BaseNode`	tree to search	required
`condition`	`Callable`	function that takes in node as argument, returns node if condition evaluates to `True`	required
`max_depth`	`int`	maximum depth to search for, based on the `depth` attribute, defaults to None	`0`

Returns:

Type	Description
`T`	(BaseNode)

find_name

find_name(tree, name, max_depth=0)

Search tree for single node matching name attribute.

Examples:

>>> from bigtree import Node, find_name
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_name(root, "c")
Node(/a/c, age=60)

Parameters:

Name	Type	Description	Default
`tree`	`Node`	tree to search	required
`name`	`str`	value to match for name attribute	required
`max_depth`	`int`	maximum depth to search for, based on the `depth` attribute, defaults to None	`0`

Returns:

Type	Description
`NodeT`	(Node)

find_names

find_names(tree, name, max_depth=0)

Search tree for multiple node(s) matching name attribute.

Examples:

>>> from bigtree import Node, find_names
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("b", age=40, parent=c)
>>> find_names(root, "c")
(Node(/a/c, age=60),)
>>> find_names(root, "b")
(Node(/a/b, age=65), Node(/a/c/b, age=40))

Parameters:

Name	Type	Description	Default
`tree`	`Node`	tree to search	required
`name`	`str`	value to match for name attribute	required
`max_depth`	`int`	maximum depth to search for, based on the `depth` attribute, defaults to None	`0`

Returns:

Type	Description
`Iterable[NodeT]`	(Iterable[Node])

find_relative_path

find_relative_path(tree, path_name)

Search tree for single node matching relative path attribute.

Supports unix folder expression for relative path, i.e., '../../node_name'
Supports wildcards, i.e., '*/node_name'
If path name starts with leading separator symbol, it will start at root node.

Examples:

>>> from bigtree import Node, find_relative_path
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_relative_path(d, "..")
(Node(/a/c, age=60),)
>>> find_relative_path(d, "../../b")
(Node(/a/b, age=65),)
>>> find_relative_path(d, "../../*")
(Node(/a/b, age=65), Node(/a/c, age=60))

Parameters:

Name	Type	Description	Default
`tree`	`Node`	tree to search	required
`path_name`	`str`	value to match (relative path) of path_name attribute	required

Returns:

Type	Description
`Iterable[NodeT]`	(Iterable[Node])

find_full_path

find_full_path(tree, path_name)

Search tree for single node matching path attribute.

Path name can be with or without leading tree path separator symbol.
Path name must be full path, works similar to find_path but faster.

Examples:

>>> from bigtree import Node, find_full_path
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_full_path(root, "/a/c/d")
Node(/a/c/d, age=40)

Parameters:

Name	Type	Description	Default
`tree`	`Node`	tree to search	required
`path_name`	`str`	value to match (full path) of path_name attribute	required

Returns:

Type	Description
`NodeT`	(Node)

find_path

find_path(tree, path_name)

Search tree for single node matching path attribute.

Path name can be with or without leading tree path separator symbol.
Path name can be full path or partial path (trailing part of path) or node name.

Examples:

>>> from bigtree import Node, find_path
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_path(root, "c")
Node(/a/c, age=60)
>>> find_path(root, "/c")
Node(/a/c, age=60)

Parameters:

Name	Type	Description	Default
`tree`	`Node`	tree to search	required
`path_name`	`str`	value to match (full path) or trailing part (partial path) of path_name attribute	required

Returns:

Type	Description
`NodeT`	(Node)

find_paths

find_paths(tree, path_name)

Search tree for multiple nodes matching path attribute.

Path name can be with or without leading tree path separator symbol.
Path name can be partial path (trailing part of path) or node name.

Examples:

>>> from bigtree import Node, find_paths
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("c", age=40, parent=c)
>>> find_paths(root, "/a/c")
(Node(/a/c, age=60),)
>>> find_paths(root, "/c")
(Node(/a/c, age=60), Node(/a/c/c, age=40))

Parameters:

Name	Type	Description	Default
`tree`	`Node`	tree to search	required
`path_name`	`str`	value to match (full path) or trailing part (partial path) of path_name attribute	required

Returns:

Type	Description
`Tuple[NodeT, ...]`	(Tuple[Node, ...])

find_attr

find_attr(tree, attr_name, attr_value, max_depth=0)

Search tree for single node matching custom attribute.

Examples:

>>> from bigtree import Node, find_attr
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_attr(root, "age", 65)
Node(/a/b, age=65)

Parameters:

Name	Type	Description	Default
`tree`	`BaseNode`	tree to search	required
`attr_name`	`str`	attribute name to perform matching	required
`attr_value`	`Any`	value to match for attr_name attribute	required
`max_depth`	`int`	maximum depth to search for, based on the `depth` attribute, defaults to None	`0`

Returns:

Type	Description
`BaseNode`	(BaseNode)

find_attrs

find_attrs(tree, attr_name, attr_value, max_depth=0)

Search tree for node(s) matching custom attribute.

Examples:

>>> from bigtree import Node, find_attrs
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=65, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_attrs(root, "age", 65)
(Node(/a/b, age=65), Node(/a/c, age=65))

Parameters:

Name	Type	Description	Default
`tree`	`BaseNode`	tree to search	required
`attr_name`	`str`	attribute name to perform matching	required
`attr_value`	`Any`	value to match for attr_name attribute	required
`max_depth`	`int`	maximum depth to search for, based on the `depth` attribute, defaults to None	`0`

Returns:

Type	Description
`Tuple[BaseNode, ...]`	(Tuple[BaseNode, ...])

find_children

find_children(tree, condition, min_count=0, max_count=0)

Search children for nodes matching condition (callable function).

Examples:

>>> from bigtree import Node, find_children
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_children(root, lambda node: node.age > 30)
(Node(/a/b, age=65), Node(/a/c, age=60))

Parameters:

Name	Type	Description	Default
`tree`	`BaseNode / DAGNode`	tree to search for its children	required
`condition`	`Callable`	function that takes in node as argument, returns node if condition evaluates to `True`	required
`min_count`	`int`	checks for minimum number of occurrences, raise SearchError if the number of results do not meet min_count, defaults to None	`0`
`max_count`	`int`	checks for maximum number of occurrences, raise SearchError if the number of results do not meet min_count, defaults to None	`0`

Returns:

Type	Description
`Tuple[Union[T, DAGNodeT], ...]`	(BaseNode/DAGNode)

find_child

find_child(tree, condition)

Search children for single node matching condition (callable function).

Examples:

>>> from bigtree import Node, find_child
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_child(root, lambda node: node.age > 62)
Node(/a/b, age=65)

Parameters:

Name	Type	Description	Default
`tree`	`BaseNode / DAGNode`	tree to search for its child	required
`condition`	`Callable`	function that takes in node as argument, returns node if condition evaluates to `True`	required

Returns:

Type	Description
`Union[T, DAGNodeT]`	(BaseNode/DAGNode)

find_child_by_name

find_child_by_name(tree, name)

Search tree for single node matching name attribute.

Examples:

>>> from bigtree import Node, find_child_by_name
>>> root = Node("a", age=90)
>>> b = Node("b", age=65, parent=root)
>>> c = Node("c", age=60, parent=root)
>>> d = Node("d", age=40, parent=c)
>>> find_child_by_name(root, "c")
Node(/a/c, age=60)
>>> find_child_by_name(c, "d")
Node(/a/c/d, age=40)

Parameters:

Name	Type	Description	Default
`tree`	`Node / DAGNode`	tree to search, parent node	required
`name`	`str`	value to match for name attribute, child node	required

Returns:

Type	Description
`Union[NodeT, DAGNodeT]`	(Node/DAGNode)