





'''simple docstring'''




from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
							from transformers import (
							    TFAutoModel,
							    TFAutoModelForCausalLM,
							    TFAutoModelForMaskedLM,
							    TFAutoModelForPreTraining,
							    TFAutoModelForQuestionAnswering,
							    TFAutoModelForSeqaSeqLM,
							    TFAutoModelForSequenceClassification,
							    TFAutoModelForTableQuestionAnswering,
							    TFAutoModelForTokenClassification,
							    TFAutoModelWithLMHead,
							    TFBertForMaskedLM,
							    TFBertForPreTraining,
							    TFBertForQuestionAnswering,
							    TFBertForSequenceClassification,
							    TFBertModel,
							    TFFunnelBaseModel,
							    TFFunnelModel,
							    TFGPTaLMHeadModel,
							    TFRobertaForMaskedLM,
							    TFTaForConditionalGeneration,
							    TFTapasForQuestionAnswering,
							)
							from transformers.models.auto.modeling_tf_auto import (
							    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
							    TF_MODEL_FOR_MASKED_LM_MAPPING,
							    TF_MODEL_FOR_PRETRAINING_MAPPING,
							    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
							    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
							    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
							    TF_MODEL_MAPPING,
							)
							from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
							from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
							from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
							from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST




class 			UpperCamelCase__ ( __SCREAMING_SNAKE_CASE       ):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__            =     '''new-model'''


if is_tf_available():




							class 			UpperCamelCase__ ( __SCREAMING_SNAKE_CASE       ):




												"""simple docstring"""
												SCREAMING_SNAKE_CASE__            =     NewModelConfig




@require_tf
class 			UpperCamelCase__ ( unittest.TestCase       ):




					"""simple docstring"""


					@slow
					def lowerCamelCase_       (		self							:       Union[str, Any]		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE      :							List[Any]						=       "bert-base-cased"
							SCREAMING_SNAKE_CASE      :							Tuple						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
							self.assertIsNotNone(UpperCAmelCase_		)
							self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

							SCREAMING_SNAKE_CASE      :							Any						=       TFAutoModel.from_pretrained(UpperCAmelCase_		)
							self.assertIsNotNone(UpperCAmelCase_		)
							self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					@slow
					def lowerCamelCase_       (		self							:       Optional[Any]		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE      :							Any						=       "bert-base-cased"
							SCREAMING_SNAKE_CASE      :							Tuple						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
							self.assertIsNotNone(UpperCAmelCase_		)
							self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

							SCREAMING_SNAKE_CASE      :							Tuple						=       TFAutoModelForPreTraining.from_pretrained(UpperCAmelCase_		)
							self.assertIsNotNone(UpperCAmelCase_		)
							self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					@slow
					def lowerCamelCase_       (		self							:       int		):

							'''simple docstring'''



							for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE      :							str						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

									SCREAMING_SNAKE_CASE      :							List[str]						=       TFAutoModelForCausalLM.from_pretrained(UpperCAmelCase_		)
									SCREAMING_SNAKE_CASE      :							Optional[int]						=       TFAutoModelForCausalLM.from_pretrained(UpperCAmelCase_	,		output_loading_info=UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					@slow
					def lowerCamelCase_       (		self							:       List[Any]		):

							'''simple docstring'''



							for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE      :							List[Any]						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

									SCREAMING_SNAKE_CASE      :							Any						=       TFAutoModelWithLMHead.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					@slow
					def lowerCamelCase_       (		self							:       Dict		):

							'''simple docstring'''



							for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE      :							Optional[int]						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

									SCREAMING_SNAKE_CASE      :							Dict						=       TFAutoModelForMaskedLM.from_pretrained(UpperCAmelCase_		)
									SCREAMING_SNAKE_CASE      :							List[str]						=       TFAutoModelForMaskedLM.from_pretrained(UpperCAmelCase_	,		output_loading_info=UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					@slow
					def lowerCamelCase_       (		self							:       List[Any]		):

							'''simple docstring'''



							for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE      :							str						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

									SCREAMING_SNAKE_CASE      :							str						=       TFAutoModelForSeqaSeqLM.from_pretrained(UpperCAmelCase_		)
									SCREAMING_SNAKE_CASE      :							List[str]						=       TFAutoModelForSeqaSeqLM.from_pretrained(UpperCAmelCase_	,		output_loading_info=UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					@slow
					def lowerCamelCase_       (		self							:       str		):

							'''simple docstring'''



							for model_name in ["bert-base-uncased"]:
									SCREAMING_SNAKE_CASE      :							Dict						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

									SCREAMING_SNAKE_CASE      :							Dict						=       TFAutoModelForSequenceClassification.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					@slow
					def lowerCamelCase_       (		self							:       Optional[int]		):

							'''simple docstring'''



							for model_name in ["bert-base-uncased"]:
									SCREAMING_SNAKE_CASE      :							str						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

									SCREAMING_SNAKE_CASE      :							Tuple						=       TFAutoModelForQuestionAnswering.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					@slow
					@require_tensorflow_probability
					def lowerCamelCase_       (		self							:       Optional[int]		):

							'''simple docstring'''



							for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
									SCREAMING_SNAKE_CASE      :							Tuple						=       AutoConfig.from_pretrained(UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

									SCREAMING_SNAKE_CASE      :							Optional[Any]						=       TFAutoModelForTableQuestionAnswering.from_pretrained(UpperCAmelCase_		)
									SCREAMING_SNAKE_CASE      :							List[str]						=       TFAutoModelForTableQuestionAnswering.from_pretrained(
									    UpperCAmelCase_	,		output_loading_info=UpperCAmelCase_		)
									self.assertIsNotNone(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					def lowerCamelCase_       (		self							:       List[str]		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE      :							Dict						=       TFAutoModelWithLMHead.from_pretrained(UpperCAmelCase_		)
							self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)
							self.assertEqual(model.num_parameters()	,		1_44_10		)
							self.assertEqual(model.num_parameters(only_trainable=UpperCAmelCase_		)	,		1_44_10		)


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

							'''simple docstring'''



							SCREAMING_SNAKE_CASE      :							Tuple						=       TFAutoModelWithLMHead.from_pretrained(UpperCAmelCase_		)
							self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)
							self.assertEqual(model.num_parameters()	,		1_44_10		)
							self.assertEqual(model.num_parameters(only_trainable=UpperCAmelCase_		)	,		1_44_10		)


					def lowerCamelCase_       (		self							:       Optional[int]		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE      :							Tuple						=       TFAutoModel.from_pretrained("""sgugger/funnel-random-tiny"""		)
							self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

							SCREAMING_SNAKE_CASE      :							str						=       copy.deepcopy(model.config		)
							SCREAMING_SNAKE_CASE      :							Dict						=       ["FunnelBaseModel"]
							SCREAMING_SNAKE_CASE      :							List[Any]						=       TFAutoModel.from_config(UpperCAmelCase_		)
							self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

							with tempfile.TemporaryDirectory() as tmp_dir:
									model.save_pretrained(UpperCAmelCase_		)
									SCREAMING_SNAKE_CASE      :							List[Any]						=       TFAutoModel.from_pretrained(UpperCAmelCase_		)
									self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)


					def lowerCamelCase_       (		self							:       Optional[int]		):

							'''simple docstring'''



							try:
									AutoConfig.register("""new-model"""	,		UpperCAmelCase_		)

									SCREAMING_SNAKE_CASE      :							Optional[Any]						=       [
									    TFAutoModel,
									    TFAutoModelForCausalLM,
									    TFAutoModelForMaskedLM,
									    TFAutoModelForPreTraining,
									    TFAutoModelForQuestionAnswering,
									    TFAutoModelForSequenceClassification,
									    TFAutoModelForTokenClassification,
									]

									for auto_class in auto_classes:
											with self.subTest(auto_class.__name__		):
													# Wrong config class will raise an error
													with self.assertRaises(UpperCAmelCase_		):
															auto_class.register(UpperCAmelCase_	,		UpperCAmelCase_		)
													auto_class.register(UpperCAmelCase_	,		UpperCAmelCase_		)
													# Trying to register something existing in the Transformers library will raise an error
													with self.assertRaises(UpperCAmelCase_		):
															auto_class.register(UpperCAmelCase_	,		UpperCAmelCase_		)

													# Now that the config is registered, it can be used as any other config with the auto-API
													SCREAMING_SNAKE_CASE      :							Tuple						=       BertModelTester(self		).get_config()
													SCREAMING_SNAKE_CASE      :							List[str]						=       NewModelConfig(**tiny_config.to_dict()		)
													SCREAMING_SNAKE_CASE      :							List[Any]						=       auto_class.from_config(UpperCAmelCase_		)
													self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

													with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(UpperCAmelCase_		)
															SCREAMING_SNAKE_CASE      :							Tuple						=       auto_class.from_pretrained(UpperCAmelCase_		)
															self.assertIsInstance(UpperCAmelCase_	,		UpperCAmelCase_		)

							finally:
									if "new-model" in CONFIG_MAPPING._extra_content:
											del CONFIG_MAPPING._extra_content["new-model"]
									for mapping in (
									    TF_MODEL_MAPPING,
									    TF_MODEL_FOR_PRETRAINING_MAPPING,
									    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
									    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
									    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
									    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
									    TF_MODEL_FOR_MASKED_LM_MAPPING,
									):
											if NewModelConfig in mapping._extra_content:
													del mapping._extra_content[NewModelConfig]


					def lowerCamelCase_       (		self							:       Tuple		):

							'''simple docstring'''



							with self.assertRaisesRegex(
							    UpperCAmelCase_	,		"""bert-base is not a local folder and is not a valid model identifier"""		):
									SCREAMING_SNAKE_CASE      :							Optional[Any]						=       TFAutoModel.from_pretrained("""bert-base"""		)


					def lowerCamelCase_       (		self							:       List[Any]		):

							'''simple docstring'''



							with self.assertRaisesRegex(
							    UpperCAmelCase_	,		R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""		):
									SCREAMING_SNAKE_CASE      :							Optional[int]						=       TFAutoModel.from_pretrained(UpperCAmelCase_	,		revision="""aaaaaa"""		)


					def lowerCamelCase_       (		self							:       Optional[Any]		):

							'''simple docstring'''



							with self.assertRaisesRegex(
							    UpperCAmelCase_	,		"""hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin"""	,		):
									SCREAMING_SNAKE_CASE      :							Union[str, Any]						=       TFAutoModel.from_pretrained("""hf-internal-testing/config-no-model"""		)


					def lowerCamelCase_       (		self							:       str		):

							'''simple docstring'''



							with self.assertRaisesRegex(UpperCAmelCase_	,		"""Use `from_pt=True` to load this model"""		):
									SCREAMING_SNAKE_CASE      :							List[Any]						=       TFAutoModel.from_pretrained("""hf-internal-testing/tiny-bert-pt-only"""		)



					def lowerCamelCase_       (		self							:       str		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE      :							Dict						=       TFAutoModel.from_pretrained("""hf-internal-testing/tiny-random-bert"""		)
							with RequestCounter() as counter:
									SCREAMING_SNAKE_CASE      :							List[str]						=       TFAutoModel.from_pretrained("""hf-internal-testing/tiny-random-bert"""		)
									self.assertEqual(counter.get_request_count	,		0		)
									self.assertEqual(counter.head_request_count	,		1		)
									self.assertEqual(counter.other_request_count	,		0		)

							# With a sharded checkpoint
							SCREAMING_SNAKE_CASE      :							Optional[int]						=       TFAutoModel.from_pretrained("""ArthurZ/tiny-random-bert-sharded"""		)
							with RequestCounter() as counter:
									SCREAMING_SNAKE_CASE      :							List[Any]						=       TFAutoModel.from_pretrained("""ArthurZ/tiny-random-bert-sharded"""		)
									self.assertEqual(counter.get_request_count	,		0		)
									self.assertEqual(counter.head_request_count	,		1		)
									self.assertEqual(counter.other_request_count	,		0		)










from collections import defaultdict

from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst





def      lowerCAmelCase_ (       )     ->		Optional[int]:







  """simple docstring"""





  lowerCamelCase__  ,					lowerCamelCase__:      int			  =9, 14  # noqa: F841
  lowerCamelCase__:      List[Any]			  =[
      [0, 1, 4],
      [0, 7, 8],
      [1, 2, 8],
      [7, 8, 7],
      [7, 6, 1],
      [2, 8, 2],
      [8, 6, 6],
      [2, 3, 7],
      [2, 5, 4],
      [6, 5, 2],
      [3, 5, 14],
      [3, 4, 9],
      [5, 4, 10],
      [1, 7, 11],
  ]

  lowerCamelCase__:      List[str]			  =defaultdict(__a		)
  for nodea, nodea, cost in edges:
    adjancency[nodea].append([nodea, cost]		)
    adjancency[nodea].append([nodea, cost]		)

  lowerCamelCase__:      List[str]			  =mst(__a		)

  lowerCamelCase__:      Union[str, Any]			  =[
      [7, 6, 1],
      [2, 8, 2],
      [6, 5, 2],
      [0, 1, 4],
      [2, 5, 4],
      [2, 3, 7],
      [0, 7, 8],
      [3, 4, 9],
  ]

  for answer in expected:
    lowerCamelCase__:      Optional[int]			  =tuple(answer[:2]		)
    lowerCamelCase__:      List[Any]			  =tuple(edge[::-1]		)
    assert edge in result or reverse in result

