



import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs



class        lowerCAmelCase__					(  _lowerCamelCase       ):


				def __init__(							self      :  Union[str, Any]						, __UpperCamelCase      :  str						, __UpperCamelCase      :  int=None						, __UpperCamelCase      :  int=True						, __UpperCamelCase      :  List[Any]=None						, **__UpperCamelCase      :  Union[str, Any]       )		->     Union[str, Any]:
											A      						=    parent
											A      						=    config_class
											A      						=    has_text_modality
											A      						=    kwargs
											A      						=    common_properties


				def __UpperCamelCase						(							self      :  Optional[int]       )		->     Tuple:
											A      						=    self.config_class(**self.inputs_dict       )
											A      						=    (
											    ['hidden_size', 'num_attention_heads', 'num_hidden_layers']
											    if self.common_properties is None
											    else self.common_properties
											)

											# Add common fields for text models
											if self.has_text_modality:
																		common_properties.extend(['vocab_size']       )

											# Test that config has the common properties as getters
											for prop in common_properties:
																		self.parent.assertTrue(hasattr(__UpperCamelCase						, __UpperCamelCase       )						, msg=f'''`{prop}` does not exist'''       )

											# Test that config has the common properties as setter
											for idx, name in enumerate(__UpperCamelCase       ):
																		try:
																									setattr(__UpperCamelCase						, __UpperCamelCase						, __UpperCamelCase       )
																									self.parent.assertEqual(
																									    getattr(__UpperCamelCase						, __UpperCamelCase       )						, __UpperCamelCase						, msg=f'''`{name} value {idx} expected, but was {getattr(__UpperCamelCase						, __UpperCamelCase       )}'''       )
																		except NotImplementedError:
																									# Some models might not be able to implement setters for common_properties
																									# In that case, a NotImplementedError is raised
																									pass

        # Test if config class can be called with Config(prop_name=..)
											for idx, name in enumerate(__UpperCamelCase       ):
																		try:
																									A      						=    self.config_class(**{name: idx}       )
																									self.parent.assertEqual(
																									    getattr(__UpperCamelCase						, __UpperCamelCase       )						, __UpperCamelCase						, msg=f'''`{name} value {idx} expected, but was {getattr(__UpperCamelCase						, __UpperCamelCase       )}'''       )
																		except NotImplementedError:
																									# Some models might not be able to implement setters for common_properties
																									# In that case, a NotImplementedError is raised
																									pass


				def __UpperCamelCase						(							self      :  List[Any]       )		->     str:
											A      						=    self.config_class(**self.inputs_dict       )
											A      						=    json.loads(config.to_json_string()       )
											for key, value in self.inputs_dict.items():
																		self.parent.assertEqual(obj[key]						, __UpperCamelCase       )


				def __UpperCamelCase						(							self      :  Optional[int]       )		->     Optional[int]:
											A      						=    self.config_class(**self.inputs_dict       )

											with tempfile.TemporaryDirectory() as tmpdirname:
																		A      						=    os.path.join(__UpperCamelCase						, 'config.json'       )
																		config_first.to_json_file(__UpperCamelCase       )
																		A      						=    self.config_class.from_json_file(__UpperCamelCase       )

											self.parent.assertEqual(config_second.to_dict()						, config_first.to_dict()       )


				def __UpperCamelCase						(							self      :  List[Any]       )		->     str:
											A      						=    self.config_class(**self.inputs_dict       )

											with tempfile.TemporaryDirectory() as tmpdirname:
																		config_first.save_pretrained(__UpperCamelCase       )
																		A      						=    self.config_class.from_pretrained(__UpperCamelCase       )

											self.parent.assertEqual(config_second.to_dict()						, config_first.to_dict()       )


				def __UpperCamelCase						(							self      :  Dict       )		->     Optional[Any]:
											A      						=    self.config_class(**self.inputs_dict       )

											A      						=    'test'
											with tempfile.TemporaryDirectory() as tmpdirname:
																		A      						=    os.path.join(__UpperCamelCase						, __UpperCamelCase       )
																		config_first.save_pretrained(__UpperCamelCase       )
																		A      						=    self.config_class.from_pretrained(__UpperCamelCase						, subfolder=__UpperCamelCase       )

											self.parent.assertEqual(config_second.to_dict()						, config_first.to_dict()       )


				def __UpperCamelCase						(							self      :  Optional[Any]       )		->     Tuple:
											A      						=    self.config_class(**self.inputs_dict						, num_labels=5       )
											self.parent.assertEqual(len(config.idalabel       )						, 5       )
											self.parent.assertEqual(len(config.labelaid       )						, 5       )

											A      						=    3
											self.parent.assertEqual(len(config.idalabel       )						, 3       )
											self.parent.assertEqual(len(config.labelaid       )						, 3       )


				def __UpperCamelCase						(							self      :  Dict       )		->     str:
											if self.config_class.is_composition:
																		return
											A      						=    self.config_class()
											self.parent.assertIsNotNone(__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  List[str]       )		->     Dict:
											A      						=    copy.deepcopy(__UpperCamelCase       )
											A      						=    self.config_class(**__UpperCamelCase       )
											A      						=    []
											for key, value in config_common_kwargs.items():
																		if key == "torch_dtype":
																									if not is_torch_available():
																																continue
																									else:
																																import torch

																																if config.torch_dtype != torch.floataa:
																																							wrong_values.append(('torch_dtype', config.torch_dtype, torch.floataa)       )
																		elif getattr(__UpperCamelCase						, __UpperCamelCase       ) != value:
																									wrong_values.append((key, getattr(__UpperCamelCase						, __UpperCamelCase       ), value)       )

											if len(__UpperCamelCase       ) > 0:
																		A      						=    '\n'.join([f'''- {v[0]}: got {v[1]} instead of {v[2]}''' for v in wrong_values]       )
																		raise ValueError(f'''The following keys were not properly set in the config:\n{errors}'''       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     Optional[int]:
											self.create_and_test_config_common_properties()
											self.create_and_test_config_to_json_string()
											self.create_and_test_config_to_json_file()
											self.create_and_test_config_from_and_save_pretrained()
											self.create_and_test_config_from_and_save_pretrained_subfolder()
											self.create_and_test_config_with_num_labels()
											self.check_config_can_be_init_without_params()
											self.check_config_arguments_init()




'''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


lowerCAmelCase_  :							List[str]             =    ['bert-base-uncased', 'bert-base-cased']
lowerCAmelCase_  :							int             =    'hf-internal-testing/tiny-bert-tf-only'

if is_tf_available():
							class 						lowerCamelCase_				(       tf.keras.Model      ):







													def __init__(	self :   Optional[int]					,     lowerCAmelCase__ :   Optional[Any]					):

																				"""simple docstring"""
																				super().__init__()
																				SCREAMING_SNAKE_CASE       :   List[str]         =      tokenizer
																				SCREAMING_SNAKE_CASE       :   str         =      AutoConfig.from_pretrained(lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      TFAutoModel.from_config(lowerCAmelCase__					)







													def        __lowercase     (	self :   Tuple					,     lowerCAmelCase__ :   Tuple					):

																				"""simple docstring"""
																				SCREAMING_SNAKE_CASE       :   Optional[Any]         =      self.tokenizer(lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   str         =      self.bert(**lowerCAmelCase__					)
																				return out["pooler_output"]
@require_tf
@require_tensorflow_text
class 						lowerCamelCase_				(       unittest.TestCase      ):







						def        __lowercase     (	self :   str					):

													"""simple docstring"""
													super().setUp()

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

													SCREAMING_SNAKE_CASE       :   Any         =      [
													    '''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ċ, ꝼ''',
													]
													SCREAMING_SNAKE_CASE       :   int         =      list(zip(self.test_sentences					,     self.test_sentences[::-1]					)					)







						def        __lowercase     (	self :   Any					):

													"""simple docstring"""
													for tokenizer, tf_tokenizer in zip(self.tokenizers					,     self.tf_tokenizers					):
																				for test_inputs in (self.test_sentences, self.paired_sentences):
																											SCREAMING_SNAKE_CASE       :   Tuple         =      tokenizer(lowerCAmelCase__					,     return_tensors='''tf'''					,     padding='''longest'''					)
																											SCREAMING_SNAKE_CASE       :   List[Any]         =      tf_tokenizer(lowerCAmelCase__					)

																											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        __lowercase     (	self :   Dict					):

													"""simple docstring"""
													for tf_tokenizer in self.tf_tokenizers:
																				SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      tf_tokenizer(self.paired_sentences					)
																				SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      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        __lowercase     (	self :   Union[str, Any]					):

													"""simple docstring"""
													for tf_tokenizer in self.tf_tokenizers:
																				SCREAMING_SNAKE_CASE       :   Any         =      tf.function(lowerCAmelCase__					)
																				for test_inputs in (self.test_sentences, self.paired_sentences):
																											SCREAMING_SNAKE_CASE       :   int         =      tf.constant(lowerCAmelCase__					)
																											SCREAMING_SNAKE_CASE       :   Any         =      compiled_tokenizer(lowerCAmelCase__					)
																											SCREAMING_SNAKE_CASE       :   List[str]         =      tf_tokenizer(lowerCAmelCase__					)

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







						@slow
						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													for tf_tokenizer in self.tf_tokenizers:
																				SCREAMING_SNAKE_CASE       :   int         =      ModelToSave(tokenizer=lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   Tuple         =      tf.convert_to_tensor(self.test_sentences					)
																				SCREAMING_SNAKE_CASE       :   Optional[Any]         =      model(lowerCAmelCase__					)  # Build model with some sample inputs
																				with TemporaryDirectory() as tempdir:
																											SCREAMING_SNAKE_CASE       :   Optional[int]         =      Path(lowerCAmelCase__					) / '''saved.model'''
																											model.save(lowerCAmelCase__					)
																											SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      tf.keras.models.load_model(lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   Tuple         =      loaded_model(lowerCAmelCase__					)
																				# 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					)




