



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    _lowercase :
				'''simple docstring'''







				def __init__(			self  ,			snake_case__  ,			snake_case__=12  ,			snake_case__=7  ,			snake_case__=True  ,			snake_case__=True  ,			snake_case__=True  ,			snake_case__=99  ,			snake_case__=32  ,			snake_case__=32  ,			snake_case__=5  ,			snake_case__=4  ,			snake_case__=37  ,			snake_case__=0.1  ,			snake_case__=0.1  ,			snake_case__=512  ,			snake_case__=0.02  ,			snake_case__=0  ,			snake_case__=None  ,			):

									'''simple docstring'''


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

									'''simple docstring'''


									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_	,     UpperCamelCase_			= input_mask.shape
														UpperCamelCase_			= np.random.randint(1  ,			seq_length - 1  ,			size=(batch_size,)     )
														for batch_idx, start_index in enumerate(snake_case__     ):
																			UpperCamelCase_			= 1
																			UpperCamelCase_			= 0

									UpperCamelCase_			= self.get_config()

									return config, input_ids, input_mask

				def    _lowerCamelCase       (			self     ):

									'''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    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= BlipTextModel(config=snake_case__     )
									model.to(snake_case__     )
									model.eval()
									with torch.no_grad():
														UpperCamelCase_			= model(snake_case__  ,			attention_mask=snake_case__     )
														UpperCamelCase_			= model(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    _lowerCamelCase       (			self     ):

									'''simple docstring'''


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




@require_torch
class    _lowercase (a_   , unittest.TestCase   ):
				'''simple docstring'''







				lowercase__     =    (BlipTextModel,) if is_torch_available() else ()
				lowercase__     =    False
				lowercase__     =    False
				lowercase__     =    False

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= BlipTextModelTester(self     )
									UpperCamelCase_			= ConfigTester(self  ,			config_class=snake_case__  ,			hidden_size=37     )

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									self.config_tester.run_common_tests()

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case__     )

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									pass

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									pass

				@unittest.skip(reason="Blip does not use inputs_embeds"     )
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									pass

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

									'''simple docstring'''


									pass

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

									'''simple docstring'''


									pass

				@slow
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


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

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									super().test_pt_tf_model_equivalence(allow_missing_keys=snake_case__     )



"""simple docstring"""





def 							_lowerCAmelCase   (    UpperCAmelCase  :				int   ,				UpperCAmelCase  :				int   ,				UpperCAmelCase  :				int					):


					'''simple docstring'''






					if power < 0:
										return -1
					base %= mod
					UpperCamelCase__		:     Any								=1

					while power > 0:
										if power & 1:
															UpperCamelCase__		:     Optional[Any]								=(result * base) % mod
										UpperCamelCase__		:     Union[str, Any]								=power >> 1
										UpperCamelCase__		:     Union[str, Any]								=(base * base) % mod

					return result



def 							_lowerCAmelCase   (    ):


					'''simple docstring'''






					print(modular_exponential(3   ,				200   ,				13					)					)


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				main()


