
    fiF%                        d Z ddlZddlmZ g dZ ed          ej        d                         Z ed          ej        dd                        Z ed          ej        d                         Z	 ed          ej        d	                         Z
 ed           ej        d
          dd                        ZdS )zStrongly connected components.    N)not_implemented_for)$number_strongly_connected_componentsstrongly_connected_componentsis_strongly_connected&kosaraju_strongly_connected_componentscondensation
undirectedc              #   H   K   i }i }t                      }g }d} fd D             } D ]v}||vrn|g}|rh|d         }	|	|vr
|dz   }|||	<   d}
||	         D ]}||vr|                    |           d}
 n |
r"||	         ||	<    |	         D ]Y}||vrS||         ||	         k    r!t          ||	         ||         g          ||	<   9t          ||	         ||         g          ||	<   Z|                                 ||	         ||	         k    rz|	h}|r[||d                  ||	         k    rC|                                }|                    |           |r||d                  ||	         k    C|                    |           |V  n|                    |	           |hxdS )a  Generate nodes in strongly connected components of graph.

    Parameters
    ----------
    G : NetworkX Graph
        A directed graph.

    Returns
    -------
    comp : generator of sets
        A generator of sets of nodes, one for each strongly connected
        component of G.

    Raises
    ------
    NetworkXNotImplemented
        If G is undirected.

    Examples
    --------
    Generate a sorted list of strongly connected components, largest first.

    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
    >>> nx.add_cycle(G, [10, 11, 12])
    >>> [
    ...     len(c)
    ...     for c in sorted(nx.strongly_connected_components(G), key=len, reverse=True)
    ... ]
    [4, 3]

    If you only want the largest component, it's more efficient to
    use max instead of sort.

    >>> largest = max(nx.strongly_connected_components(G), key=len)

    See Also
    --------
    connected_components
    weakly_connected_components
    kosaraju_strongly_connected_components

    Notes
    -----
    Uses Tarjan's algorithm[1]_ with Nuutila's modifications[2]_.
    Nonrecursive version of algorithm.

    References
    ----------
    .. [1] Depth-first search and linear graph algorithms, R. Tarjan
       SIAM Journal of Computing 1(2):146-160, (1972).

    .. [2] On finding the strongly connected components in a directed graph.
       E. Nuutila and E. Soisalon-Soinen
       Information Processing Letters 49(1): 9-14, (1994)..

    r   c                 <    i | ]}|t          |                   S  )iter).0vGs     /var/www/development/aibuddy-work/election-extract/venv/lib/python3.11/site-packages/networkx/algorithms/components/strongly_connected.py
<dictcomp>z1strongly_connected_components.<locals>.<dictcomp>O   s%    ***1D1JJ***       TFN)setappendminpopaddupdate)r   preorderlowlink	scc_found	scc_queuei	neighborssourcequeuer   donewsccks   `             r   r   r      s&     v HGII	A*******I , ,""HE ,"IH$$AA"#HQK"1  A((Q$ )  ,!)!GAJqT L LI--'{Xa[88-0'!*gaj1I-J-J

-0'!*hqk1J-K-K
IIKKKqzXa[00 c' 'HYr],Chqk,Q,Q )AGGAJJJ ( 'HYr],Chqk,Q,Q "((---!				!((+++9  ,, ,r   c              #   L  K   t          t          j        |                     d          |                    }t	                      |rY|                                }|v rt          j        | |          }fd|D             }                    |           |V  |WdS dS )a	  Generate nodes in strongly connected components of graph.

    Parameters
    ----------
    G : NetworkX Graph
        A directed graph.

    Returns
    -------
    comp : generator of sets
        A generator of sets of nodes, one for each strongly connected
        component of G.

    Raises
    ------
    NetworkXNotImplemented
        If G is undirected.

    Examples
    --------
    Generate a sorted list of strongly connected components, largest first.

    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
    >>> nx.add_cycle(G, [10, 11, 12])
    >>> [
    ...     len(c)
    ...     for c in sorted(
    ...         nx.kosaraju_strongly_connected_components(G), key=len, reverse=True
    ...     )
    ... ]
    [4, 3]

    If you only want the largest component, it's more efficient to
    use max instead of sort.

    >>> largest = max(nx.kosaraju_strongly_connected_components(G), key=len)

    See Also
    --------
    strongly_connected_components

    Notes
    -----
    Uses Kosaraju's algorithm.

    F)copy)r"   c                     h | ]}|v|	S r   r   )r   r   seens     r   	<setcomp>z9kosaraju_strongly_connected_components.<locals>.<setcomp>   s    ---Qq}}q}}}r   N)listnxdfs_postorder_nodesreverser   r   dfs_preorder_nodesr   )r   r"   postrcnewr+   s         @r   r   r   r   s      b &qyyey'<'<VLLLMMD55D
 HHJJ99!!Q''----!---C			      r   c                 N    t          d t          |           D                       S )a  Returns number of strongly connected components in graph.

    Parameters
    ----------
    G : NetworkX graph
       A directed graph.

    Returns
    -------
    n : integer
       Number of strongly connected components

    Raises
    ------
    NetworkXNotImplemented
        If G is undirected.

    Examples
    --------
    >>> G = nx.DiGraph(
    ...     [(0, 1), (1, 2), (2, 0), (2, 3), (4, 5), (3, 4), (5, 6), (6, 3), (6, 7)]
    ... )
    >>> nx.number_strongly_connected_components(G)
    3

    See Also
    --------
    strongly_connected_components
    number_connected_components
    number_weakly_connected_components

    Notes
    -----
    For directed graphs only.
    c              3      K   | ]}d V  dS )r   Nr   )r   r&   s     r   	<genexpr>z7number_strongly_connected_components.<locals>.<genexpr>   s"      ==Sq======r   )sumr   r   s    r   r   r      s+    L ==9!<<======r   c                     t          |           dk    rt          j        d          t          t          t	          |                               t          |           k    S )aW  Test directed graph for strong connectivity.

    A directed graph is strongly connected if and only if every vertex in
    the graph is reachable from every other vertex.

    Parameters
    ----------
    G : NetworkX Graph
       A directed graph.

    Returns
    -------
    connected : bool
      True if the graph is strongly connected, False otherwise.

    Examples
    --------
    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 0), (2, 4), (4, 2)])
    >>> nx.is_strongly_connected(G)
    True
    >>> G.remove_edge(2, 3)
    >>> nx.is_strongly_connected(G)
    False

    Raises
    ------
    NetworkXNotImplemented
        If G is undirected.

    See Also
    --------
    is_weakly_connected
    is_semiconnected
    is_connected
    is_biconnected
    strongly_connected_components

    Notes
    -----
    For directed graphs only.
    r   z-Connectivity is undefined for the null graph.)lenr.   NetworkXPointlessConceptnextr   r:   s    r   r   r      sX    X 1vv{{)?
 
 	
 t1!445566#a&&@@r   T)returns_graphc                    |t          j        |           }i i }t          j                    }|j        d<   t	          |           dk    r|S t          |          D ]+\  }||<                       fd|D                        ,dz   }|                    t          |                     |	                    fd| 
                                D                        t          j        ||d           |S )a  Returns the condensation of G.

    The condensation of G is the graph with each of the strongly connected
    components contracted into a single node.

    Parameters
    ----------
    G : NetworkX DiGraph
       A directed graph.

    scc:  list or generator (optional, default=None)
       Strongly connected components. If provided, the elements in
       `scc` must partition the nodes in `G`. If not provided, it will be
       calculated as scc=nx.strongly_connected_components(G).

    Returns
    -------
    C : NetworkX DiGraph
       The condensation graph C of G.  The node labels are integers
       corresponding to the index of the component in the list of
       strongly connected components of G.  C has a graph attribute named
       'mapping' with a dictionary mapping the original nodes to the
       nodes in C to which they belong.  Each node in C also has a node
       attribute 'members' with the set of original nodes in G that
       form the SCC that the node in C represents.

    Raises
    ------
    NetworkXNotImplemented
        If G is undirected.

    Examples
    --------
    Contracting two sets of strongly connected nodes into two distinct SCC
    using the barbell graph.

    >>> G = nx.barbell_graph(4, 0)
    >>> G.remove_edge(3, 4)
    >>> G = nx.DiGraph(G)
    >>> H = nx.condensation(G)
    >>> H.nodes.data()
    NodeDataView({0: {'members': {0, 1, 2, 3}}, 1: {'members': {4, 5, 6, 7}}})
    >>> H.graph["mapping"]
    {0: 0, 1: 0, 2: 0, 3: 0, 4: 1, 5: 1, 6: 1, 7: 1}

    Contracting a complete graph into one single SCC.

    >>> G = nx.complete_graph(7, create_using=nx.DiGraph)
    >>> H = nx.condensation(G)
    >>> H.nodes
    NodeView((0,))
    >>> H.nodes.data()
    NodeDataView({0: {'members': {0, 1, 2, 3, 4, 5, 6}}})

    Notes
    -----
    After contracting all strongly connected components to a single node,
    the resulting graph is a directed acyclic graph.

    Nmappingr   c              3       K   | ]}|fV  	d S Nr   )r   nr    s     r   r8   zcondensation.<locals>.<genexpr>W  s'      11!1v111111r   r   c              3   b   K   | ])\  }}|         |         k    |         |         fV  *d S rC   r   )r   ur   rA   s      r   r8   zcondensation.<locals>.<genexpr>Z  sP        %)Q'!*PQ
:R:RWQZ :R:R:R:R r   members)r.   r   DiGraphgraphr<   	enumerater   add_nodes_fromrangeadd_edges_fromedgesset_node_attributes)r   r&   rG   C	componentnumber_of_componentsr    rA   s         @@r   r   r     s&   ~ {.q11GG

A AGI
1vv{{!# 2 29
1111y1111111q5U/00111    -.WWYY      1gy111Hr   rC   )__doc__networkxr.   networkx.utils.decoratorsr   __all___dispatchabler   r   r   r   r   r   r   r   <module>rX      st   $ $     9 9 9 9 9 9   \""^, ^,  #"^,B \""9 9 9  #"9x \""$> $>  #"$>N \""/A /A  #"/Ad \""%%%P P P &% #"P P Pr   