


"""simple docstring"""



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


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

if is_tf_available():







  class _lowerCAmelCase				(      tf.keras.Model	):







     def __init__(	self						,	UpperCamelCase__						)	->		Any:

         '''simple docstring'''




         super().__init__()
         snake_case    :      Optional[int]      					=    tokenizer
         snake_case    :      str      					=    AutoConfig.from_pretrained(UpperCamelCase__						)
         snake_case    :      Optional[Any]      					=    TFAutoModel.from_config(UpperCamelCase__						)







     def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		Any:

         '''simple docstring'''




         snake_case    :      Tuple      					=    self.tokenizer(UpperCamelCase__						)
         snake_case    :      str      					=    self.bert(**UpperCamelCase__						)
         return out["pooler_output"]







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







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

       '''simple docstring'''




       super().setUp()

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

       snake_case    :      str      					=    [
           "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ċ, ꝼ",
       ]
       snake_case    :      Optional[int]      					=    list(zip(self.test_sentences						,	self.test_sentences[::-1]						)						)







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

       '''simple docstring'''




       for tokenizer, tf_tokenizer in zip(self.tokenizers						,	self.tf_tokenizers						):
           for test_inputs in (self.test_sentences, self.paired_sentences):
               snake_case    :      List[str]      					=    tokenizer(UpperCamelCase__						,	return_tensors="tf"						,	padding="longest"						)
               snake_case    :      List[str]      					=    tf_tokenizer(UpperCamelCase__						)

               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  lowerCamelCase		(	self						)	->		str:

       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
           snake_case    :      Optional[Any]      					=    tf_tokenizer(self.paired_sentences						)
           snake_case    :      Tuple      					=    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  lowerCamelCase		(	self						)	->		List[Any]:

       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
           snake_case    :      int      					=    tf.function(UpperCamelCase__						)
           for test_inputs in (self.test_sentences, self.paired_sentences):
               snake_case    :      List[Any]      					=    tf.constant(UpperCamelCase__						)
               snake_case    :      Tuple      					=    compiled_tokenizer(UpperCamelCase__						)
               snake_case    :      Dict      					=    tf_tokenizer(UpperCamelCase__						)

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







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

       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
           snake_case    :      Optional[Any]      					=    ModelToSave(tokenizer=UpperCamelCase__						)
           snake_case    :      Optional[Any]      					=    tf.convert_to_tensor(self.test_sentences						)
           snake_case    :      Dict      					=    model(UpperCamelCase__						)  # Build model with some sample inputs
           with TemporaryDirectory() as tempdir:
               snake_case    :      Dict      					=    Path(UpperCamelCase__						) / "saved.model"
               model.save(UpperCamelCase__						)
               snake_case    :      Any      					=    tf.keras.models.load_model(UpperCamelCase__						)
           snake_case    :      str      					=    loaded_model(UpperCamelCase__						)
           # 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   __lowerCAmelCase						(						lowercase  :  list[int] )	->						float:


    """simple docstring"""





    if not nums:  # Makes sure that the list is not empty
        raise ValueError("List is empty" )

    snake_case    :      List[str]      					=    sum(lowercase ) / len(lowercase )  # Calculate the average
    return sum(abs(x - average ) for x in nums ) / len(lowercase )


if __name__ == "__main__":
  import doctest

  doctest.testmod()





