






"""simple docstring"""



from typing import List

from .keymap import KEYMAP, get_character



def 						lowercase    (				__snake_case				: str	):

		def decorator(__snake_case				: int	):
				lowercase_ : int							       =   getattr(__snake_case		,					'''handle_key'''		,					[]	)
				handle += [key]
				setattr(__snake_case		,					'''handle_key'''		,					__snake_case	)
				return func

		return decorator



def 						lowercase    (				*__snake_case				: List[str]	):

		def decorator(__snake_case				: Dict	):
				lowercase_ : int							       =   getattr(__snake_case		,					'''handle_key'''		,					[]	)
				handle += keys
				setattr(__snake_case		,					'''handle_key'''		,					__snake_case	)
				return func

		return decorator





class 					_UpperCAmelCase       ( _A							):




					def __new__(				cls     :						List[str]    ,						A     :						Tuple    ,						A     :						str    ,						A     :						Union[str, Any]   )  ->  str:
							lowercase_ : Optional[Any]							       =   super().__new__(cls    ,						A    ,						A    ,						A   )
							if not hasattr(A    ,						'''key_handler'''   ):
									setattr(A    ,						'''key_handler'''    ,						{}   )
							setattr(A    ,						'''handle_input'''    ,						KeyHandler.handle_input   )

							for value in attrs.values():
									lowercase_ : Dict							       =   getattr(A    ,						'''handle_key'''    ,						[]   )
									for key in handled_keys:
											lowercase_ : int							       =   value
							return new_cls






					@staticmethod
					def   A  (				cls     :						Tuple   )  ->  Optional[Any]:
							lowercase_ : Dict							       =   get_character()
							if char != KEYMAP["undefined"]:
									lowercase_ : str							       =   ord(A   )
							lowercase_ : Any							       =   cls.key_handler.get(A   )
							if handler:
									lowercase_ : Optional[int]							       =   char
									return handler(cls   )
							else:
									return None



def 						lowercase    (				cls				: List[str]	):
		return KeyHandler(cls.__name__		,					cls.__bases__		,					cls.__dict__.copy()	)








from __future__ import annotations

from typing import Any



class 				lowerCAmelCase_		:
       def __init__(			self,			SCREAMING_SNAKE_CASE_       )     ->		None:
          UpperCamelCase    :  Any							=	num_of_nodes
          UpperCamelCase    :  list[list[int]]							=	[]
          UpperCamelCase    :  dict[int, int]							=	{}
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		None:
          self.m_edges.append([u_node, v_node, weight]       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_       )     ->		int:

          if self.m_component[u_node] == u_node:
             return u_node
          return self.find_component(self.m_component[u_node]       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_       )     ->		None:

          if self.m_component[u_node] != u_node:
             for k in self.m_component:
                UpperCamelCase    :  Dict							=	self.find_component(SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		None:

          if component_size[u_node] <= component_size[v_node]:
             UpperCamelCase    :  Tuple							=	v_node
             component_size[v_node] += component_size[u_node]
             self.set_component(SCREAMING_SNAKE_CASE_       )

          elif component_size[u_node] >= component_size[v_node]:
             UpperCamelCase    :  Union[str, Any]							=	self.find_component(SCREAMING_SNAKE_CASE_       )
             component_size[u_node] += component_size[v_node]
             self.set_component(SCREAMING_SNAKE_CASE_       )






       def 					snake_case_       (			self       )     ->		None:
          UpperCamelCase    :  int							=	[]
          UpperCamelCase    :  int							=	0

          UpperCamelCase    :  list[Any]							=	[-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       )

          UpperCamelCase    :  List[str]							=	self.m_num_of_nodes

          while num_of_components > 1:
             for edge in self.m_edges:
                UpperCamelCase	,     UpperCamelCase	,     UpperCamelCase    :  List[Any]							=	edge

                UpperCamelCase    :  str							=	self.m_component[u]
                UpperCamelCase    :  Any							=	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
                      ):
                         UpperCamelCase    :  Any							=	[u, v, w]

             for edge in minimum_weight_edge:
                if isinstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       ):
                   UpperCamelCase	,     UpperCamelCase	,     UpperCamelCase    :  int							=	edge

                   UpperCamelCase    :  List[Any]							=	self.m_component[u]
                   UpperCamelCase    :  Tuple							=	self.m_component[v]

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

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






def 		UpperCamelCase	(   )	->     None:
   pass


if __name__ == "__main__":
    import doctest

    doctest.testmod()



