


import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
   import tensorflow as tf

if is_tensorflow_text_available():
   from transformers.models.bert import TFBertTokenizer


_A		       =						['bert-base-uncased', 'bert-base-cased']
_A		       =						'hf-internal-testing/tiny-bert-tf-only'

if is_tf_available():






   class     UpperCAmelCase__       (					tf.keras.Model		):



       """simple docstring"""






       def __init__(			self					,   A_    )  ->       List[str]:
            super().__init__()
            __UpperCamelCase    							=tokenizer
            __UpperCamelCase    							=AutoConfig.from_pretrained(_snake_case    )
            __UpperCamelCase    							=TFAutoModel.from_config(_snake_case    )






       def _a					(			self					,   A_    )  ->       Optional[Any]:
            __UpperCamelCase    							=self.tokenizer(_snake_case    )
            __UpperCamelCase    							=self.bert(**_snake_case    )
            return out["pooler_output"]






@require_tf
@require_tensorflow_text
class     UpperCAmelCase__       (					unittest.TestCase		):



    """simple docstring"""






    def _a					(			self    )  ->       List[str]:
         super().setUp()

         __UpperCamelCase    							=[
             BertTokenizer.from_pretrained(_snake_case    ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
         ]  # repeat for when fast_bert_tokenizer=false
         __UpperCamelCase    							=[TFBertTokenizer.from_pretrained(_snake_case    ) for checkpoint in TOKENIZER_CHECKPOINTS] + [
             TFBertTokenizer.from_pretrained(_snake_case					,   use_fast_bert_tokenizer=_snake_case    )
             for checkpoint in TOKENIZER_CHECKPOINTS
         ]
         assert len(self.tokenizers    ) == len(self.tf_tokenizers    )

         __UpperCamelCase    							=[
             '''This is a straightforward English test sentence.''',
             '''This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.''',
             '''Now we\'re going to add some Chinese: 一 二 三 一二三''',
             '''And some much more rare Chinese: 齉 堃 齉堃''',
             '''Je vais aussi écrire en français pour tester les accents''',
             '''Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ''',
         ]
         __UpperCamelCase    							=list(zip(self.test_sentences					,   self.test_sentences[::-1]    )    )






    def _a					(			self    )  ->       Dict:



         for tokenizer, tf_tokenizer in zip(self.tokenizers					,   self.tf_tokenizers    ):
              for test_inputs in (self.test_sentences, self.paired_sentences):
                   __UpperCamelCase    							=tokenizer(_snake_case					,   return_tensors='tf'					,   padding='longest'    )
                   __UpperCamelCase    							=tf_tokenizer(_snake_case    )

                   for key in python_outputs.keys():
                        self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape    )    )
                        self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key]					,   tf.intaa    ) == tf_outputs[key]    )    )






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



         for tf_tokenizer in self.tf_tokenizers:
              __UpperCamelCase    							=tf_tokenizer(self.paired_sentences    )
              __UpperCamelCase    							=tf_tokenizer(
                  text=[sentence[0] for sentence in self.paired_sentences]					,   text_pair=[sentence[1] for sentence in self.paired_sentences]					,   )
              for key in merged_outputs.keys():
                   self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key]					,   tf.intaa    ) == separated_outputs[key]    )    )






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



         for tf_tokenizer in self.tf_tokenizers:
              __UpperCamelCase    							=tf.function(_snake_case    )
              for test_inputs in (self.test_sentences, self.paired_sentences):
                   __UpperCamelCase    							=tf.constant(_snake_case    )
                   __UpperCamelCase    							=compiled_tokenizer(_snake_case    )
                   __UpperCamelCase    							=tf_tokenizer(_snake_case    )

                   for key in eager_outputs.keys():
                        self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]    )    )






    @slow
    def _a					(			self    )  ->       Any:



         for tf_tokenizer in self.tf_tokenizers:
              __UpperCamelCase    							=ModelToSave(tokenizer=_snake_case    )
              __UpperCamelCase    							=tf.convert_to_tensor(self.test_sentences    )
              __UpperCamelCase    							=model(_snake_case    )  # Build model with some sample inputs
              with TemporaryDirectory() as tempdir:
                   __UpperCamelCase    							=Path(_snake_case    ) / '''saved.model'''
                   model.save(_snake_case    )
                   __UpperCamelCase    							=tf.keras.models.load_model(_snake_case    )
              __UpperCamelCase    							=loaded_model(_snake_case    )
              # We may see small differences because the loaded model is compiled, so we need an epsilon for the test
              self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output    )    )					,   1E-5    )










"""simple docstring"""







def      __UpperCAmelCase      (    __lowerCamelCase = 50	)							->      int:
		lowercase__   :    int				=			[[0] * 3 for _ in range(length + 1	)]

		for row_length in range(length + 1	):
				for tile_length in range(2						,     5	):
						for tile_start in range(row_length - tile_length + 1	):
								different_colour_ways_number[row_length][tile_length - 2] += (
								    different_colour_ways_number[row_length - tile_start - tile_length][
								        tile_length - 2
								    ]
								    + 1
								)

		return sum(different_colour_ways_number[length]	)


if __name__ == "__main__":
							print(F'''{solution() = }''')
