

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask


if is_torch_available():
      import torch

      from transformers import BlipTextModel
      from transformers.models.blip.modeling_blip import BLIP_PRETRAINED_MODEL_ARCHIVE_LIST






class     __magic_name__     :


 def __init__(    self		:			List[Any]      ,    lowerCAmelCase__		:			Any      ,    lowerCAmelCase__		:			Union[str, Any]=1_2      ,    lowerCAmelCase__		:			Any=7      ,    lowerCAmelCase__		:			str=True      ,    lowerCAmelCase__		:			Tuple=True      ,    lowerCAmelCase__		:			List[Any]=True      ,    lowerCAmelCase__		:			List[Any]=9_9      ,    lowerCAmelCase__		:			Optional[int]=3_2      ,    lowerCAmelCase__		:			List[Any]=3_2      ,    lowerCAmelCase__		:			List[str]=5      ,    lowerCAmelCase__		:			List[Any]=4      ,    lowerCAmelCase__		:			Union[str, Any]=3_7      ,    lowerCAmelCase__		:			Union[str, Any]=0.1      ,    lowerCAmelCase__		:			Dict=0.1      ,    lowerCAmelCase__		:			int=5_1_2      ,    lowerCAmelCase__		:			Dict=0.02      ,    lowerCAmelCase__		:			List[Any]=0      ,    lowerCAmelCase__		:			Optional[int]=None      ,    )     ->   Dict:
   UpperCAmelCase          =	parent
   UpperCAmelCase          =	batch_size
   UpperCAmelCase          =	seq_length
   UpperCAmelCase          =	is_training
   UpperCAmelCase          =	use_input_mask
   UpperCAmelCase          =	use_labels
   UpperCAmelCase          =	vocab_size
   UpperCAmelCase          =	hidden_size
   UpperCAmelCase          =	projection_dim
   UpperCAmelCase          =	num_hidden_layers
   UpperCAmelCase          =	num_attention_heads
   UpperCAmelCase          =	intermediate_size
   UpperCAmelCase          =	dropout
   UpperCAmelCase          =	attention_dropout
   UpperCAmelCase          =	max_position_embeddings
   UpperCAmelCase          =	initializer_range
   UpperCAmelCase          =	scope
   UpperCAmelCase          =	bos_token_id


 def _UpperCamelCase						(    self		:			Tuple     )     ->   Union[str, Any]:
   UpperCAmelCase          =	ids_tensor([self.batch_size, self.seq_length]      ,    self.vocab_size     )

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

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

   UpperCAmelCase          =	self.get_config()

   return config, input_ids, input_mask


 def _UpperCamelCase						(    self		:			Tuple     )     ->   Any:
   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 _UpperCamelCase						(    self		:			Optional[Any]      ,    lowerCAmelCase__		:			Tuple      ,    lowerCAmelCase__		:			str      ,    lowerCAmelCase__		:			Any     )     ->   int:
   UpperCAmelCase          =	BlipTextModel(config=a_     )
   model.to(a_     )
   model.eval()
   with torch.no_grad():
     UpperCAmelCase          =	model(a_      ,    attention_mask=a_     )
     UpperCAmelCase          =	model(a_     )
   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 _UpperCamelCase						(    self		:			Optional[Any]     )     ->   Optional[int]:
   UpperCAmelCase          =	self.prepare_config_and_inputs()
   UpperCAmelCase          =	config_and_inputs
   UpperCAmelCase          =	{'''input_ids''': input_ids, '''attention_mask''': input_mask}
   return config, inputs_dict






@require_torch
class     __magic_name__     (							__UpperCamelCase						,    unittest.TestCase     ):
 UpperCAmelCase				     =    (BlipTextModel,) if is_torch_available() else ()
 UpperCAmelCase				     =    False
 UpperCAmelCase				     =    False
 UpperCAmelCase				     =    False


 def _UpperCamelCase						(    self		:			Tuple     )     ->   List[Any]:
   UpperCAmelCase          =	BlipTextModelTester(self     )
   UpperCAmelCase          =	ConfigTester(self      ,    config_class=a_      ,    hidden_size=3_7     )


 def _UpperCamelCase						(    self		:			Optional[Any]     )     ->   Union[str, Any]:
   self.config_tester.run_common_tests()


 def _UpperCamelCase						(    self		:			Any     )     ->   Optional[int]:
   UpperCAmelCase          =	self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*a_     )


 def _UpperCamelCase						(    self		:			List[str]     )     ->   Optional[Any]:
   pass


 def _UpperCamelCase						(    self		:			Optional[int]     )     ->   List[str]:
   pass


 @unittest.skip(reason="Blip does not use inputs_embeds"     )
 def _UpperCamelCase						(    self		:			int     )     ->   Tuple:
   pass


 @unittest.skip(reason="BlipTextModel has no base class and is not available in MODEL_MAPPING"     )
 def _UpperCamelCase						(    self		:			int     )     ->   List[str]:
   pass


 @unittest.skip(reason="BlipTextModel has no base class and is not available in MODEL_MAPPING"     )
 def _UpperCamelCase						(    self		:			Optional[int]     )     ->   Optional[int]:
   pass


 @slow
 def _UpperCamelCase						(    self		:			Any     )     ->   int:





   for model_name in BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     UpperCAmelCase          =	BlipTextModel.from_pretrained(a_     )
     self.assertIsNotNone(a_     )


 def _UpperCamelCase						(    self		:			Union[str, Any]     )     ->   int:
   super().test_pt_tf_model_equivalence(allow_missing_keys=a_     )








import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
				from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

				from .test_feature_extraction_speechta import floats_list


__A       =get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")

@require_torch
class 						UpperCAmelCase__     (     unittest.TestCase  ):




			'''simple docstring'''






			def 					snake_case__	(  self				:					List[str]					):
					'''simple docstring'''





					__UpperCAmelCase       :	str						=      tempfile.mkdtemp()

					__UpperCAmelCase       :	Optional[int]						=      SpeechTaTokenizer(a_					)
					tokenizer.save_pretrained(self.tmpdirname					)

					__UpperCAmelCase       :	Union[str, Any]						=      {
					    '''feature_size''': 1,
					    '''padding_value''': 0.0,
					    '''sampling_rate''': 1_60_00,
					    '''do_normalize''': False,
					    '''num_mel_bins''': 80,
					    '''hop_length''': 16,
					    '''win_length''': 64,
					    '''win_function''': '''hann_window''',
					    '''fmin''': 80,
					    '''fmax''': 76_00,
					    '''mel_floor''': 1e-10,
					    '''reduction_factor''': 2,
					    '''return_attention_mask''': True,
					}

					__UpperCAmelCase       :	Tuple						=      os.path.join(self.tmpdirname			,			a_					)
					with open(self.feature_extraction_file			,			'''w'''			,			encoding='''utf-8'''					) as fp:
							fp.write(json.dumps(a_					) + '''\n'''					)




			def 					snake_case__	(  self				:					Any			,			**a_				:					Tuple					):
					'''simple docstring'''





					return SpeechTaTokenizer.from_pretrained(self.tmpdirname			,			**a_					)




			def 					snake_case__	(  self				:					Dict			,			**a_				:					str					):
					'''simple docstring'''





					return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname			,			**a_					)




			def 					snake_case__	(  self				:					List[str]					):
					'''simple docstring'''





					shutil.rmtree(self.tmpdirname					)




			def 					snake_case__	(  self				:					Dict					):
					'''simple docstring'''





					__UpperCAmelCase       :	int						=      self.get_tokenizer()
					__UpperCAmelCase       :	str						=      self.get_feature_extractor()

					__UpperCAmelCase       :	List[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					processor.save_pretrained(self.tmpdirname					)
					__UpperCAmelCase       :	List[str]						=      SpeechTaProcessor.from_pretrained(self.tmpdirname					)

					self.assertEqual(processor.tokenizer.get_vocab()			,			tokenizer.get_vocab()					)
					self.assertIsInstance(processor.tokenizer			,			a_					)

					self.assertEqual(processor.feature_extractor.to_json_string()			,			feature_extractor.to_json_string()					)
					self.assertIsInstance(processor.feature_extractor			,			a_					)




			def 					snake_case__	(  self				:					int					):
					'''simple docstring'''





					__UpperCAmelCase       :	Optional[int]						=      SpeechTaProcessor(tokenizer=self.get_tokenizer()			,			feature_extractor=self.get_feature_extractor()					)
					processor.save_pretrained(self.tmpdirname					)

					__UpperCAmelCase       :	Optional[Any]						=      self.get_tokenizer(bos_token='''(BOS)'''			,			eos_token='''(EOS)'''					)
					__UpperCAmelCase       :	List[Any]						=      self.get_feature_extractor(do_normalize=a_			,			padding_value=1.0					)

					__UpperCAmelCase       :	List[str]						=      SpeechTaProcessor.from_pretrained(
					    self.tmpdirname			,			bos_token='''(BOS)'''			,			eos_token='''(EOS)'''			,			do_normalize=a_			,			padding_value=1.0					)

					self.assertEqual(processor.tokenizer.get_vocab()			,			tokenizer_add_kwargs.get_vocab()					)
					self.assertIsInstance(processor.tokenizer			,			a_					)

					self.assertEqual(processor.feature_extractor.to_json_string()			,			feature_extractor_add_kwargs.to_json_string()					)
					self.assertIsInstance(processor.feature_extractor			,			a_					)




			def 					snake_case__	(  self				:					Union[str, Any]					):
					'''simple docstring'''





					__UpperCAmelCase       :	Optional[Any]						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Union[str, Any]						=      self.get_tokenizer()

					__UpperCAmelCase       :	List[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	List[Any]						=      floats_list((3, 10_00)					)

					__UpperCAmelCase       :	Tuple						=      feature_extractor(audio=a_			,			return_tensors='''np'''					)
					__UpperCAmelCase       :	List[str]						=      processor(audio=a_			,			return_tensors='''np'''					)

					for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()			,			input_processor[key].sum()			,			delta=1e-2					)




			def 					snake_case__	(  self				:					Optional[Any]					):
					'''simple docstring'''





					__UpperCAmelCase       :	List[Any]						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Dict						=      self.get_tokenizer()

					__UpperCAmelCase       :	Optional[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	Union[str, Any]						=      floats_list((3, 10_00)					)

					__UpperCAmelCase       :	Dict						=      feature_extractor(audio_target=a_			,			return_tensors='''np'''					)
					__UpperCAmelCase       :	str						=      processor(audio_target=a_			,			return_tensors='''np'''					)

					for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()			,			input_processor[key].sum()			,			delta=1e-2					)




			def 					snake_case__	(  self				:					Union[str, Any]					):
					'''simple docstring'''





					__UpperCAmelCase       :	Union[str, Any]						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Optional[int]						=      self.get_tokenizer()

					__UpperCAmelCase       :	Optional[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	List[str]						=      '''This is a test string'''

					__UpperCAmelCase       :	List[Any]						=      processor(text=a_					)
					__UpperCAmelCase       :	Optional[int]						=      tokenizer(a_					)

					for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]			,			encoded_processor[key]					)




			def 					snake_case__	(  self				:					List[str]					):
					'''simple docstring'''





					__UpperCAmelCase       :	Optional[Any]						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Optional[Any]						=      self.get_tokenizer()

					__UpperCAmelCase       :	List[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	List[str]						=      '''This is a test string'''

					__UpperCAmelCase       :	Optional[Any]						=      processor(text_target=a_					)
					__UpperCAmelCase       :	Optional[int]						=      tokenizer(a_					)

					for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]			,			encoded_processor[key]					)




			def 					snake_case__	(  self				:					List[str]					):
					'''simple docstring'''





					__UpperCAmelCase       :	int						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Union[str, Any]						=      self.get_tokenizer()

					__UpperCAmelCase       :	int						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	Optional[Any]						=      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

					__UpperCAmelCase       :	Optional[Any]						=      processor.batch_decode(a_					)
					__UpperCAmelCase       :	Any						=      tokenizer.batch_decode(a_					)

					self.assertListEqual(a_			,			a_					)




			def 					snake_case__	(  self				:					str					):
					'''simple docstring'''





					__UpperCAmelCase       :	str						=      self.get_feature_extractor()
					__UpperCAmelCase       :	str						=      self.get_tokenizer()

					__UpperCAmelCase       :	Optional[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					self.assertListEqual(
					    processor.model_input_names			,			feature_extractor.model_input_names			,			msg='''`processor` and `feature_extractor` model input names do not match'''			,			)





