D^(h#PdZddlZddlmZmZddlmZddlmZddl Z ddl m Z ddl mZmZgd Zd d hZd d d dZedZe dd.dZdZdZe j0ddid/dZe de j0ddidd0dZe j0dd d1dZe j0ddd d1d Ze j0dddddddd!d"Ze j0ddd d1d#Ze j0ddd d1d$Zd%Z e d&zZ!e jEd'd (e_e jEd)d (d*ze_e!jEd'd+(e_e!jEd)d+(e_Gd,d-Z#y)2u Algorithms for finding optimum branchings and spanning arborescences. This implementation is based on: J. Edmonds, Optimum branchings, J. Res. Natl. Bur. Standards 71B (1967), 233–240. URL: http://archive.org/details/jresv71Bn4p233 N) dataclassfield) itemgetter) PriorityQueue)py_random_state)is_arborescence is_branching)branching_weightgreedy_branchingmaximum_branchingminimum_branchingminimal_branchingmaximum_spanning_arborescenceminimum_spanning_arborescenceArborescenceIteratormaxmin branching arborescence)rrspanning arborescenceinfcdjt|Dcgc]!}|jtj#c}Scc}w)N)joinrangechoicestring ascii_letters)Lseedns a/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/networkx/algorithms/tree/branchings.py random_stringr$>s2 77uQxH!DKK 4 45H IIHs&Ac| SNweights r# _min_weightr*Cs 7Nc|Sr&r'r(s r# _max_weightr-Gs Mr+attrdefault) edge_attrsr)cPtfd|jdDS)a Returns the total weight of a branching. You must access this function through the networkx.algorithms.tree module. Parameters ---------- G : DiGraph The directed graph. attr : str The attribute to use as weights. If None, then each edge will be treated equally with a weight of 1. default : float When `attr` is not None, then if an edge does not have that attribute, `default` specifies what value it should take. Returns ------- weight: int or float The total weight of the branching. Examples -------- >>> G = nx.DiGraph() >>> G.add_weighted_edges_from([(0, 1, 2), (1, 2, 4), (2, 3, 3), (3, 4, 2)]) >>> nx.tree.branching_weight(G) 11 c3HK|]}|djyw)N)get).0edger.r/s r# z#branching_weight..js IdtAw{{4)Is"Tdata)sumedges)Gr.r/s ``r#r r Ks!> Iagg4g6HI IIr+T)r0 returns_graphc |tvrtjd|dk(rd}nd}| t|}|j dDcgc]\}}}|||j ||f} }}} | j tddd | tj} | j|tjj} t| D]Y\} \}}} | || |k(r| j|d k(r+i}|| ||<| j||fi|| j!||[| Scc}}}w#t$r| j td| YwxYw) a7 Returns a branching obtained through a greedy algorithm. This algorithm is wrong, and cannot give a proper optimal branching. However, we include it for pedagogical reasons, as it can be helpful to see what its outputs are. The output is a branching, and possibly, a spanning arborescence. However, it is not guaranteed to be optimal in either case. Parameters ---------- G : DiGraph The directed graph to scan. attr : str The attribute to use as weights. If None, then each edge will be treated equally with a weight of 1. default : float When `attr` is not None, then if an edge does not have that attribute, `default` specifies what value it should take. kind : str The type of optimum to search for: 'min' or 'max' greedy branching. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- B : directed graph The greedily obtained branching. zUnknown value for `kind`.rFT)r!r8r3rr)keyreverse)KINDSnxNetworkXExceptionr$r;r4sortr TypeErrorDiGraphadd_nodes_fromutils UnionFind enumerate in_degreeadd_edgeunion)r<r.r/kindr!rAuvr9r;Bufiws r#r r mstF 5""#>?? u} |$'ABdAS T T!QaDHHT7+ , TE T7 z!Q*G < AQ    B!%(  9Aq! a5BqE>  [[^q DT AJJq! $t $ HHQN  H? U 7  z!}g 67s D;1E%E*)E*)preserve_edge_attrsr>Fcj !"#$%&'()*d$d%d"d(}tjd_i t|j dD]t\}\}}} | j |i} | j | j | <|r#| j D]\} } | k7s | | | <$ |||fi| vd} tjig&g!t)tjj*g#g'fd} !"#$%&'()*fd }d }ttj} t|}|)vr)j'|j)|||\}}||dkDr|d}*|*|k(}|i}|d j |d j |<$|||d fi|d|||d "<*j+|||r1|||| ttj}| d z } #t$rttk(sJtr t!sJ&j#j% j%f!j#j%j%f#j#g'j#dYnwxYw|j-}t!| d }| dkDr| d z} (t/| z}#| }|&| d zd||\}}|j1||r'| }|t2|j5|nC&| \ |d }|D]} |\}}} ||k(sn t3d|j5|| dkDr|j7||D]R}&dd |\}}} | i}|r$| j D]\}}|"fvs |||<|j8||fi|T|S)Nc||vr"||\}}}||k7s||k7rtd|d|j|||fi||||j|||f||<y)aS Adds an edge to `G` while also updating the edge index. This algorithm requires the use of an external dictionary to track the edge keys since it is possible that the source or destination node of an edge will be changed and the default key-handling capabilities of the MultiDiGraph class do not account for this. Parameters ---------- G : MultiDiGraph The graph to insert an edge into. edge_index : dict A mapping from integers to the edges of the graph. u : node The source node of the new edge. v : node The destination node of the new edge. key : int The key to use from `edge_index`. d : keyword arguments, optional Other attributes to store on the new edge. zKey z is already in use.N) ExceptionrMsucc) r< edge_indexrPrQr@duuvv_s r#edmonds_add_edgez+maximum_branching..edmonds_add_edgesu2 * "3IBARQ"W$sg-@ ABB 1a""a1c!23 3r+ct}|j|jD]}|j||j|jD]}|j||D]}||=|j |y)aR Remove a node from the graph, updating the edge index to match. Parameters ---------- G : MultiDiGraph The graph to remove an edge from. edge_index : dict A mapping from integers to the edges of the graph. n : node The node to remove from `G`. N)setpredvaluesupdaterZ remove_node)r<r[r"keyskeydictr@s r#edmonds_remove_nodez.maximum_branching..edmonds_remove_nodesuvvay'') !G KK  !vvay'') !G KK  ! C3  ar+z#edmonds' secret candidate attributezedmonds new node base name Tr8rcPd}t }j|ddD]\}}}}|j tjj k(r5| }|j tjj k(r|}|||||f}||fS||kDsz|}|||||f}||fS)a Find the edge directed towards v with maximal weight. If an edge partition exists in this graph, return the included edge if it exists and never return any excluded edge. Note: There can only be one included edge for each vertex otherwise the edge partition is empty. Parameters ---------- v : node The node to search for the maximal weight incoming edge. NTr9rg)INFin_edgesr4rC EdgePartitionEXCLUDEDINCLUDED) rQr6 max_weightrPr_r@r9 new_weightr<r. partitions r#edmonds_find_desired_edgez4maximum_branching..edmonds_find_desired_edgeOsT  zz!$TzB 5OAq#txx "b&6&6&?&??dJxx "b&6&6&?&??' 1c:t4Z J&' 1c:t4! 5$Zr+c |d}tj||}t|ddDcgc]*\}}t|||j d,}}}|j |dt }d} i} |D]L} | \}}} | } | | |<| j tjjk(rC| |ksI| }| } Nj |j | j jjfj jjft|z}j|g}jddD]u\}}}} || vr+|| vr| j}|j ||||f7|| vr;| } | || |z z } | j}| |<|j ||||fvw|D]}||!jt||D];\}}}} |||fi| | vs| =|||fi| "j!||=ycc}}w)a Perform step I2 from Edmonds' paper First, check if the last step I1 created a cycle. If it did not, do nothing. If it did, store the cycle for later reference and contract it. Parameters ---------- v : node The current node to consider desired_edge : edge The minimum desired edge to remove from the cycle. level : int The current level, i.e. the number of cycles that have already been removed. rrNr3Trk)rC shortest_pathrKlistrgappendrlr4rnrpcopystradd_noder;difference_updaterbrN)#rQ desired_edgelevelrPQ_nodesrTr^Q_edges minweightminedgeQ_incoming_weightedge_keyr9rUnew_node new_edgesr@ddnoderR B_edge_indexr< G_edge_indexr. branchingscandidate_attrcircuitsr`rigraphsminedge_circuitnew_node_base_namersselected_nodesrSs# r#edmonds_step_I2z*maximum_branching..edmonds_step_I2ts O""1a+;DWQR[;Q 27!RD71:r"'') *1 -   |A'  #H%h/JAq$T A$% a xx "b&6&6&?&??9} " #  w' qvvx!2!2!4561668\%6%6%89:&E 2 8  wwDtw< OAq#t%%))B$$h3%;<))T A%6q%999AB BtH$$a3%;<- 0 7D < 6 < 6 7 ((W6( OAq#t Q aC @4 @%( L!QDtDA  { s/I2c||vrt|d|j|D]%}|j||D]}||vsd|fccS'y)a Returns True if `u` is a root node in G. Node `u` is a root node if its in-degree over the specified edges is zero. Parameters ---------- G : Graph The current graph. u : node The node in `G` to check if it is a root. edgekeys : iterable of edges The edges for which to check if `u` is a root of. z not in GF)TN)rYrc)r<rPedgekeysrQedgekeys r#is_rootz"maximum_branching..is_rootsf A:qe9-. . A66!9Q< *h& '>) *  r+r=r3rz+Couldn't find edge incoming to merged node.)rC MultiDiGraph__networkx_cache__rKr;r4itemsrbrIrJiterrwnodesnext StopIterationlenr rxryaddr{rN __class__rzrerYremoverHrM)+r<r.r/preserve_attrsrs G_originalr@rPrQr9r\d_kd_vr~rtrrrr}desired_edge_weightcircuitrHr; merged_nodeisrootrrtargetvaluerRrrrrrr`rirrrrrSs+`` ` @@@@@@@@@@@@@r#r r s4B:;N6J AAL&z'7'7T'7'BC :\aD 488D'* + 88I  *88I.AiL  JJL !S$; AcF ! L!Q9q9 : E AL FJUN    BHO(# JUUUn2 agg E  U A*N"1 1 ,Ea,H) )  #(;a(?QAer!unG+,BA""9-9 ,Q 3 3I >9 Q aLO Jr J7;AaDGLO $^ 4 HHQN<7T!'')_- q  q6SV# ##1v#A& MM1668\%6%6%89 :   qvvx):):)<= > OOB   " "4 (  @ A  5!!$ %E !)  )3u:5 5/!&"3A"6 UK W %e,G LL !%UmOA|!'*1-F" O)'2 1d; O  MNN LL !Q !)TZ  )A,w'1aAdG_ ggi $ Ut^44#BsG $  1a2  Hs H<c|jdD]\}}}|j|| ||<tj|t |||||}|jdD]\}}}|j|| ||<tj||jdD]\}}}|j|| ||<tj||S)NTr8)r;r4rC _clear_cacher )r<r.r/rrsr_r\rRs r#rris777%(1a55w''$(OOA!T7NIFA777%(1a55w''$(OOA777%(1a55w''$(OOA Hr+r.r/rrsczt }t}|j||D]\}}}||kDr|}||ks|}|jdD]'\}}} |dz||z z| j||z | |<)tj|t |||||} |jdD]'\}}} |dz||z z| j||z | |<)tj|| jdD]'\}}} |dz||z z| j||z | |<)tj| | S)a Returns a minimal branching from `G`. A minimal branching is a branching similar to a minimal arborescence but without the requirement that the result is actually a spanning arborescence. This allows minimal branchinges to be computed over graphs which may not have arborescence (such as multiple components). Parameters ---------- G : (multi)digraph-like The graph to be searched. attr : str The edge attribute used in determining optimality. default : float The value of the edge attribute used if an edge does not have the attribute `attr`. preserve_attrs : bool If True, preserve the other attributes of the original graph (that are not passed to `attr`) partition : str The key for the edge attribute containing the partition data on the graph. Edges can be included, excluded or open using the `EdgePartition` enum. Returns ------- B : (multi)digraph-like A minimal branching. r9r/Tr8r)rlr;r4rCrr ) r<r.r/rrsrq min_weightr_rUr\rRs r#rr~siDJJ77g761a z>J z>J  777%T1a q.J$;J z>J  777%T1a%%g&3a7: ;RS$TOOA!T7NIFA777%T1a%%g&3a7: ;RS$TOOA777%T1a%%g&3a7: ;RS$TOOA 1 ll,,-UVV Hr+czt|||||}t|stjj d|S)Nrz&No minimum spanning arborescence in G.)rr rCrrD)r<r.r/rrsrRs r#rrsB  %  A 1 ll,,-UVV Hr+a Returns a {kind} {style} from G. Parameters ---------- G : (multi)digraph-like The graph to be searched. attr : str The edge attribute used to in determining optimality. default : float The value of the edge attribute used if an edge does not have the attribute `attr`. preserve_attrs : bool If True, preserve the other attributes of the original graph (that are not passed to `attr`) partition : str The key for the edge attribute containing the partition data on the graph. Edges can be included, excluded or open using the `EdgePartition` enum. Returns ------- B : (multi)digraph-like A {kind} {style}. zV Raises ------ NetworkXException If the graph does not contain a {kind} {style}. maximum)rOstyleminimumz) See Also -------- minimal_branching rcbeZdZdZedGddZd dZdZd Zd Z d Z d Z y)ru Iterate over all spanning arborescences of a graph in either increasing or decreasing cost. Notes ----- This iterator uses the partition scheme from [1]_ (included edges, excluded edges and open edges). It generates minimum spanning arborescences using a modified Edmonds' Algorithm which respects the partition of edges. For arborescences with the same weight, ties are broken arbitrarily. References ---------- .. [1] G.K. Janssens, K. Sörensen, An algorithm to generate all spanning trees in order of increasing cost, Pesquisa Operacional, 2005-08, Vol. 25 (2), p. 219-229, https://www.scielo.br/j/pope/a/XHswBwRwJyrfL88dmMwYNWp/?lang=en T)orderc>eZdZUdZeed<edZeed<dZ y)ArborescenceIterator.Partitionz This dataclass represents a partition and stores a dict with the edge data and the weight of the minimum spanning arborescence of the partition dict. mst_weightF)comparepartition_dictcrtj|j|jj Sr&)r Partitionrrry)selfs r#__copy__z'ArborescenceIterator.Partition.__copy__Us-'11!4!4!9!9!; r+N) __name__ __module__ __qualname____doc__float__annotations__rrdictrr'r+r#rrJs# $U33 r+rNch|j|_||_||_|rtnt |_d|_|li}|dD]}tjj||<!|dD]}tjj||<!tjd||_yd|_y)a Initialize the iterator Parameters ---------- G : nx.DiGraph The directed graph which we need to iterate trees over weight : String, default = "weight" The edge attribute used to store the weight of the edge minimum : bool, default = True Return the trees in increasing order while true and decreasing order while false. init_partition : tuple, default = None In the case that certain edges have to be included or excluded from the arborescences, `init_partition` should be in the form `(included_edges, excluded_edges)` where each edges is a `(u, v)`-tuple inside an iterable such as a list or set. z;ArborescenceIterators super secret partition attribute nameNrr)ryr<r)rrrmethod partition_keyrCrnrprorrinit_partition)rr<r)rrres r#__init__zArborescenceIterator.__init__Zs.  -4 ):W J   %N#A& >$&$4$4$=$=q! >#A& >$&$4$4$=$=q! >"6"@"@N"SD "&D r+ct|_|j|j|j|j |j|j |j|j|jdj|j}|jj|j|jr|n| |jin|jj|S)zu Returns ------- ArborescenceIterator The iterator object for this graph Trsrr()rpartition_queue_clear_partitionr<r_write_partitionrr)rsizeputrrr)rrs r#__iter__zArborescenceIterator.__iter__s - dff%    *  ! !$"5"5 6[[ FF KK(( ! $dkk$ "    NN"ll  **2,,;;    r+cP|jjr |`|`t|jj }|j ||j |j|j|jd}|j|||j||S)z Returns ------- (multi)Graph The spanning tree of next greatest weight, which ties broken arbitrarily. Tr) remptyr<rr4rrr)r _partitionr)rrsnext_arborescences r#__next__zArborescenceIterator.__next__s    % % ', ((,,.  i( KK FF KK(( (   #45 /0  r+c<|jd|jj}|jd|jj}|jD]}||jvstj j |j|<tj j|j|<|j| |j|j|j|jd}|j|j}|jr|n| |_|j j#|j%|jj|_"y#tj&$rY8wxYw)a Create new partitions based of the minimum spanning tree of the current minimum partition. Parameters ---------- partition : Partition The Partition instance used to generate the current minimum spanning tree. partition_arborescence : nx.Graph The minimum spanning arborescence of the input partition. rTrr(N)rrryr;rCrnrorprrr<r)rrrrrrrrD)rrspartition_arborescencep1p2rp1_mst p1_mst_weights r#rzArborescenceIterator._partitionsQ^^Ay77<<> ? ^^Ay77<<> ?'-- =A 000')'7'7'@'@!!!$')'7'7'@'@!!!$%%b) ![[ "&"4"4'+ )F%+KKt{{K$CM59\\M ~BM((,,R[[];%'$5$5$:$:$<!- =&++sBFFFc|jjdD]\\}}}||f|jvr|j||f||j<6tj j ||j<^t j|j|jD]Q}d}d}|jj|dD]~\}}}|j|jtj jk(r|dz }C|j|jtj jk(sz|dz }|dk(s||jj|dz k7s|jj|dD]d\}}}|j|jtj jk7s>tj j||j<fTy)a Writes the desired partition into the graph to calculate the minimum spanning tree. Also, if one incoming edge is included, mark all others as excluded so that if that vertex is merged during Edmonds' algorithm we cannot still pick another of that vertex's included edges. Parameters ---------- partition : Partition A Partition dataclass describing a partition on the edges of the graph. Tr8r)nbunchr9rN) r<r;rrrCrnOPENrrmr4rprorL)rrsrPrQr\r"included_countexcluded_counts r#rz%ArborescenceIterator._write_partitionsvv|||. >GAq!1v111(1(@(@!Q(H$$$%(*(8(8(=(=$$$%  >  JANN66??!$?? (1a55++,0@0@0I0II"a'NUU4--."2B2B2K2KK"a'N  ("~9I9I!9Lq9P'P#vvadCJGAq!uuT//0B4D4D4M4MM020@0@0I0I$,,-J Jr+c|jdD]"\}}}|j|vs||j=$tj|jy)z7 Removes partition data from the graph Tr8N)r;rrCrr<)rr<rPrQr\s r#rz%ArborescenceIterator._clear_partition sRwwDw) *GAq!!!Q&d(() * r+)r)TN) rrrrrrrrrrrrr'r+r#rr5sH(T   )'V D!2&=P!JF r+r)N)r)r)r)rrN)r)rFN)$rr dataclassesrroperatorrqueuernetworkxrCnetworkx.utilsr recognitionr r __all__rBSTYLESrrlr$r*r- _dispatchabler r r rrrrdocstring_branchingdocstring_arborescenceformatrr'r+r#rsk:(*6  "+   ElJJfi01J2JBfi0EL FL ^d$?   g @g T d$dSAE T (d$dSAet< T< ~d$dSAE& T& Rd$dSAE T "6066 +7 I[A)?(E(E 1)F)%)?(E(E 1)F)% ] ] r+