human
Here's a good function header given the following:
I wrote the below code

    def _unblock(thisnode):
        'Recursively    unblock    and    remove    nodes    from    B[thisnode].'
        if blocked[thisnode]:
            blocked[thisnode] = False
            while B[thisnode]:
                _unblock(B[thisnode].pop())
    def circuit(thisnode, startnode, component):
        closed = False
        path.append(thisnode)
        blocked[thisnode] = True
        for nextnode in component[thisnode]:
            if (nextnode == startnode):
                result.append(path[:])
                closed = True
            elif (not blocked[nextnode]):
                if circuit(nextnode, startnode, component):
                    closed = True
        if closed:
            _unblock(thisnode)
        else:
            for nextnode in component[thisnode]:
                if (thisnode not in B[nextnode]):
                    B[nextnode].append(thisnode)
        path.pop()
        return closed
    path = []
    blocked = defaultdict(bool)
    B = defaultdict(list)
    result = []
    ordering = dict(zip(G, range(len(G))))
    for s in ordering:
        subgraph = G.subgraph((node for node in G if (ordering[node] >= ordering[s])))
        strongcomp = nx.strongly_connected_components(subgraph)
        mincomp = min(strongcomp, key=(lambda ns: min((ordering[n] for n in ns))))
        component = G.subgraph(mincomp)
        if component:
            startnode = min(component, key=ordering.__getitem__)
            for node in component:
                blocked[node] = False
                B[node][:] = []
            dummy = circuit(startnode, startnode, component)
    return result

What's a good function header?
assistant
#Here's a good function header.

@not_implemented_for('undirected')
def recursive_simple_cycles(G):