Python - Networkx Search Predecessor Nodes - Maximum Depth Exceeded

I'm working in a project using the library Networkx ( for graph management ) in Python, and I been having trouble trying to implement what I need I have a collection of directed g

Solution 1:

your code may contain an infinite recursion if there is a cycle between two nodes. for example:

import networkx as nx
G = nx.DiGraph()
G.add_edges_from([(1,2), (2,1)])

defactivate_nodes(g, node):               
    for pred in g.predecessors(node):
        activate_nodes(g, pred)

activate_nodes(G, 1)
RuntimeError: maximum recursion depth exceeded

if you have possible cycles on one of the graphs you better mark each node as visited or change the edges on the graph to have no cycles.

assuming you do not have cycles on your graphs here is an example of how to implement the algorithm iteratively:

import networkx as nx

G = nx.DiGraph()
G.add_nodes_from([1,2,3])
G.add_edges_from([(2, 1), (3, 1), (2, 3)])

G.node[1]['weight'] = 1
G.node[2]['weight'] = 2
G.node[3]['weight'] = 3defactivate_node(g, start_node):          
    stack = [start_node]
    ws = []

    while stack:
        node = stack.pop()
        preds = g.predecessors(node)
        stack += preds
        print('%s -> %s' % (node, preds))
        for pred in preds:
            ws.append(g.node[pred]['weight'])

    print('weights: %r' % ws)
    returnsum(ws)


print('total sum %d' % activate_node(G, 1))

this code prints:

1-> [2, 3]3-> [2]2-> []2-> []weights: [2, 3, 2]totalsum7

Note

you can reverse the direction of the directed graph using DiGraph.reverse()

if you need to use DFS or something else you can reverse the graph to get the predecessor as just the directly connected neighbours of that node. Using this, algorithms like DFS might be easier to use.