






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 			snake_case__   (							lowercase_):

       '''simple docstring'''
       lowerCamelCase							:				int 				= "new-model"


if is_tf_available():




     class 			snake_case__   (							lowercase_):

            '''simple docstring'''
            lowerCamelCase							:				int 				= NewModelConfig




@require_tf
class 			snake_case__   (							unittest.TestCase):

       '''simple docstring'''



       @slow
       def 					__lowercase						(							self    ) ->      Tuple:






            '''simple docstring'''





            __snake_case			:Optional[Any]          =						"""bert-base-cased"""
            __snake_case			:Optional[int]          =						AutoConfig.from_pretrained(a__    )
            self.assertIsNotNone(a__    )
            self.assertIsInstance(a__			,						a__    )

            __snake_case			:Tuple          =						TFAutoModel.from_pretrained(a__    )
            self.assertIsNotNone(a__    )
            self.assertIsInstance(a__			,						a__    )



       @slow
       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:List[str]          =						"""bert-base-cased"""
            __snake_case			:Union[str, Any]          =						AutoConfig.from_pretrained(a__    )
            self.assertIsNotNone(a__    )
            self.assertIsInstance(a__			,						a__    )

            __snake_case			:List[str]          =						TFAutoModelForPreTraining.from_pretrained(a__    )
            self.assertIsNotNone(a__    )
            self.assertIsInstance(a__			,						a__    )



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






            '''simple docstring'''





            for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __snake_case			:List[str]          =						AutoConfig.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )

                 __snake_case			:List[str]          =						TFAutoModelForCausalLM.from_pretrained(a__    )
                 __snake_case       , __snake_case			:Any          =						TFAutoModelForCausalLM.from_pretrained(a__			,						output_loading_info=a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )



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






            '''simple docstring'''





            for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __snake_case			:Any          =						AutoConfig.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )

                 __snake_case			:int          =						TFAutoModelWithLMHead.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )



       @slow
       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





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

                 __snake_case			:Union[str, Any]          =						TFAutoModelForMaskedLM.from_pretrained(a__    )
                 __snake_case       , __snake_case			:int          =						TFAutoModelForMaskedLM.from_pretrained(a__			,						output_loading_info=a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )



       @slow
       def 					__lowercase						(							self    ) ->      Tuple:






            '''simple docstring'''





            for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __snake_case			:Any          =						AutoConfig.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )

                 __snake_case			:str          =						TFAutoModelForSeqaSeqLM.from_pretrained(a__    )
                 __snake_case       , __snake_case			:Tuple          =						TFAutoModelForSeqaSeqLM.from_pretrained(a__			,						output_loading_info=a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )



       @slow
       def 					__lowercase						(							self    ) ->      List[str]:






            '''simple docstring'''





            for model_name in ["bert-base-uncased"]:
                 __snake_case			:Optional[int]          =						AutoConfig.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )

                 __snake_case			:Optional[Any]          =						TFAutoModelForSequenceClassification.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )



       @slow
       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





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

                 __snake_case			:Optional[Any]          =						TFAutoModelForQuestionAnswering.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )



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






            '''simple docstring'''





            for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
                 __snake_case			:Any          =						AutoConfig.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )

                 __snake_case			:Union[str, Any]          =						TFAutoModelForTableQuestionAnswering.from_pretrained(a__    )
                 __snake_case       , __snake_case			:Tuple          =						TFAutoModelForTableQuestionAnswering.from_pretrained(
                     a__			,						output_loading_info=a__    )
                 self.assertIsNotNone(a__    )
                 self.assertIsInstance(a__			,						a__    )



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






            '''simple docstring'''





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



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Optional[int]          =						TFAutoModelWithLMHead.from_pretrained(a__    )
            self.assertIsInstance(a__			,						a__    )
            self.assertEqual(model.num_parameters()			,						1_44_10    )
            self.assertEqual(model.num_parameters(only_trainable=a__    )			,						1_44_10    )



       def 					__lowercase						(							self    ) ->      List[str]:






            '''simple docstring'''





            __snake_case			:str          =						TFAutoModel.from_pretrained("""sgugger/funnel-random-tiny"""    )
            self.assertIsInstance(a__			,						a__    )

            __snake_case			:List[str]          =						copy.deepcopy(model.config    )
            __snake_case			:Tuple          =						["""FunnelBaseModel"""]
            __snake_case			:int          =						TFAutoModel.from_config(a__    )
            self.assertIsInstance(a__			,						a__    )

            with tempfile.TemporaryDirectory() as tmp_dir:
                 model.save_pretrained(a__    )
                 __snake_case			:Union[str, Any]          =						TFAutoModel.from_pretrained(a__    )
                 self.assertIsInstance(a__			,						a__    )



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






            '''simple docstring'''





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

                 __snake_case			:List[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(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
                           __snake_case			:Optional[int]          =						BertModelTester(self    ).get_config()
                           __snake_case			:Dict          =						NewModelConfig(**tiny_config.to_dict()    )
                           __snake_case			:Tuple          =						auto_class.from_config(a__    )
                           self.assertIsInstance(a__			,						a__    )

                           with tempfile.TemporaryDirectory() as tmp_dir:
                                model.save_pretrained(a__    )
                                __snake_case			:Any          =						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 					__lowercase						(							self    ) ->      Optional[Any]:






            '''simple docstring'''





            with self.assertRaisesRegex(
                a__			,						"""bert-base is not a local folder and is not a valid model identifier"""    ):
                 __snake_case			:List[str]          =						TFAutoModel.from_pretrained("""bert-base"""    )



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






            '''simple docstring'''





            with self.assertRaisesRegex(
                a__			,						R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""    ):
                 __snake_case			:List[Any]          =						TFAutoModel.from_pretrained(a__			,						revision="""aaaaaa"""    )



       def 					__lowercase						(							self    ) ->      str:






            '''simple docstring'''





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



       def 					__lowercase						(							self    ) ->      str:






            '''simple docstring'''





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



       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            __snake_case			:int          =						TFAutoModel.from_pretrained("""hf-internal-testing/tiny-random-bert"""    )
            with RequestCounter() as counter:
                 __snake_case			:Optional[int]          =						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
            __snake_case			:Tuple          =						TFAutoModel.from_pretrained("""ArthurZ/tiny-random-bert-sharded"""    )
            with RequestCounter() as counter:
                 __snake_case			:str          =						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    )










import os






def   UpperCamelCase  (       ):




     '''simple docstring'''






     __snake_case			:List[str]          =						os.path.dirname(os.path.realpath(snake_case__  )  )
     __snake_case			:Union[str, Any]          =						os.path.join(snake_case__	,"""triangle.txt"""  )

     with open(snake_case__  ) as f:
          __snake_case			:int          =						f.readlines()

     __snake_case			:int          =						[]
     for line in triangle:
          __snake_case			:List[Any]          =						[]
          for number in line.strip().split(""" """  ):
               numbers_from_line.append(int(snake_case__  )  )
          a.append(snake_case__  )

     for i in range(1	,len(snake_case__  )  ):
          for j in range(len(a[i]  )  ):
               __snake_case			:Union[str, Any]          =						a[i - 1][j] if j != len(a[i - 1]  ) else 0
               __snake_case			:Dict          =						a[i - 1][j - 1] if j > 0 else 0
               a[i][j] += max(snake_case__	,snake_case__  )
     return max(a[-1]  )


if __name__ == "__main__":
     print(solution())


