"""simple docstring"""





from __future__ import annotations

from typing import Any
class  _snake_case     :






						def __init__(       self      :			int							,					UpperCAmelCase      :			int    ):
													__lowerCamelCase					:		List[Any]		   =     num_of_nodes
													__lowerCamelCase					:		list[list[int]]		   =     []
													__lowerCamelCase					:		dict[int, int]		   =     {}






						def       lowerCamelCase__     (       self      :			Any							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			int    ):
													self.m_edges.append([u_node, v_node, weight]    )






						def       lowerCamelCase__     (       self      :			int							,					UpperCAmelCase      :			int    ):

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






						def       lowerCamelCase__     (       self      :			Union[str, Any]							,					UpperCAmelCase      :			int    ):

													if self.m_component[u_node] != u_node:
																				for k in self.m_component:
																											__lowerCamelCase					:		int		   =     self.find_component(UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			int							,					UpperCAmelCase      :			list[int]							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			int    ):

													if component_size[u_node] <= component_size[v_node]:
																				__lowerCamelCase					:		Optional[int]		   =     v_node
																				component_size[v_node] += component_size[u_node]
																				self.set_component(UpperCAmelCase    )

													elif component_size[u_node] >= component_size[v_node]:
																				__lowerCamelCase					:		Optional[int]		   =     self.find_component(UpperCAmelCase    )
																				component_size[u_node] += component_size[v_node]
																				self.set_component(UpperCAmelCase    )







						def       lowerCamelCase__     (       self      :			List[str]    ):
													__lowerCamelCase					:		List[Any]		   =     []
													__lowerCamelCase					:		Tuple		   =     0

													__lowerCamelCase					:		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    )

													__lowerCamelCase					:		int		   =     self.m_num_of_nodes

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

																											__lowerCamelCase					:		Optional[int]		   =     self.m_component[u]
																											__lowerCamelCase					:		Union[str, 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
																																									):
																																																__lowerCamelCase					:		Dict		   =     [u, v, w]

																				for edge in minimum_weight_edge:
																											if isinstance(UpperCAmelCase							,					UpperCAmelCase    ):
																																		__lowerCamelCase   ,  __lowerCamelCase   ,  __lowerCamelCase					:		Dict		   =     edge

																																		__lowerCamelCase					:		str		   =     self.m_component[u]
																																		__lowerCamelCase					:		Dict		   =     self.m_component[v]

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

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


def    lowercase_   (   ) ->      None:



							'''simple docstring'''



if __name__ == "__main__":
				import doctest

				doctest.testmod()
"""simple docstring"""





# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__A  =				abspath(join(dirname(__file__), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)


def    lowercase_   (   _lowerCamelCase:	List[Any]      ) ->      Union[str, Any]:



							'''simple docstring'''

							config.addinivalue_line(
							    "markers"						,   "is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested"      )
							config.addinivalue_line(
							    "markers"						,   "is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested"      )
							config.addinivalue_line("markers"						,   "is_pipeline_test: mark test to run only when pipelines are tested"      )
							config.addinivalue_line("markers"						,   "is_staging_test: mark test to run only in the staging environment"      )
							config.addinivalue_line("markers"						,   "accelerate_tests: mark test that require accelerate"      )
							config.addinivalue_line("markers"						,   "tool_tests: mark the tool tests that are run on their specific schedule"      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]      ) ->      Any:



							'''simple docstring'''

							from transformers.testing_utils import pytest_addoption_shared

							pytest_addoption_shared(_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Optional[int]      ) ->      Tuple:



							'''simple docstring'''

							from transformers.testing_utils import pytest_terminal_summary_main

							__lowerCamelCase					:		Any		   =     terminalreporter.config.getoption("--make-reports"      )
							if make_reports:
														pytest_terminal_summary_main(_lowerCamelCase						,   id=_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]						,   _lowerCamelCase:	Tuple      ) ->      Dict:



							'''simple docstring'''

							if exitstatus == 5:
														__lowerCamelCase					:		Optional[int]		   =     0


# Doctest custom flag to ignore output.
__A  =				doctest.register_optionflag('''IGNORE_RESULT''')

__A  =				doctest.OutputChecker
class  _snake_case     (					a__		):






						def       lowerCamelCase__     (       self      :			List[str]							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			Any							,					UpperCAmelCase      :			int    ):
													if IGNORE_RESULT & optionflags:
																				return True
													return OutputChecker.check_output(self							,					UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase    )

__A  =				CustomOutputChecker
__A  =				HfDoctestModule







__A  =				HfDocTestParser