def load_from_layer_data(cls, layer_data):
new_layer = cls()
result_nodes = {}
name_attr = nxt_node.INTERNAL_ATTRS.NAME
name_key = nxt_node.INTERNAL_ATTRS.as_save_key(name_attr)
for node_path, node_data in layer_data.get('nodes', {}).items():
parent_path = nxt_path.get_parent_path(node_path)
node_name = nxt_path.node_name_from_node_path(node_path)
node_data[name_key] = node_name
spec_node = nxt_node.create_spec_node(node_data, new_layer,
parent_path)
code_lines = getattr(spec_node, nxt_node.INTERNAL_ATTRS.COMPUTE)
code = '\n'.join(code_lines)
setattr(spec_node, nxt_node.INTERNAL_ATTRS.CACHED_CODE, code)
result_nodes[node_path] = spec_node
new_layer.nodes = result_nodes
return new_layer
def _construct_node_specs(self, layer_data):
self.spec_list = []
self._nodes_path_as_key = {}
self._nodes_node_as_key = {}
nodes = order_nodes_dict(layer_data.get(SAVE_KEY.NODES, {}))
for node_path, node_data in nodes.items():
parent_path = nxt_path.get_parent_path(node_path)
root_name = nxt_path.node_name_from_node_path(node_path)
node_data['name'] = root_name
node_data[nxt_node.INTERNAL_ATTRS.SOURCE_LAYER] = self.real_path
root_spec_node = nxt_node.create_spec_node(node_data, self,
parent_path=parent_path)
root_parent_path = getattr(root_spec_node,
nxt_node.INTERNAL_ATTRS.PARENT_PATH)
root_node_path = nxt_path.join_node_paths(root_parent_path,
root_name)
self.spec_list += [root_spec_node]
self._nodes_path_as_key[root_node_path] = root_spec_node
self._nodes_node_as_key[root_spec_node] = root_node_path
self.clear_node_child_cache(root_node_path)
def children(self,
node_path=nxt_path.WORLD,
return_type=LayerReturnTypes.Node,
ordered=False,
include_implied=False):
if include_implied and return_type != LayerReturnTypes.Path:
raise ValueError('When including implied, can only return path. '
'Nothing else exists for implicit nodes.')
children_nodes = []
children_paths = []
node_table = []
name_dict = {}
if not node_path:
if return_type in (LayerReturnTypes.Node, LayerReturnTypes.Path,
LayerReturnTypes.NodeTable):
return []
elif return_type == LayerReturnTypes.NameDict:
return {}
elif return_type == LayerReturnTypes.Boolean:
return False
else:
logger.error('Invalid return type provided')
return None
child_order = []
implied_children = []
# Look up real children cache
children_cache = self._cached_children.get(node_path)
if node_path == nxt_path.WORLD:
children_cache = None
if children_cache is not None:
children_nodes = children_cache[LayerReturnTypes.Node][:]
children_paths = children_cache[LayerReturnTypes.Path][:]
node_table = children_cache[LayerReturnTypes.NodeTable][:]
name_dict = copy.copy(children_cache[LayerReturnTypes.NameDict])
cache_real = False
else:
self._cached_children[node_path] = {
LayerReturnTypes.Node: children_nodes,
LayerReturnTypes.Path: children_paths,
LayerReturnTypes.NodeTable: node_table,
LayerReturnTypes.NameDict: name_dict
}
cache_real = True
# Lookup implied cache
cache_implied = False
if include_implied:
implied_c_cache = self._cached_implied_children.get(node_path)
if node_path == nxt_path.WORLD:
implied_c_cache = None
if implied_c_cache is not None:
implied_children = implied_c_cache[LayerReturnTypes.Path][:]
if return_type == LayerReturnTypes.Boolean and not cache_real:
return bool(implied_children + children_paths)
else:
path_implied = {LayerReturnTypes.Path: implied_children}
self._cached_implied_children[node_path] = path_implied
cache_implied = True
re_cache = cache_implied or cache_real
if re_cache:
for path, node in self._nodes_path_as_key.items():
if cache_real:
parent_path = getattr(node,
nxt_node.INTERNAL_ATTRS.PARENT_PATH)
if parent_path == node_path:
children_nodes += [node]
children_paths += [path]
node_table += [[path, node]]
key = getattr(node, nxt_node.INTERNAL_ATTRS.NAME)
name_dict[key] = node
if not include_implied or not cache_implied:
continue
if nxt_path.is_ancestor(path, node_path):
trim_depth = nxt_path.get_path_depth(node_path) + 1
trimmed = nxt_path.trim_to_depth(path, trim_depth)
if trimmed not in implied_children:
implied_children += [trimmed]
if cache_real:
k = LayerReturnTypes.Path
self._cached_children[node_path][k] = children_paths[:]
if include_implied:
for imp in implied_children:
if imp not in children_paths:
children_paths += [imp]
if return_type == LayerReturnTypes.Boolean:
return bool(children_paths)
if ordered:
node = self.lookup(node_path)
if include_implied and not node:
child_order = []
else:
co_attr = nxt_node.INTERNAL_ATTRS.CHILD_ORDER
child_order = getattr(node, co_attr)
if child_order:
ordered_child_nodes = []
ordered_child_paths = []
ordered_node_table = []
for child_name in child_order:
# return type NODE
for n in children_nodes:
c_name = getattr(n, nxt_node.INTERNAL_ATTRS.NAME)
if c_name == child_name:
ordered_child_nodes += [n]
# return type PATH
for p in children_paths:
if nxt_path.node_name_from_node_path(p) == child_name:
ordered_child_paths += [p]
# return type TABLE
for item in node_table:
p, n = item
if nxt_path.node_name_from_node_path(p) == child_name:
ordered_node_table += [item]
# return type NODE
for n in children_nodes:
if n not in ordered_child_nodes:
ordered_child_nodes += [n]
children_nodes = ordered_child_nodes
# return type PATH
for p in children_paths:
if p not in ordered_child_paths:
ordered_child_paths += [p]
children_paths = ordered_child_paths
# return type TABLE
for item in node_table:
p, n = item
if p not in ordered_node_table:
ordered_node_table += [item]
node_table = ordered_node_table
if return_type == LayerReturnTypes.Node:
return children_nodes
elif return_type == LayerReturnTypes.Path:
return children_paths
elif return_type == LayerReturnTypes.NodeTable:
return node_table
elif return_type == LayerReturnTypes.NameDict:
return name_dict
elif return_type == LayerReturnTypes.Boolean:
return False
else:
logger.error('Invalid return type provided')
return None
