from __future__ import annotations

from typing import Any
class     a_			:






 '''simple docstring'''






 def __init__(      self :  Union[str, Any]      ,   lowercase__ :  int):







        '''simple docstring'''



        lowerCAmelCase__					     = num_of_nodes
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = {}




 def 		__snake_case						(      self :  Optional[Any]      ,   lowercase__ :  int      ,   lowercase__ :  int      ,   lowercase__ :  int):







        '''simple docstring'''



        self.m_edges.append([u_node, v_node, weight])




 def 		__snake_case						(      self :  List[str]      ,   lowercase__ :  int):







        '''simple docstring'''



        if self.m_component[u_node] == u_node:
               return u_node
        return self.find_component(self.m_component[u_node])




 def 		__snake_case						(      self :  List[str]      ,   lowercase__ :  int):







        '''simple docstring'''



        if self.m_component[u_node] != u_node:
               for k in self.m_component:
                      lowerCAmelCase__					     = self.find_component(lowercase__)




 def 		__snake_case						(      self :  Tuple      ,   lowercase__ :  list[int]      ,   lowercase__ :  int      ,   lowercase__ :  int):







        '''simple docstring'''



        if component_size[u_node] <= component_size[v_node]:
               lowerCAmelCase__					     = v_node
               component_size[v_node] += component_size[u_node]
               self.set_component(lowercase__)

        elif component_size[u_node] >= component_size[v_node]:
               lowerCAmelCase__					     = self.find_component(lowercase__)
               component_size[u_node] += component_size[v_node]
               self.set_component(lowercase__)




 def 		__snake_case						(      self :  Union[str, Any]):







        '''simple docstring'''



        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = 0

        lowerCAmelCase__					     = [-1] * self.m_num_of_nodes

        # A list of components (initialized to all of the nodes)
        for node in range(self.m_num_of_nodes):
               self.m_component.update({node: node})
               component_size.append(1)

        lowerCAmelCase__					     = self.m_num_of_nodes

        while num_of_components > 1:
               for edge in self.m_edges:
                      lowerCAmelCase__     , lowerCAmelCase__     , lowerCAmelCase__					     = edge

                      lowerCAmelCase__					     = self.m_component[u]
                      lowerCAmelCase__					     = self.m_component[v]

                      if u_component != v_component:

                             for component in (u_component, v_component):
                                    if (
                                        minimum_weight_edge[component] == -1
                                        or minimum_weight_edge[component][2] > w
                                    ):
                                           lowerCAmelCase__					     = [u, v, w]

               for edge in minimum_weight_edge:
                      if isinstance(lowercase__      ,   lowercase__):
                             lowerCAmelCase__     , lowerCAmelCase__     , lowerCAmelCase__					     = edge

                             lowerCAmelCase__					     = self.m_component[u]
                             lowerCAmelCase__					     = self.m_component[v]

                             if u_component != v_component:
                                    mst_weight += w
                                    self.union(lowercase__      ,   lowercase__      ,   lowercase__)
                                    print(F"""Added edge [{u} - {v}]\nAdded weight: {w}\n""")
                                    num_of_components -= 1

               lowerCAmelCase__					     = [-1] * self.m_num_of_nodes
        print(F"""The total weight of the minimal spanning tree is: {mst_weight}""")






def 				__lowerCamelCase		(						):
       pass


if __name__ == "__main__":
    import doctest

    doctest.testmod()


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase__     						=			{
    'configuration_x_clip': [
        'XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'XCLIPConfig',
        'XCLIPTextConfig',
        'XCLIPVisionConfig',
    ],
    'processing_x_clip': ['XCLIPProcessor'],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase__     						=			[
        'XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
        'XCLIPModel',
        'XCLIPPreTrainedModel',
        'XCLIPTextModel',
        'XCLIPVisionModel',
    ]

if TYPE_CHECKING:
    from .configuration_x_clip import (
        XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
        XCLIPConfig,
        XCLIPTextConfig,
        XCLIPVisionConfig,
    )
    from .processing_x_clip import XCLIPProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_x_clip import (
            XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
            XCLIPModel,
            XCLIPPreTrainedModel,
            XCLIPTextModel,
            XCLIPVisionModel,
        )

else:
    import sys

    lowerCAmelCase__     						=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
