π± BaseNode
bigtree.node.basenode
BaseNode
BaseNode extends any Python class to a tree node.
Nodes can have attributes if they are initialized from Node
, dictionary, or pandas DataFrame.
Nodes can be linked to each other with parent
and children
setter methods,
or using bitshift operator with the convention parent_node >> child_node
or child_node << parent_node
.
Examples:
>>> from bigtree import Node, print_tree
>>> root = Node("a", age=90)
>>> b = Node("b", age=65)
>>> c = Node("c", age=60)
>>> d = Node("d", age=40)
>>> root.children = [b, c]
>>> d.parent = b
>>> print_tree(root, attr_list=["age"])
a [age=90]
βββ b [age=65]
β βββ d [age=40]
βββ c [age=60]
>>> from bigtree import Node
>>> root = Node("a", age=90)
>>> b = Node("b", age=65)
>>> c = Node("c", age=60)
>>> d = Node("d", age=40)
>>> root >> b
>>> root >> c
>>> d << b
>>> print_tree(root, attr_list=["age"])
a [age=90]
βββ b [age=65]
β βββ d [age=40]
βββ c [age=60]
Directly passing parent
argument.
>>> from bigtree import Node
>>> root = Node("a")
>>> b = Node("b", parent=root)
>>> c = Node("c", parent=root)
>>> d = Node("d", parent=b)
Directly passing children
argument.
>>> from bigtree import Node
>>> d = Node("d")
>>> c = Node("c")
>>> b = Node("b", children=[d])
>>> a = Node("a", children=[b, c])
BaseNode Creation
Node can be created by instantiating a BaseNode
class or by using a dictionary.
If node is created with dictionary, all keys of dictionary will be stored as class attributes.
BaseNode Attributes
These are node attributes that have getter and/or setter methods.
Get and set other BaseNode
parent
: Get/set parent nodechildren
: Get/set child nodes
Get other BaseNode
ancestors
: Get ancestors of node excluding self, iteratordescendants
: Get descendants of node excluding self, iteratorleaves
: Get all leaf node(s) from self, iteratorsiblings
: Get siblings of selfleft_sibling
: Get sibling left of selfright_sibling
: Get sibling right of self
Get BaseNode
configuration
node_path
: Get tuple of nodes from rootis_root
: Get indicator if self is root nodeis_leaf
: Get indicator if self is leaf noderoot
: Get root node of treediameter
: Get diameter of selfdepth
: Get depth of selfmax_depth
: Get maximum depth from root to leaf node
BaseNode Methods
These are methods available to be performed on BaseNode
.
Constructor methods
from_dict()
: Create BaseNode from dictionary
BaseNode
methods
describe()
: Get node information sorted by attributes, return list of tuplesget_attr(attr_name: str)
: Get value of node attributeset_attrs(attrs: dict)
: Set node attribute name(s) and value(s)go_to(node: Self)
: Get a path from own node to another node from same treeappend(node: Self)
: Add child to nodeextend(nodes: List[Self])
: Add multiple children to nodecopy()
: Deep copy selfsort()
: Sort child nodes
parent
property
writable
Get parent node
Returns:
Type | Description |
---|---|
Optional[T]
|
(Optional[Self]) |
parents
property
writable
Do not allow parents
attribute to be accessed
Raises:
Type | Description |
---|---|
AttributeError
|
No such attribute |
children
deletable
property
writable
Get child nodes
Returns:
Type | Description |
---|---|
Tuple[T, ...]
|
(Tuple[Self, ...]) |
ancestors
property
Get iterator to yield all ancestors of self, does not include self
Returns:
Type | Description |
---|---|
Iterable[T]
|
(Iterable[Self]) |
descendants
property
Get iterator to yield all descendants of self, does not include self
Returns:
Type | Description |
---|---|
Iterable[T]
|
(Iterable[Self]) |
leaves
property
Get iterator to yield all leaf nodes from self
Returns:
Type | Description |
---|---|
Iterable[T]
|
(Iterable[Self]) |
siblings
property
Get siblings of self
Returns:
Type | Description |
---|---|
Iterable[T]
|
(Iterable[Self]) |
node_path
property
Get tuple of nodes starting from root
Returns:
Type | Description |
---|---|
Iterable[T]
|
(Iterable[Self]) |
diameter
property
Get diameter of tree or subtree, the length of longest path between any two nodes
Returns:
Type | Description |
---|---|
int
|
(int) |
max_depth
property
Get maximum depth from root to leaf node
Returns:
Type | Description |
---|---|
int
|
(int) |
from_dict
classmethod
Construct node from dictionary, all keys of dictionary will be stored as class attributes
Input dictionary must have key name
if not Node
will not have any name
Examples:
Parameters:
Name | Type | Description | Default |
---|---|---|---|
input_dict |
Dict[str, Any]
|
dictionary with node information, key: attribute name, value: attribute value |
required |
Returns:
Type | Description |
---|---|
BaseNode
|
(BaseNode) |
describe
Get node information sorted by attribute name, returns list of tuples
Examples:
>>> from bigtree.node.node import Node
>>> a = Node('a', age=90)
>>> a.describe()
[('_BaseNode__children', []), ('_BaseNode__parent', None), ('_sep', '/'), ('age', 90), ('name', 'a')]
>>> a.describe(exclude_prefix="_")
[('age', 90), ('name', 'a')]
>>> a.describe(exclude_prefix="_", exclude_attributes=["name"])
[('age', 90)]
Parameters:
Name | Type | Description | Default |
---|---|---|---|
exclude_attributes |
List[str]
|
list of attributes to exclude |
[]
|
exclude_prefix |
str
|
prefix of attributes to exclude |
''
|
Returns:
Type | Description |
---|---|
List[Tuple[str, Any]]
|
(List[Tuple[str, Any]]) |
get_attr
Get value of node attribute Returns default value if attribute name does not exist
Examples:
Parameters:
Name | Type | Description | Default |
---|---|---|---|
attr_name |
str
|
attribute name |
required |
default_value |
Any
|
default value if attribute does not exist, defaults to None |
None
|
Returns:
Type | Description |
---|---|
Any
|
(Any) |
set_attrs
go_to
Get path from current node to specified node from same tree
Examples:
>>> from bigtree import Node, print_tree
>>> a = Node(name="a")
>>> b = Node(name="b", parent=a)
>>> c = Node(name="c", parent=a)
>>> d = Node(name="d", parent=b)
>>> e = Node(name="e", parent=b)
>>> f = Node(name="f", parent=c)
>>> g = Node(name="g", parent=e)
>>> h = Node(name="h", parent=e)
>>> print_tree(a)
a
βββ b
β βββ d
β βββ e
β βββ g
β βββ h
βββ c
βββ f
>>> d.go_to(d)
[Node(/a/b/d, )]
>>> d.go_to(g)
[Node(/a/b/d, ), Node(/a/b, ), Node(/a/b/e, ), Node(/a/b/e/g, )]
>>> d.go_to(f)
[Node(/a/b/d, ), Node(/a/b, ), Node(/a, ), Node(/a/c, ), Node(/a/c/f, )]
Parameters:
Name | Type | Description | Default |
---|---|---|---|
node |
Self
|
node to travel to from current node, inclusive of start and end node |
required |
Returns:
Type | Description |
---|---|
Iterable[T]
|
(Iterable[Self]) |
append
Add other as child of self
Parameters:
Name | Type | Description | Default |
---|---|---|---|
other |
Self
|
other node, child to be added |
required |
extend
Add others as children of self
Parameters:
Name | Type | Description | Default |
---|---|---|---|
others |
Self
|
other nodes, children to be added |
required |
copy
sort
Sort children, possible keyword arguments include key=lambda node: node.name
, reverse=True
Examples: