ó ,µ[c @sdZddlmZmZddlmZddlmZddlm Z ddlm Z ddlm Z ddl Z ddl Zdd lmZdd lmZdd lmZdd lmZdd lmZddlmZdddddddddddddg Ze jZd„Zd„Zd„Zd„Zd „Zdd!„Z ed"ƒd#„ƒZ!d$„Z"ed"ƒd%„ƒZ#ed"ƒd&„ƒZ$ed"ƒd'„ƒZ%ed"ƒd(d)d*„ƒZ&ed"ƒd(d)d+„ƒZ'd,„Z(ed-ƒed"ƒd.„ƒƒZ)dS(/sÞAlgorithms for directed acyclic graphs (DAGs). Note that most of these functions are only guaranteed to work for DAGs. In general, these functions do not check for acyclic-ness, so it is up to the user to check for that. iÿÿÿÿ(t defaultdicttdeque(tgcd(tpartial(tchain(tproduct(tstarmapN(tNIL(tarbitrary_element(tconsume(tpairwise(tgenerate_unique_node(tnot_implemented_fort descendantst ancestorsttopological_sortt lexicographical_topological_sorttall_topological_sortstis_directed_acyclic_grapht is_aperiodicttransitive_closurettransitive_reductiont antichainstdag_longest_pathtdag_longest_path_lengthtdag_to_branchingcCs[|j|ƒs%tjd|ƒ‚ntd„tj|d|ƒjƒDƒƒ}||hS(sûReturn all nodes reachable from `source` in `G`. Parameters ---------- G : NetworkX DiGraph A directed acyclic graph (DAG) source : node in `G` Returns ------- set() The descendants of `source` in `G` s The node %s is not in the graph.css|]\}}|VqdS(N((t.0tntd((s6lib/python2.7/site-packages/networkx/algorithms/dag.pys Gstsource(thas_nodetnxt NetworkXErrortsettshortest_path_lengthtitems(tGRtdes((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyR 7s+cCs[|j|ƒs%tjd|ƒ‚ntd„tj|d|ƒjƒDƒƒ}||hS(s÷Return all nodes having a path to `source` in `G`. Parameters ---------- G : NetworkX DiGraph A directed acyclic graph (DAG) source : node in `G` Returns ------- set() The ancestors of source in G s The node %s is not in the graph.css|]\}}|VqdS(N((RRR((s6lib/python2.7/site-packages/networkx/algorithms/dag.pys [sttarget(RRR R!R"R#(R$Rtanc((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyRKs+cCs4ytt|ƒƒWntjk r+tSXtSdS(s/Decides whether the directed graph has a cycle.N(R RRtNetworkXUnfeasibletTruetFalse(R$((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyt has_cycle_s cCs|jƒot|ƒ S(sÞReturn True if the graph `G` is a directed acyclic graph (DAG) or False if not. Parameters ---------- G : NetworkX graph Returns ------- bool True if `G` is a DAG, False otherwise (t is_directedR+(R$((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyRis ccs5|jƒstjdƒ‚nd„|jƒDƒ}g|jƒD]\}}|dkrA|^qA}x±|r|jƒ}||kr•tdƒ‚nxx|j|ƒD]g\}}y||cd8>> DG = nx.DiGraph([(1, 2), (2, 3)]) >>> list(reversed(list(nx.topological_sort(DG)))) [3, 2, 1] If your DiGraph naturally has the edges representing tasks/inputs and nodes representing people/processes that initiate tasks, then topological_sort is not quite what you need. You will have to change the tasks to nodes with dependence reflected by edges. The result is a kind of topological sort of the edges. This can be done with :func:`networkx.line_graph` as follows: >>> list(nx.topological_sort(nx.line_graph(DG))) [(1, 2), (2, 3)] Notes ----- This algorithm is based on a description and proof in "Introduction to Algorithms: A Creative Approach" [1]_ . See also -------- is_directed_acyclic_graph, lexicographical_topological_sort References ---------- .. [1] Manber, U. (1989). *Introduction to Algorithms - A Creative Approach.* Addison-Wesley. s2Topological sort not defined on undirected graphs.cSs+i|]!\}}|dkr||“qS(i((RtvR((s6lib/python2.7/site-packages/networkx/algorithms/dag.pys ¼s isGraph changed during iterationis8Graph contains a cycle or graph changed during iterationN( R,RR t in_degreetpopt RuntimeErrortedgestKeyErrortappendR((R$t indegree_mapR-Rt zero_indegreetnodet_tchild((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyRys(?  1      c #s|jƒstjdƒ‚nˆd kr6d„‰n‡fd†}d„|jƒDƒ}g|jƒD]$\}}|dkrh||ƒ^qh}tj|ƒxÃ|rdtj|ƒ\}}||krØtdƒ‚nx|j |ƒD]p\}} y|| cd8s isGraph changed during iterationis8Graph contains a cycle or graph changed during iterationN( R,RR tNoneR.theapqtheapifytheappopR0R1R2theappushR(( R$R:R;R4R-RR5R7R6R8((R:s6lib/python2.7/site-packages/networkx/algorithms/dag.pyRÔs02    7     t undirectedc cs©|jƒstjdƒ‚nt|jƒƒ}tg|jƒD]\}}|dkr@|^q@ƒ}g}g}x/tr¤tg|D]}||dk^q†ƒs«t‚t |ƒt |ƒkrÀt |ƒVxºt |ƒdkr¼t |ƒt |ƒkst‚|j ƒ}xC|j |ƒD]2\}} || cd7<|| dkst‚qWx4t |ƒdkr‰||ddkr‰|j ƒqVW|j |ƒ|d|dkr¸|j ƒqÑPqÑWnËt |ƒdkrätjdƒ‚n|j ƒ}xc|j |ƒD]R\}} || cd8<|| dks2t‚|| dkr|j| ƒqqW|j|ƒt |ƒt |ƒkr‹|j|ƒnt |ƒdkrvPqvqvWdS(s¹Returns a generator of _all_ topological sorts of the directed graph G. A topological sort is a nonunique permutation of the nodes such that an edge from u to v implies that u appears before v in the topological sort order. Parameters ---------- G : NetworkX DiGraph A directed graph Returns ------- generator All topological sorts of the digraph G Raises ------ NetworkXNotImplemented If `G` is not directed NetworkXUnfeasible If `G` is not acyclic Examples -------- To enumerate all topological sorts of directed graph: >>> DG = nx.DiGraph([(1, 2), (2, 3), (2, 4)]) >>> list(nx.all_topological_sorts(DG)) [[1, 2, 4, 3], [1, 2, 3, 4]] Notes ----- Implements an iterative version of the algorithm given in [1]. References ---------- .. [1] Knuth, Donald E., Szwarcfiter, Jayme L. (1974). "A Structured Program to Generate All Topological Sorting Arrangements" Information Processing Letters, Volume 2, Issue 6, 1974, Pages 153-157, ISSN 0020-0190, https://doi.org/10.1016/0020-0190(74)90001-5. Elsevier (North-Holland), Amsterdam s2Topological sort not defined on undirected graphs.iiiÿÿÿÿsGraph contains a cycle.N(R,RR tdictR.RR)talltAssertionErrortlentlistR/t out_edgest appendleftR(R3( R$tcountR-RtDtbasest current_sorttqR7tj((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyR*sH.  7 /  )    c Cs2|jƒstjdƒ‚nt|ƒ}id|6}|g}d}d}x‹|rÙg}xh|D]`}xW||D]K}||kr§t|||||dƒ}qs|j|ƒ||| 1 that divides the length of every cycle in the graph. Parameters ---------- G : NetworkX DiGraph A directed graph Returns ------- bool True if the graph is aperiodic False otherwise Raises ------ NetworkXError If `G` is not directed Notes ----- This uses the method outlined in [1]_, which runs in $O(m)$ time given $m$ edges in `G`. Note that a graph is not aperiodic if it is acyclic as every integer trivial divides length 0 cycles. References ---------- .. [1] Jarvis, J. P.; Shier, D. R. (1996), "Graph-theoretic analysis of finite Markov chains," in Shier, D. R.; Wallenius, K. T., Applied Mathematical Modeling: A Multidisciplinary Approach, CRC Press. s.is_aperiodic not defined for undirected graphsiiN( R,RR RRR3RERtsubgraphR!( R$tstlevelst this_leveltgtlt next_leveltuR-((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyR¢s*"        "  csM|jƒ}x:|D]2‰|j‡fd†tj|dˆƒDƒƒqW|S(sE Returns transitive closure of a directed graph The transitive closure of G = (V,E) is a graph G+ = (V,E+) such that for all v,w in V there is an edge (v,w) in E+ if and only if there is a non-null path from v to w in G. Parameters ---------- G : NetworkX DiGraph A directed graph Returns ------- NetworkX DiGraph The transitive closure of `G` Raises ------ NetworkXNotImplemented If `G` is not directed References ---------- .. [1] http://www.ics.uci.edu/~eppstein/PADS/PartialOrder.py c3s'|]}ˆ|krˆ|fVqdS(N((RRV(R-(s6lib/python2.7/site-packages/networkx/algorithms/dag.pys üsR(tcopytadd_edges_fromRtdfs_preorder_nodes(R$tTC((R-s6lib/python2.7/site-packages/networkx/algorithms/dag.pyRÞs  0cs%t|ƒs$d}tj|ƒ‚ntjƒ}|j|jƒƒi}t|jƒ}xÆ|D]¾‰t|ˆƒ}xˆ|ˆD]|}||krÒ||krÁd„tj ||ƒDƒ||+s iic3s|]}ˆ|fVqdS(N((RR-(RV(s6lib/python2.7/site-packages/networkx/algorithms/dag.pys 0s( RRR tDiGraphtadd_nodes_fromtnodesRBR.R!t dfs_edgesRX(R$tmsgtTRR t check_counttu_nbrsR-((RVs6lib/python2.7/site-packages/networkx/algorithms/dag.pyRs&     #!c csÓtj|ƒ}gttttj|ƒƒƒƒfg}x“|rÎ|jƒ\}}|Vxo|rÊ|jƒ}||g}g|D],}|||kp¥|||ks‚|^q‚}|j||fƒq\Wq<WdS(s€Generates antichains from a directed acyclic graph (DAG). An antichain is a subset of a partially ordered set such that any two elements in the subset are incomparable. Parameters ---------- G : NetworkX DiGraph A directed acyclic graph (DAG) Returns ------- generator object Raises ------ NetworkXNotImplemented If `G` is not directed NetworkXUnfeasible If `G` contains a cycle Notes ----- This function was originally developed by Peter Jipsen and Franco Saliola for the SAGE project. It's included in NetworkX with permission from the authors. Original SAGE code at: https://github.com/sagemath/sage/blob/master/src/sage/combinat/posets/hasse_diagram.py References ---------- .. [1] Free Lattices, by R. Freese, J. Jezek and J. B. Nation, AMS, Vol 42, 1995, p. 226. N(RRRFtreversedRR/R3( R$RZtantichains_stackst antichaintstackR9t new_antichainttt new_stack((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyR4s%*    9tweightic s*|s gSi‰x®tj|ƒD]}g|j|jƒD]0\}}ˆ|d|j||ƒ|f^q:}|r‹t|dd„ƒn d|f}|ddkr­|n d|fˆ|’scs ˆ|dS(Ni((R9(tdist(s6lib/python2.7/site-packages/networkx/algorithms/dag.pyRl•siN( RRtpredR#tgettmaxR<R3treverse( R$Rktdefault_weightR-RVtdatatustmaxutpath((Rms6lib/python2.7/site-packages/networkx/algorithms/dag.pyRis"!G'*  cCsZtj|||ƒ}d}x8t|ƒD]*\}}||||j||ƒ7}q(W|S(sõReturns the longest path length in a DAG Parameters ---------- G : NetworkX DiGraph A directed acyclic graph (DAG) weight : string, optional Edge data key to use for weight default_weight : int, optional The weight of edges that do not have a weight attribute Returns ------- int Longest path length Raises ------ NetworkXNotImplemented If `G` is not directed See also -------- dag_longest_path i(RRR Ro(R$RkRrRvt path_lengthRVR-((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyRŸs "cCsZd„|jƒDƒ}d„|jƒDƒ}ttj|ƒ}tt|t||ƒƒƒS(sqYields root-to-leaf paths in a directed acyclic graph. `G` must be a directed acyclic graph. If not, the behavior of this function is undefined. A "root" in this graph is a node of in-degree zero and a "leaf" a node of out-degree zero. When invoked, this function iterates over each path from any root to any leaf. A path is a list of nodes. css'|]\}}|dkr|VqdS(iN((RR-R((s6lib/python2.7/site-packages/networkx/algorithms/dag.pys Ïscss'|]\}}|dkr|VqdS(iN((RR-R((s6lib/python2.7/site-packages/networkx/algorithms/dag.pys Ðs(R.t out_degreeRRtall_simple_pathstchainiRR(R$trootstleavest all_paths((s6lib/python2.7/site-packages/networkx/algorithms/dag.pytroot_to_leaf_pathsÄs t multigraphcCsct|ƒr$d}tj|ƒ‚nt|ƒ}tj|ƒ\}}|j|ƒ|jtƒ|S(s( Returns a branching representing all (overlapping) paths from root nodes to leaf nodes in the given directed acyclic graph. As described in :mod:`networkx.algorithms.tree.recognition`, a *branching* is a directed forest in which each node has at most one parent. In other words, a branching is a disjoint union of *arborescences*. For this function, each node of in-degree zero in `G` becomes a root of one of the arborescences, and there will be one leaf node for each distinct path from that root to a leaf node in `G`. Each node `v` in `G` with *k* parents becomes *k* distinct nodes in the returned branching, one for each parent, and the sub-DAG rooted at `v` is duplicated for each copy. The algorithm then recurses on the children of each copy of `v`. Parameters ---------- G : NetworkX graph A directed acyclic graph. Returns ------- DiGraph The branching in which there is a bijection between root-to-leaf paths in `G` (in which multiple paths may share the same leaf) and root-to-leaf paths in the branching (in which there is a unique path from a root to a leaf). Each node has an attribute 'source' whose value is the original node to which this node corresponds. No other graph, node, or edge attributes are copied into this new graph. Raises ------ NetworkXNotImplemented If `G` is not directed, or if `G` is a multigraph. HasACycle If `G` is not acyclic. Examples -------- To examine which nodes in the returned branching were produced by which original node in the directed acyclic graph, we can collect the mapping from source node to new nodes into a dictionary. For example, consider the directed diamond graph:: >>> from collections import defaultdict >>> from operator import itemgetter >>> >>> G = nx.DiGraph(nx.utils.pairwise('abd')) >>> G.add_edges_from(nx.utils.pairwise('acd')) >>> B = nx.dag_to_branching(G) >>> >>> sources = defaultdict(set) >>> for v, source in B.nodes(data='source'): ... sources[source].add(v) >>> len(sources['a']) 1 >>> len(sources['d']) 2 To copy node attributes from the original graph to the new graph, you can use a dictionary like the one constructed in the above example:: >>> for source, nodes in sources.items(): ... for v in nodes: ... B.node[v].update(G.node[source]) Notes ----- This function is not idempotent in the sense that the node labels in the returned branching may be uniquely generated each time the function is invoked. In fact, the node labels may not be integers; in order to relabel the nodes to be more readable, you can use the :func:`networkx.convert_node_labels_to_integers` function. The current implementation of this function uses :func:`networkx.prefix_tree`, so it is subject to the limitations of that function. s3dag_to_branching is only defined for acyclic graphs(R+Rt HasACycleR~t prefix_treet remove_nodeR(R$R`tpathstBtroot((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyRÖsW    (*t__doc__t collectionsRRt fractionsRt functoolsRt itertoolsRRRR=tnetworkxRtnetworkx.generators.treesRtnetworkx.utilsRR R R R t__all__t from_iterableRzR RR+RRR<RRRRRRRRR~R(((s6lib/python2.7/site-packages/networkx/algorithms/dag.pyts\        [ Vx <#35 5 $