



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


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

if is_tf_available():


							class   __lowerCAmelCase  (		tf.keras.Model   ):
												"""simple docstring"""






												def __init__(  self       :							str					,       _snake_case       :							Optional[int]       ):






															"""simple docstring"""


															super().__init__()
															A__	  =     tokenizer
															A__	  =     AutoConfig.from_pretrained(_snake_case       )
															A__	  =     TFAutoModel.from_config(_snake_case       )



												def      _a				(  self       :							Optional[int]					,       _snake_case       :							Optional[int]       ):






															"""simple docstring"""


															A__	  =     self.tokenizer(_snake_case       )
															A__	  =     self.bert(**_snake_case       )
															return out["pooler_output"]


@require_tf
@require_tensorflow_text
class   __lowerCAmelCase  (		unittest.TestCase   ):
					"""simple docstring"""






					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


								super().setUp()

								A__	  =     [
								    BertTokenizer.from_pretrained(_snake_case       ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
								]  # repeat for when fast_bert_tokenizer=false
								A__	  =     [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       )

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



					def      _a				(  self       :							str       ):






								"""simple docstring"""


								for tokenizer, tf_tokenizer in zip(self.tokenizers					,       self.tf_tokenizers       ):
											for test_inputs in (self.test_sentences, self.paired_sentences):
														A__	  =     tokenizer(_snake_case					,       return_tensors='tf'					,       padding='longest'       )
														A__	  =     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       :							Dict       ):






								"""simple docstring"""


								for tf_tokenizer in self.tf_tokenizers:
											A__	  =     tf_tokenizer(self.paired_sentences       )
											A__	  =     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[Any]       ):






								"""simple docstring"""


								for tf_tokenizer in self.tf_tokenizers:
											A__	  =     tf.function(_snake_case       )
											for test_inputs in (self.test_sentences, self.paired_sentences):
														A__	  =     tf.constant(_snake_case       )
														A__	  =     compiled_tokenizer(_snake_case       )
														A__	  =     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       :							Tuple       ):






								"""simple docstring"""


								for tf_tokenizer in self.tf_tokenizers:
											A__	  =     ModelToSave(tokenizer=_snake_case       )
											A__	  =     tf.convert_to_tensor(self.test_sentences       )
											A__	  =     model(_snake_case       )  # Build model with some sample inputs
											with TemporaryDirectory() as tempdir:
														A__	  =     Path(_snake_case       ) / 'saved.model'
														model.save(_snake_case       )
														A__	  =     tf.keras.models.load_model(_snake_case       )
											A__	  =     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       )









from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
							import tensorflow as tf

							from transformers import TFBlipTextModel
							from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST


class   __lowerCAmelCase  :
					"""simple docstring"""






					def __init__(  self       :							Dict					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							Optional[Any]=12					,       _snake_case       :							Any=7					,       _snake_case       :							List[str]=True					,       _snake_case       :							int=True					,       _snake_case       :							int=True					,       _snake_case       :							Tuple=99					,       _snake_case       :							List[Any]=32					,       _snake_case       :							Optional[int]=32					,       _snake_case       :							List[str]=2					,       _snake_case       :							List[str]=4					,       _snake_case       :							List[Any]=37					,       _snake_case       :							Union[str, Any]=0.1					,       _snake_case       :							Tuple=0.1					,       _snake_case       :							Dict=5_12					,       _snake_case       :							Union[str, Any]=0.02					,       _snake_case       :							Any=0					,       _snake_case       :							Optional[Any]=None					,       ):






								"""simple docstring"""


								A__	  =     parent
								A__	  =     batch_size
								A__	  =     seq_length
								A__	  =     is_training
								A__	  =     use_input_mask
								A__	  =     use_labels
								A__	  =     vocab_size
								A__	  =     hidden_size
								A__	  =     projection_dim
								A__	  =     num_hidden_layers
								A__	  =     num_attention_heads
								A__	  =     intermediate_size
								A__	  =     dropout
								A__	  =     attention_dropout
								A__	  =     max_position_embeddings
								A__	  =     initializer_range
								A__	  =     scope
								A__	  =     bos_token_id



					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								A__	  =     ids_tensor([self.batch_size, self.seq_length]					,       self.vocab_size       )

								A__	  =     None
								if self.use_input_mask:
											A__	  =     random_attention_mask([self.batch_size, self.seq_length]       )

								if input_mask is not None:
											A__	  =     input_mask.numpy()
											A__  ,			A__	  =     input_mask.shape
											A__	  =     np.random.randint(1					,       seq_length - 1					,       size=(batch_size,)       )
											for batch_idx, start_index in enumerate(_snake_case       ):
														A__	  =     1
														A__	  =     0

								A__	  =     self.get_config()

								return config, input_ids, tf.convert_to_tensor(_snake_case       )



					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


								return BlipTextConfig(
								    vocab_size=self.vocab_size					,       hidden_size=self.hidden_size					,       projection_dim=self.projection_dim					,       num_hidden_layers=self.num_hidden_layers					,       num_attention_heads=self.num_attention_heads					,       intermediate_size=self.intermediate_size					,       dropout=self.dropout					,       attention_dropout=self.attention_dropout					,       max_position_embeddings=self.max_position_embeddings					,       initializer_range=self.initializer_range					,       bos_token_id=self.bos_token_id					,       )



					def      _a				(  self       :							int					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							Any					,       _snake_case       :							List[str]       ):






								"""simple docstring"""


								A__	  =     TFBlipTextModel(config=_snake_case       )
								A__	  =     model(_snake_case					,       attention_mask=_snake_case					,       training=_snake_case       )
								A__	  =     model(_snake_case					,       training=_snake_case       )
								self.parent.assertEqual(result.last_hidden_state.shape					,       (self.batch_size, self.seq_length, self.hidden_size)       )
								self.parent.assertEqual(result.pooler_output.shape					,       (self.batch_size, self.hidden_size)       )



					def      _a				(  self       :							str       ):






								"""simple docstring"""


								A__	  =     self.prepare_config_and_inputs()
								A__  ,			A__  ,			A__	  =     config_and_inputs
								A__	  =     {'input_ids': input_ids, 'attention_mask': input_mask}
								return config, inputs_dict







@require_tf
class   __lowerCAmelCase  (		UpperCAmelCase_				,  unittest.TestCase   ):
					"""simple docstring"""






					A__					:		Tuple      							=     (TFBlipTextModel,) if is_tf_available() else ()
					A__					:		Optional[int]      							=     False
					A__					:		Union[str, Any]      							=     False
					A__					:		Union[str, Any]      							=     False



					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     BlipTextModelTester(self       )
								A__	  =     ConfigTester(self					,       config_class=_snake_case					,       hidden_size=37       )



					def      _a				(  self       :							List[str]       ):






								"""simple docstring"""


								self.config_tester.run_common_tests()



					def      _a				(  self       :							Union[str, Any]       ):






								"""simple docstring"""


								A__	  =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case       )



					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


								pass



					def      _a				(  self       :							int       ):






								"""simple docstring"""


								pass



					@unittest.skip(reason='Blip does not use inputs_embeds'       )
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								pass



					@unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'       )
					def      _a				(  self       :							str       ):






								"""simple docstring"""


								pass



					@unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'       )
					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								pass



					@slow
					def      _a				(  self       :							Union[str, Any]       ):






								"""simple docstring"""


								for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__	  =     TFBlipTextModel.from_pretrained(_snake_case       )
											self.assertIsNotNone(_snake_case       )



					def      _a				(  self       :							int					,       _snake_case       :							int=True       ):






								"""simple docstring"""


								super().test_pt_tf_model_equivalence(allow_missing_keys=_snake_case       )




