def depth(self, node=None):
"""
Get the maximum level of this tree or the level of the given node
@param node Node instance or identifier
@return int
@throw NodeIDAbsentError
"""
ret = 0
if node is None:
# Get maximum level of this tree
leaves = self.leaves()
for leave in leaves:
level = self.level(leave.identifier)
ret = level if level >= ret else ret
else:
# Get level of the given node
if not isinstance(node, Node):
nid = node
else:
nid = node.identifier
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
ret = self.level(nid)
return ret
def remove_subtree(self, nid):
"""
Return a subtree deleted from this tree. If nid is None, an
empty tree is returned.
For the original tree, this method is similar to
`remove_node(self,nid)`, because given node and its children
are removed from the original tree in both methods.
For the returned value and performance, these two methods are
different:
`remove_node` returns the number of deleted nodes;
`remove_subtree` returns a subtree of deleted nodes;
You are always suggested to use `remove_node` if your only to
delete nodes from a tree, as the other one need memory
allocation to store the new tree.
"""
st = Tree()
if nid is None:
return st
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
st.root = nid
parent = self[nid].bpointer
self[nid].bpointer = None # reset root parent for the new tree
removed = []
for id in self.expand_tree(nid):
removed.append(id)
for id in removed:
st._nodes.update({id: self._nodes.pop(id)})
# Update its parent info
self.__update_fpointer(parent, nid, Node.DELETE)
return st
def remove_node(self, identifier):
"""
Remove a node indicated by 'identifier'; all the successors are
removed as well.
Return the number of removed nodes.
"""
removed = []
if identifier is None:
return 0
if not self.contains(identifier):
raise NodeIDAbsentError("Node '%s' "
"is not in the tree" % identifier)
parent = self[identifier].bpointer
for id in self.expand_tree(identifier):
# TODO: implementing this function as a recursive function:
# check if node has children
# true -> run remove_node with child_id
# no -> delete node
removed.append(id)
cnt = len(removed)
for id in removed:
del self._nodes[id]
# Update its parent info
self.__update_fpointer(parent, identifier, Node.DELETE)
return cnt
def paste(self, nid, new_tree, deepcopy=False):
"""
Paste a @new_tree to the original one by linking the root
of new tree to given node (nid).
Update: add @deepcopy of pasted tree.
"""
assert isinstance(new_tree, Tree)
if nid is None:
raise OSError("First parameter can't be None")
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
set_joint = set(new_tree._nodes) & set(self._nodes) # joint keys
if set_joint:
# TODO: a deprecated routine is needed to avoid exception
raise ValueError('Duplicated nodes %s exists.' % list(set_joint))
if deepcopy:
for node in new_tree._nodes:
self._nodes.update({node.identifier: deepcopy(node)})
else:
self._nodes.update(new_tree._nodes)
self.__update_fpointer(nid, new_tree.root, Node.ADD)
self.__update_bpointer(new_tree.root, nid)
def __init__(self):
self.global_plate_definitions = MetaDataTree()
self.global_plate_definitions.create_node(identifier="root")
to_be_added = dict(
(i, d) for i, d, in enumerate(self.global_meta_data))
passes = 0
# Populate the global plate definitions from dict given in the database
while len(to_be_added) > 0:
passes += 1
if passes > 1000:
raise NodeIDAbsentError("Nodes absent for ids {}".format(
", ".join(
map(lambda x: x['identifier'], to_be_added.values()))))
items = list(to_be_added.items())
for i, item in items:
try:
self.global_plate_definitions.create_node(**item)
del to_be_added[i]
except NodeIDAbsentError:
pass
logging.info("Global plate definitions: ")
logging.info(self.global_plate_definitions)
def parent(self, nid):
"""Get parent node object of given id"""
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
pid = self[nid].bpointer
if pid is None or not self.contains(pid):
return None
return self[pid]
def expand_tree(self, nid=None, mode=DEPTH, filter=None, key=None,
reverse=False):
"""
Python generator. Loosly based on an algorithm from
'Essential LISP' by John R. Anderson, Albert T. Corbett, and
Brian J. Reiser, page 239-241
UPDATE: the @filter function is performed on Node object during
traversing.
UPDATE: the @key and @reverse are present to sort nodes at each
level.
"""
nid = self.root if (nid is None) else nid
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
filter = self._real_true if (filter is None) else filter
if filter(self[nid]):
yield nid
queue = [self[i] for i in self[nid].fpointer if filter(self[i])]
if mode in [self.DEPTH, self.WIDTH]:
queue.sort(key=key, reverse=reverse)
while queue:
yield queue[0].identifier
expansion = [self[i] for i in queue[0].fpointer
if filter(self[i])]
expansion.sort(key=key, reverse=reverse)
if mode is self.DEPTH:
queue = expansion + queue[1:] # depth-first
elif mode is self.WIDTH:
queue = queue[1:] + expansion # width-first
elif mode is self.ZIGZAG:
# Suggested by Ilya Kuprik ([email protected]).
stack_fw = []
queue.reverse()
stack = stack_bw = queue
direction = False
while stack:
expansion = [self[i] for i in stack[0].fpointer
if filter(self[i])]
yield stack.pop(0).identifier
if direction:
expansion.reverse()
stack_bw = expansion + stack_bw
else:
stack_fw = expansion + stack_fw
if not stack:
direction = not direction
stack = stack_fw if direction else stack_bw
def is_branch(self, nid):
"""
Return the children (ID) list of nid.
Empty list is returned if nid does not exist
"""
if nid is None:
raise OSError("First parameter can't be None")
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
try:
fpointer = self[nid].fpointer
except KeyError:
fpointer = []
return fpointer
def rsearch(self, nid, filter=None):
"""
Traverse the tree branch along the branch from nid to its
ancestors (until root).
"""
if nid is None:
return
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
filter = (self._real_true) if (filter is None) else filter
current = nid
while current is not None:
if filter(self[current]):
yield current
# subtree() hasn't update the bpointer
current = self[current].bpointer if self.root != current else None
def link_past_node(self, nid):
"""
Delete a node by linking past it.
For example, if we have a -> b -> c and delete node b, we are left
with a -> c
"""
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
if self.root == nid:
raise LinkPastRootNodeError("Cannot link past the root node, "
"delete it with remove_node()")
# Get the parent of the node we are linking past
parent = self[self[nid].bpointer]
# Set the children of the node to the parent
for child in self[nid].fpointer:
self[child].update_bpointer(parent.identifier)
# Link the children to the parent
parent.fpointer += self[nid].fpointer
# Delete the node
parent.update_fpointer(nid, mode=parent.DELETE)
del self._nodes[nid]
def subtree(self, nid):
"""
Return a shallow COPY of subtree with nid being the new root.
If nid is None, return an empty tree.
If you are looking for a deepcopy, please create a new tree
with this shallow copy,
e.g.
new_tree = Tree(t.subtree(t.root), deep=True)
This line creates a deep copy of the entire tree.
"""
st = Tree()
if nid is None:
return st
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
st.root = nid
for node_n in self.expand_tree(nid):
st._nodes.update({self[node_n].identifier: self[node_n]})
return st
def add_node(self, node, parent=None):
"""
Add a new node to tree.
The 'node' parameter refers to an instance of Class::Node
"""
if not isinstance(node, Node):
raise OSError("First parameter must be object of Class::Node.")
if node.identifier in self._nodes:
raise DuplicatedNodeIdError("Can't create node "
"with ID '%s'" % node.identifier)
if parent is None:
if self.root is not None:
raise MultipleRootError("A tree takes one root merely.")
else:
self.root = node.identifier
elif not self.contains(parent):
raise NodeIDAbsentError("Parent node '%s' "
"is not in the tree" % parent)
self._nodes.update({node.identifier: node})
self.__update_fpointer(parent, node.identifier, Node.ADD)
self.__update_bpointer(node.identifier, parent)
def _Tree__print_backend(self,
nid=None,
level=ROOT,
idhidden=True,
queue_filter=None,
key=None,
reverse=False,
line_type='ascii-ex',
data_property=None,
func=print,
iflast=None):
"""
Another implementation of printing tree using Stack
Print tree structure in hierarchy style.
For example:
Root
|___ C01
| |___ C11
| |___ C111
| |___ C112
|___ C02
|___ C03
| |___ C31
A more elegant way to achieve this function using Stack
structure, for constructing the Nodes Stack push and pop nodes
with additional level info.
UPDATE: the @key @reverse is present to sort node at each
level.
"""
line_types = \
{'ascii': ('|', '|-- ', '+-- '),
'ascii-ex': ('\u2502', '\u251c\u2500\u2500 ', '\u2514\u2500\u2500 '),
'ascii-exr': ('\u2502', '\u251c\u2500\u2500 ', '\u2570\u2500\u2500 '),
'ascii-em': ('\u2551', '\u2560\u2550\u2550 ', '\u255a\u2550\u2550 '),
'ascii-emv': ('\u2551', '\u255f\u2500\u2500 ', '\u2559\u2500\u2500 '),
'ascii-emh': ('\u2502', '\u255e\u2550\u2550 ', '\u2558\u2550\u2550 ')}
DT_VLINE, DT_LINE_BOX, DT_LINE_COR = line_types[line_type]
nid = self.root if (nid is None) else nid
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
if data_property is not None and hasattr(self[nid].data,
data_property):
display_value = getattr(self[nid].data, data_property)
elif data_property is None:
display_value = self[nid].tag
else:
raise NodePropertyAbsentError(
"Node '%s' does not have data property '%s'" %
(nid, data_property))
label = ('{0}'.format(display_value)) \
if idhidden \
else ('{0}[{1}:{2}]'.format(display_value, self[nid].identifier, str(self[nid].data)))
queue_filter = self._Tree__real_true if (
queue_filter is None) else queue_filter
if not iflast:
iflast = []
if level == self.ROOT:
func(label.encode('utf8'))
else:
leading = ''.join(
map(lambda x: DT_VLINE + ' ' * 3
if not x else ' ' * 4, iflast[0:-1]))
lasting = DT_LINE_COR if iflast[-1] else DT_LINE_BOX
func('{0}{1}{2}'.format(leading, lasting, label).encode('utf-8'))
if queue_filter(self[nid]) and self[nid].expanded:
queue = [
self[i] for i in self[nid].fpointer if queue_filter(self[i])
]
key = (lambda x: x) if (key is None) else key
queue.sort(key=key, reverse=reverse)
level += 1
for element in queue:
iflast.append(queue.index(element) == len(queue) - 1)
self._Tree__print_backend(element.identifier, level, idhidden,
queue_filter, key, reverse,
line_type, data_property, func,
iflast)
iflast.pop()
def __getitem__(self, key):
"""Return _nodes[key]"""
try:
return self._nodes[key]
except KeyError:
raise NodeIDAbsentError("Node '%s' is not in the tree" % key)
def _print_backend(self, nid=None, level=ROOT, idhidden=True, filter=None,
key=None, reverse=False, line_type='ascii-ex', func=print, iflast=[]):
"""
Another implementation of printing tree using Stack
Print tree structure in hierarchy style.
For example:
Root
|___ C01
| |___ C11
| |___ C111
| |___ C112
|___ C02
|___ C03
| |___ C31
A more elegant way to achieve this function using Stack
structure, for constructing the Nodes Stack push and pop nodes
with additional level info.
UPDATE: the @key @reverse is present to sort node at each
level.
"""
line_types = \
{'ascii': ('|', '|-- ', '+-- '),
'ascii-ex': ('\u2502', '\u251c\u2500\u2500 ', '\u2514\u2500\u2500 '),
'ascii-exr': ('\u2502', '\u251c\u2500\u2500 ', '\u2570\u2500\u2500 '),
'ascii-em': ('\u2551', '\u2560\u2550\u2550 ', '\u255a\u2550\u2550 '),
'ascii-emv': ('\u2551', '\u255f\u2500\u2500 ', '\u2559\u2500\u2500 '),
'ascii-emh': ('\u2502', '\u255e\u2550\u2550 ', '\u2558\u2550\u2550 ')}
DT_VLINE, DT_LINE_BOX, DT_LINE_COR = line_types[line_type]
leading = ''
lasting = DT_LINE_BOX
nid = self.root if (nid is None) else nid
if not self.contains(nid):
raise NodeIDAbsentError("Node '%s' is not in the tree" % nid)
label = ("{0}".format(self[nid].tag)) \
if idhidden else ("{0}[{1}]".format(self[nid].tag,
self[nid].identifier))
filter = (self._real_true) if (filter is None) else filter
if level == self.ROOT:
func(label)
else:
leading = ''.join(map(lambda x: DT_VLINE + ' ' * 3 if not x else ' ' * 4, iflast[0:-1]))
lasting = DT_LINE_COR if iflast[-1] else DT_LINE_BOX
func("{0}{1}{2}".format(leading, lasting, label))
if filter(self[nid]) and self[nid].expanded:
queue = [self[i] for i in self[nid].fpointer if filter(self[i])]
key = (lambda x: x) if (key is None) else key
queue.sort(key=key, reverse=reverse)
level += 1
for element in queue:
iflast.append(queue.index(element) == len(queue)-1)
self._print_backend(element.identifier,
level,
idhidden,
filter,
key,
reverse,
line_type,
func,
iflast)
iflast.pop()