Graphcore contains all the base graph manipulation objects.
The base Graph object implements a simple nodes and edges graph.
Add an edge to the graph. Edges are directional.
Example: g.addEdge(node_1, node_2, einfo={‘name’:’Woot Edge’})
Add a Node object to the graph. Returns the nodeid.
Return a list of the subgraph clusters (as graphs) contained within this graph. A subgraph “cluster” is defined as a group of interconnected nodes. This can be used to split out grouped subgraphs from within a larger graph.
Get the (eid, fromid, toid, einfo) tuple for the specified edge.
Example: e = g.getEdge(eid)
Get a property about an edge specified by from/to id.
Example: n = g.getEdgeInfo(eid ‘name’, ‘Default Name’)
Get the list of edges in the graph. Edges are defined as (eid, fromid, toid, einfo) tuples.
Example: for eid, fromid, toid, einfo in g.getEdges():
Retrieve a piece of information about a given node by key.
Example: descr = g.getNodeInfo(nid, ‘Description’, default=’OH HAI’)
Get the node info dictionary for the specified node.
Example: d = g.getNodeProps(nid)
Return a list of edges which originate with us.
Example: for eid, fromid, toid, einfo in g.getRefsFrom(id)
Return a list of edges which terminate at us.
Example: for eid, fromid, toid, einfo in g.getRefsFrom(id)
Check if a given node is present within the graph.
Example: if g.hasNode(‘yermom’): print ‘woot’
Search for the shortest path from one node to another with the option to filter based on edges using edgecb. edgecb should be a function:
def myedgecb(graph, eid, fromid, toid, depth)
which returns True if it’s OK to traverse this node in the search.
Additionally, toid may be None and the caller may specify tocb with a function such as:
def mytocb(graph, nid)
which must return True on finding the target node
Returns a list of edge ids...
Search from the specified node (breadth first) until you find a node where nodecb(graph, nid) == True. See pathSearchFromTo for docs on edgecb...
Set a key/value pair about a given edge by it’s from/to id.
Example: g.setEdgeInfo(eid, ‘awesomeness’, 99)
Bases: visgraph.graphcore.Graph
An extension to the graph base which implements the idea of hierarchy keeping a weight relationship based on the added edges. Edges are directional from X to y.
You must add nodes with the property “rootnode” to know where the hierarchy begins!
Calculate the node weights for the given nodes in the hierarchical graph based on the added “rootnode” nodes. This will return a dict of { nodeid: weight, } key-pairs.
# NOTE: This will also set the ‘weight’ property on the nodes
Paths are enumerated threads through a particular graph. They are implemented as an optimized hierarchical graph using python primitives to save memory and processing time...
Each “leaf” node may be tracked back for it’s entire path by tracking back to parents.
Get a list of lists which has each path flattened out.
print ‘Found A Path:’ for node in path:
doStuff()
Get all the leaf nodes for the path tree which contains the pnode.
Example: for leaf in getLeafNodes(root):
Return the list of children nodes for the specified node.
Example: for knode in getNodeKids(pnode):
Get a property from the given node, returning default in the case that the specified property is not present.
Assuming that the key is unique, walk the current path and see how many times “key” has the specified value. This will be how many instances of a loop have been encountered.
Retrieve the specified property by walking the give path backward until the property is found. Returns the specified default if the specified key is not found as a property of any node in the given path.
Return a list of the path nodes which lead from the root node to the specified path node.
Get the root node for the path tree which contains pnode.
Example: root = getRootNode(branchnode)
Assuming you have some identifier property (such as graph node id) being set on the path nodes, you may use this API to determine if the current path has a node with the specified key/value property.