



'''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 __A			(  A						):



 '''simple docstring'''







 __lowerCamelCase    :       Optional[int]          =       'new-model'


if is_tf_available():






  class __A			(  A						):



   '''simple docstring'''







   __lowerCamelCase    :       Any          =       NewModelConfig






@require_tf
class __A			(  unittest.TestCase						):



 '''simple docstring'''







 @slow
 def 					a__  (self       )    ->     str:


      """simple docstring"""



      _a      =  '''bert-base-cased'''
      _a      =  AutoConfig.from_pretrained(A       )
      self.assertIsNotNone(A       )
      self.assertIsInstance(A ,   A       )

      _a      =  TFAutoModel.from_pretrained(A       )
      self.assertIsNotNone(A       )
      self.assertIsInstance(A ,   A       )



 @slow
 def 					a__  (self       )    ->     Any:


      """simple docstring"""



      _a      =  '''bert-base-cased'''
      _a      =  AutoConfig.from_pretrained(A       )
      self.assertIsNotNone(A       )
      self.assertIsInstance(A ,   A       )

      _a      =  TFAutoModelForPreTraining.from_pretrained(A       )
      self.assertIsNotNone(A       )
      self.assertIsInstance(A ,   A       )



 @slow
 def 					a__  (self       )    ->     int:


      """simple docstring"""



      for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a      =  AutoConfig.from_pretrained(A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )

           _a      =  TFAutoModelForCausalLM.from_pretrained(A       )
           _a  ,    _a      =  TFAutoModelForCausalLM.from_pretrained(A ,   output_loading_info=A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )



 @slow
 def 					a__  (self       )    ->     Union[str, Any]:


      """simple docstring"""



      for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a      =  AutoConfig.from_pretrained(A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )

           _a      =  TFAutoModelWithLMHead.from_pretrained(A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )



 @slow
 def 					a__  (self       )    ->     Optional[Any]:


      """simple docstring"""



      for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a      =  AutoConfig.from_pretrained(A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )

           _a      =  TFAutoModelForMaskedLM.from_pretrained(A       )
           _a  ,    _a      =  TFAutoModelForMaskedLM.from_pretrained(A ,   output_loading_info=A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )



 @slow
 def 					a__  (self       )    ->     Dict:


      """simple docstring"""



      for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a      =  AutoConfig.from_pretrained(A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )

           _a      =  TFAutoModelForSeqaSeqLM.from_pretrained(A       )
           _a  ,    _a      =  TFAutoModelForSeqaSeqLM.from_pretrained(A ,   output_loading_info=A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )



 @slow
 def 					a__  (self       )    ->     Optional[int]:


      """simple docstring"""



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

           _a      =  TFAutoModelForSequenceClassification.from_pretrained(A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )



 @slow
 def 					a__  (self       )    ->     List[Any]:


      """simple docstring"""



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

           _a      =  TFAutoModelForQuestionAnswering.from_pretrained(A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )



 @slow
 @require_tensorflow_probability
 def 					a__  (self       )    ->     Any:


      """simple docstring"""



      for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
           _a      =  AutoConfig.from_pretrained(A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )

           _a      =  TFAutoModelForTableQuestionAnswering.from_pretrained(A       )
           _a  ,    _a      =  TFAutoModelForTableQuestionAnswering.from_pretrained(
               A ,   output_loading_info=A       )
           self.assertIsNotNone(A       )
           self.assertIsInstance(A ,   A       )



 def 					a__  (self       )    ->     Any:


      """simple docstring"""



      _a      =  TFAutoModelWithLMHead.from_pretrained(A       )
      self.assertIsInstance(A ,   A       )
      self.assertEqual(model.num_parameters() ,   14_410       )
      self.assertEqual(model.num_parameters(only_trainable=A       ) ,   14_410       )



 def 					a__  (self       )    ->     int:


      """simple docstring"""



      _a      =  TFAutoModelWithLMHead.from_pretrained(A       )
      self.assertIsInstance(A ,   A       )
      self.assertEqual(model.num_parameters() ,   14_410       )
      self.assertEqual(model.num_parameters(only_trainable=A       ) ,   14_410       )



 def 					a__  (self       )    ->     Optional[int]:


      """simple docstring"""



      _a      =  TFAutoModel.from_pretrained('''sgugger/funnel-random-tiny'''       )
      self.assertIsInstance(A ,   A       )

      _a      =  copy.deepcopy(model.config       )
      _a      =  ['''FunnelBaseModel''']
      _a      =  TFAutoModel.from_config(A       )
      self.assertIsInstance(A ,   A       )

      with tempfile.TemporaryDirectory() as tmp_dir:
           model.save_pretrained(A       )
           _a      =  TFAutoModel.from_pretrained(A       )
           self.assertIsInstance(A ,   A       )



 def 					a__  (self       )    ->     Optional[Any]:


      """simple docstring"""



      try:
           AutoConfig.register('''new-model''' ,   A       )

           _a      =  [
               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(A       ):
                          auto_class.register(A ,   A       )
                     auto_class.register(A ,   A       )
                     # Trying to register something existing in the Transformers library will raise an error
                     with self.assertRaises(A       ):
                          auto_class.register(A ,   A       )

                     # Now that the config is registered, it can be used as any other config with the auto-API
                     _a      =  BertModelTester(self       ).get_config()
                     _a      =  NewModelConfig(**tiny_config.to_dict()       )
                     _a      =  auto_class.from_config(A       )
                     self.assertIsInstance(A ,   A       )

                     with tempfile.TemporaryDirectory() as tmp_dir:
                          model.save_pretrained(A       )
                          _a      =  auto_class.from_pretrained(A       )
                          self.assertIsInstance(A ,   A       )

      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 					a__  (self       )    ->     int:


      """simple docstring"""



      with self.assertRaisesRegex(
          A ,   '''bert-base is not a local folder and is not a valid model identifier'''       ):
           _a      =  TFAutoModel.from_pretrained('''bert-base'''       )



 def 					a__  (self       )    ->     int:


      """simple docstring"""



      with self.assertRaisesRegex(
          A ,   R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''       ):
           _a      =  TFAutoModel.from_pretrained(A ,   revision='''aaaaaa'''       )



 def 					a__  (self       )    ->     Optional[Any]:


      """simple docstring"""



      with self.assertRaisesRegex(
          A ,   '''hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin''' ,   ):
           _a      =  TFAutoModel.from_pretrained('''hf-internal-testing/config-no-model'''       )



 def 					a__  (self       )    ->     Optional[int]:


      """simple docstring"""



      with self.assertRaisesRegex(A ,   '''Use `from_pt=True` to load this model'''       ):
           _a      =  TFAutoModel.from_pretrained('''hf-internal-testing/tiny-bert-pt-only'''       )



 def 					a__  (self       )    ->     Union[str, Any]:


      """simple docstring"""



      _a      =  TFAutoModel.from_pretrained('''hf-internal-testing/tiny-random-bert'''       )
      with RequestCounter() as counter:
           _a      =  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
      _a      =  TFAutoModel.from_pretrained('''ArthurZ/tiny-random-bert-sharded'''       )
      with RequestCounter() as counter:
           _a      =  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       )








'''simple docstring'''





import math






class __A			:



 '''simple docstring'''







 def __init__(self ,   A=0       )    ->     Dict:  # a graph with Node 0,1,...,N-1


      """simple docstring"""



      _a      =  n
      _a      =  [
          [math.inf for j in range(0 ,   A       )] for i in range(0 ,   A       )
      ]  # adjacency matrix for weight
      _a      =  [
          [math.inf for j in range(0 ,   A       )] for i in range(0 ,   A       )
      ]  # dp[i][j] stores minimum distance from i to j



 def 					a__  (self ,   A ,   A ,   A       )    ->     Tuple:


      """simple docstring"""



      _a      =  w



 def 					a__  (self       )    ->     List[Any]:


      """simple docstring"""



      for k in range(0 ,   self.n       ):
           for i in range(0 ,   self.n       ):
                for j in range(0 ,   self.n       ):
                     _a      =  min(self.dp[i][j] ,   self.dp[i][k] + self.dp[k][j]       )



 def 					a__  (self ,   A ,   A       )    ->     str:


      """simple docstring"""



      return self.dp[u][v]


if __name__ == "__main__":
  lowercase_		       =  Graph(5)
  graph.add_edge(0, 2, 9)
  graph.add_edge(0, 4, 10)
  graph.add_edge(1, 3, 5)
  graph.add_edge(2, 3, 7)
  graph.add_edge(3, 0, 10)
  graph.add_edge(3, 1, 2)
  graph.add_edge(3, 2, 1)
  graph.add_edge(3, 4, 6)
  graph.add_edge(4, 1, 3)
  graph.add_edge(4, 2, 4)
  graph.add_edge(4, 3, 9)
  graph.floyd_warshall()
  graph.show_min(1, 4)
  graph.show_min(0, 3)



