code.py

def get_node_order(self, node):
    return self.nodes.index(node)
def subgraph(self, nbunch, name=None):
    nbunch = (n.node_id for n in nbunch)
    return DmSubgraph(self._graph.subgraph(nbunch), name)
def get_root_nodes(self):
    return [n['id'] for n in self.graph.nodes()]
def get_nodes(self):
    return self._graph.nodes()
def get_digraph(self, objects):
    edges = []
    nodes = OrderedDict()
    for obj, childs in objects:
        nodes.setdefault(obj.__class__, []).append(obj)
        edges.append(get_name(obj))
        for child in childs:
            edges.append('%s  -> %s' % (get_name(obj), get_name(child)))
    return 'digraph items_in_db {\n%s\n%s;\n}' % ('\n'.join(
        '{ rank=same; %s; }' % ';'.join(map(get_name, objs)) for objs in
def sucs(self, node):
    return self.edges.get(node, [])
def nodes(self):
    return self.graph.nodes()
def get_leaf_nodes(self, wnids):
    return [wnid for wnid in wnids if not self.g.successors(wnid)]
def unshift(self, node):
    return self.nodes.unshift(node)
def get_nodes(self):
    return sorted(self.graph.nodes())
def get_parents(self, node):
    return [p for p, c in self.edges if c == node]
def get_nodes(self):
    return [a for a in self.nodes]
def get_root_nodes(self):
    return [min(self._g.nodes())]
def vertices(self):
    return [node.vertice for node in self.nodes]
def get_root_nodes(self):
    return [n['id'] for n in self.graph.nodes() if n.get('sempos') == 'v']
@classmethod
def topology_infrastructures(cls, topology):
    return cls.overlapping(topology)
@classmethod
def topology_signages(cls, topology):
    return cls.overlapping(topology)
def _get_graph_nodes(g):
    return list(filter(None, map(_get_node_label, g.body)))
def get_dependent_nodes(self, node):
    return nx.descendants(self.graph, node)
def get_children(self, node):
    return [c for p, c in self.edges if p == node]
def get_node(self, name):
    return self.nodes[name]
def get_index(self, node):
    return self.nodes.index(node)
def get_root_nodes(self):
    return [n['id'] for n in self.graph.nodes() if n['sempos'] in {'v', 'n'}]
def get_texture_subnodes(parent, submaterial=None):
    if not submaterial:
        submaterial = parent.active_node_material
    d = {}
    for link in parent.node_tree.links:
        if link.from_node and link.from_node.type == 'TEXTURE':
            if link.to_node and link.to_node.type == 'MATERIAL_EXT':
                if link.to_node.material:
                    if link.to_node.material.name == submaterial.name:
                        node = link.from_node
def get_direct_decendent_nodes(self, node):
    nodes = []
    for edge in models.Edge.objects.filter(domainnode=node):
        nodes.append(edge.rangenode)
    return nodes
@property
def subnodes(self):
    if self._subnodes is None:
        children = self._getChildren()
        self._subnodes = []
        for index, child in enumerate(children):
            if child in self._ref2node:
                node = self._ref2node[child]
                node.row = index
            else:
def get_edges(self, node_key):
    return self._graph[node_key]
@uninit_error
def get_tet_nodes(self):
    return self.tet_nodes
def get_atoms(self):
    return self.children
def _get_roots(self):
    return [n for n in self.nx_graph.nodes() if not self.nx_graph.
        predecessors(n)]
def get_nodes(self):
    return [self.node]
def get_nodes(self):
    return self.__node
def get_links(self):
    return [(a, b, w) for a in self.nodes for b, w in self.edges[a] if a in
        self.edges]
def actions(self, state):
    assert state in self.G
    if self.G.is_directed():
        return self.G.itersucc(state)
    else:
        assert self.G.is_undirected()
        return self.G.iterneighbors(state)
def get_edge_properties(self, edge):
    return self.edge_properties.setdefault(edge, {})
def nodes(self):
    return Nodes(self._node)
def get_outgoing_nodes(self):
    return [node for node, vertices in self.outgoing_vertices.items() if 
        not vertices]
def get_node(self, name):
    return self._nodes.get(name)
def nodes(self):
    return self.__elementsOfType('node')
def nodes(self):
    try:
        return self._nodes
    except AttributeError:
        pass
    self._nodes = self.graph.nodes()
    return self._nodes
def Domain(self, node):
    return self.nodes[node].copy()
def get_nodes(self):
    """
        """
    return self.__nodes
def get_nodes(self):
    return self.nodes
def get_nodes(self):
    return self.__nodes
def get_nodes(self):
    return self._nodes
def get_graph_topology(self):
    return self.graph_topology
def get_node_order(self) ->List[object]:
    return get_node_order(self._node)
def nodes(self):
    return self._nodes(None)
def nodes(self):
    return self._nodes
def nodes(self):
    return self.__nodes__