



"""simple docstring"""







import gc
import inspect
import unittest

import torch
from parameterized import parameterized

from diffusers import PriorTransformer
from diffusers.utils import floats_tensor, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin


enable_full_determinism()
class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Union[str, Any]   	=				PriorTransformer
		lowerCAmelCase			:					int   	=				"hidden_states"







		@property
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Optional[Any]:






				"""simple docstring"""



				lowercase__   :    Dict				=			4
				lowercase__   :    List[Any]				=			8
				lowercase__   :    Any				=			7

				lowercase__   :    int				=			floats_tensor((batch_size, embedding_dim)						).to(_snake_case						)

				lowercase__   :    Any				=			floats_tensor((batch_size, embedding_dim)						).to(_snake_case						)
				lowercase__   :    int				=			floats_tensor((batch_size, num_embeddings, embedding_dim)						).to(_snake_case						)

				return {
				    "hidden_states": hidden_states,
				    "timestep": 2,
				    "proj_embedding": proj_embedding,
				    "encoder_hidden_states": encoder_hidden_states,
				}







		def 					UpperCAmelCase    (	self						:  str			,_snake_case						:  str=0						)					->		Optional[Any]:






				"""simple docstring"""



				torch.manual_seed(_snake_case						)
				lowercase__   :    Optional[Any]				=			4
				lowercase__   :    Optional[int]				=			8
				lowercase__   :    Any				=			7

				lowercase__   :    str				=			torch.randn((batch_size, embedding_dim)						).to(_snake_case						)

				lowercase__   :    List[Any]				=			torch.randn((batch_size, embedding_dim)						).to(_snake_case						)
				lowercase__   :    Dict				=			torch.randn((batch_size, num_embeddings, embedding_dim)						).to(_snake_case						)

				return {
				    "hidden_states": hidden_states,
				    "timestep": 2,
				    "proj_embedding": proj_embedding,
				    "encoder_hidden_states": encoder_hidden_states,
				}







		@property
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		List[Any]:






				"""simple docstring"""



				return (4, 8)







		@property
		def 					UpperCAmelCase    (	self						:  Any						)					->		List[str]:






				"""simple docstring"""



				return (4, 8)







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






				"""simple docstring"""



				lowercase__   :    Tuple				=			{
				    '''num_attention_heads''': 2,
				    '''attention_head_dim''': 4,
				    '''num_layers''': 2,
				    '''embedding_dim''': 8,
				    '''num_embeddings''': 7,
				    '''additional_embeddings''': 4,
				}
				lowercase__   :    Any				=			self.dummy_input
				return init_dict, inputs_dict







		def 					UpperCAmelCase    (	self						:  int						)					->		int:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Tuple				=			PriorTransformer.from_pretrained(
				    '''hf-internal-testing/prior-dummy'''			,output_loading_info=_snake_case						)
				self.assertIsNotNone(_snake_case						)
				self.assertEqual(len(loading_info['''missing_keys''']						)			,0						)

				model.to(_snake_case						)
				lowercase__   :    Optional[Any]				=			model(**self.dummy_input						)[0]

				assert hidden_states is not None, "Make sure output is not None"







		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Dict:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Any				=			self.prepare_init_args_and_inputs_for_common()

				lowercase__   :    List[str]				=			self.model_class(**_snake_case						)
				lowercase__   :    Optional[Any]				=			inspect.signature(model.forward						)
				# signature.parameters is an OrderedDict => so arg_names order is deterministic
				lowercase__   :    Optional[Any]				=			[*signature.parameters.keys()]

				lowercase__   :    int				=			['''hidden_states''', '''timestep''']
				self.assertListEqual(arg_names[:2]			,_snake_case						)







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






				"""simple docstring"""



				lowercase__   :    Any				=			PriorTransformer.from_pretrained('''hf-internal-testing/prior-dummy'''						)
				lowercase__   :    Dict				=			model.to(_snake_case						)

				if hasattr(_snake_case			,'''set_default_attn_processor'''						):
						model.set_default_attn_processor()

				lowercase__   :    Dict				=			self.get_dummy_seed_input()

				with torch.no_grad():
						lowercase__   :    Optional[int]				=			model(**_snake_case						)[0]

				lowercase__   :    str				=			output[0, :5].flatten().cpu()
				print(_snake_case						)

				# Since the VAE Gaussian prior's generator is seeded on the appropriate device,
				# the expected output slices are not the same for CPU and GPU.
				lowercase__   :    Optional[Any]				=			torch.tensor([-1.3436, -0.2870, 0.7538, 0.4368, -0.0239]						)
				self.assertTrue(torch_all_close(_snake_case			,_snake_case			,rtol=1e-2						)						)





@slow
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		def 					UpperCAmelCase    (	self						:  Dict			,_snake_case						:  List[str]=1			,_snake_case						:  Tuple=768			,_snake_case						:  List[Any]=77			,_snake_case						:  Optional[Any]=0						)					->		List[Any]:






				"""simple docstring"""



				torch.manual_seed(_snake_case						)
				lowercase__   :    Tuple				=			batch_size
				lowercase__   :    List[str]				=			embedding_dim
				lowercase__   :    Tuple				=			num_embeddings

				lowercase__   :    int				=			torch.randn((batch_size, embedding_dim)						).to(_snake_case						)

				lowercase__   :    str				=			torch.randn((batch_size, embedding_dim)						).to(_snake_case						)
				lowercase__   :    List[str]				=			torch.randn((batch_size, num_embeddings, embedding_dim)						).to(_snake_case						)

				return {
				    "hidden_states": hidden_states,
				    "timestep": 2,
				    "proj_embedding": proj_embedding,
				    "encoder_hidden_states": encoder_hidden_states,
				}







		def 					UpperCAmelCase    (	self						:  int						)					->		List[Any]:






				"""simple docstring"""



				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()







		@parameterized.expand(
		    [
		        # fmt: off
		        [13, [-0.5861,  0.1283, -0.0931,  0.0882,  0.4476,  0.1329, -0.0498,  0.0640]],
		        [37, [-0.4913,  0.0110, -0.0483,  0.0541,  0.4954, -0.0170,  0.0354,  0.1651]],
		        # fmt: on
		    ]						)
		def 					UpperCAmelCase    (	self						:  Optional[Any]			,_snake_case						:  Optional[Any]			,_snake_case						:  Optional[Any]						)					->		int:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			PriorTransformer.from_pretrained('''kandinsky-community/kandinsky-2-1-prior'''			,subfolder='''prior'''						)
				model.to(_snake_case						)
				lowercase__   :    List[str]				=			self.get_dummy_seed_input(seed=_snake_case						)

				with torch.no_grad():
						lowercase__   :    List[str]				=			model(**_snake_case						)[0]

				assert list(sample.shape						) == [1, 768]

				lowercase__   :    List[str]				=			sample[0, :8].flatten().cpu()
				print(_snake_case						)
				lowercase__   :    Optional[Any]				=			torch.tensor(_snake_case						)

				assert torch_all_close(_snake_case			,_snake_case			,atol=1e-3						)





'''simple docstring'''




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 			UpperCamelCase_ :





	def __init__(  self		,		A		,		A=12		,		A=7		,		A=True		,		A=True		,		A=True		,		A=99		,		A=32		,		A=32		,		A=2		,		A=4		,		A=37		,		A=0.1		,		A=0.1		,		A=512		,		A=0.0_2		,		A=0		,		A=None		,		)			->			Any:
								UpperCAmelCase     :		Optional[Any]							     =		parent
								UpperCAmelCase     :		str							     =		batch_size
								UpperCAmelCase     :		Union[str, Any]							     =		seq_length
								UpperCAmelCase     :		Optional[Any]							     =		is_training
								UpperCAmelCase     :		int							     =		use_input_mask
								UpperCAmelCase     :		List[Any]							     =		use_labels
								UpperCAmelCase     :		Dict							     =		vocab_size
								UpperCAmelCase     :		str							     =		hidden_size
								UpperCAmelCase     :		List[Any]							     =		projection_dim
								UpperCAmelCase     :		Tuple							     =		num_hidden_layers
								UpperCAmelCase     :		Dict							     =		num_attention_heads
								UpperCAmelCase     :		Optional[Any]							     =		intermediate_size
								UpperCAmelCase     :		Any							     =		dropout
								UpperCAmelCase     :		List[Any]							     =		attention_dropout
								UpperCAmelCase     :		Optional[Any]							     =		max_position_embeddings
								UpperCAmelCase     :		Tuple							     =		initializer_range
								UpperCAmelCase     :		Optional[Any]							     =		scope
								UpperCAmelCase     :		Union[str, Any]							     =		bos_token_id





	def  _lowercase(  self    )			->			Tuple:
								UpperCAmelCase     :		Optional[int]							     =		ids_tensor([self.batch_size, self.seq_length]		,		self.vocab_size    )

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

								if input_mask is not None:
															UpperCAmelCase     :		Tuple							     =		input_mask.numpy()
															UpperCAmelCase     ,     UpperCAmelCase     :		int							     =		input_mask.shape
															UpperCAmelCase     :		Optional[int]							     =		np.random.randint(1		,		seq_length - 1		,		size=(batch_size,)    )
															for batch_idx, start_index in enumerate(A    ):
																						UpperCAmelCase     :		Tuple							     =		1
																						UpperCAmelCase     :		Optional[Any]							     =		0

								UpperCAmelCase     :		int							     =		self.get_config()

								return config, input_ids, tf.convert_to_tensor(A    )





	def  _lowercase(  self    )			->			int:
								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  _lowercase(  self		,		A		,		A		,		A    )			->			Union[str, Any]:
								UpperCAmelCase     :		int							     =		TFBlipTextModel(config=A    )
								UpperCAmelCase     :		Union[str, Any]							     =		model(A		,		attention_mask=A		,		training=A    )
								UpperCAmelCase     :		int							     =		model(A		,		training=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  _lowercase(  self    )			->			Optional[int]:
								UpperCAmelCase     :		Dict							     =		self.prepare_config_and_inputs()
								UpperCAmelCase     ,     UpperCAmelCase     ,     UpperCAmelCase     :		Any							     =		config_and_inputs
								UpperCAmelCase     :		Optional[Any]							     =		{"""input_ids""": input_ids, """attention_mask""": input_mask}
								return config, inputs_dict




@require_tf
class 			UpperCamelCase_ (							__magic_name__      ,     unittest.TestCase			):
	lowercase          = (TFBlipTextModel,) if is_tf_available() else ()
	lowercase          = False
	lowercase          = False
	lowercase          = False





	def  _lowercase(  self    )			->			int:
								UpperCAmelCase     :		Union[str, Any]							     =		BlipTextModelTester(self    )
								UpperCAmelCase     :		List[str]							     =		ConfigTester(self		,		config_class=A		,		hidden_size=37    )





	def  _lowercase(  self    )			->			Tuple:
								self.config_tester.run_common_tests()





	def  _lowercase(  self    )			->			List[Any]:
								UpperCAmelCase     :		List[Any]							     =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*A    )





	def  _lowercase(  self    )			->			List[str]:
								pass





	def  _lowercase(  self    )			->			Optional[int]:
								pass





	@unittest.skip(reason="""Blip does not use inputs_embeds"""    )
	def  _lowercase(  self    )			->			Union[str, Any]:
								pass





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





	@unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""    )
	def  _lowercase(  self    )			->			Dict:
								pass





	@slow
	def  _lowercase(  self    )			->			Dict:
								for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															UpperCAmelCase     :		Any							     =		TFBlipTextModel.from_pretrained(A    )
															self.assertIsNotNone(A    )






	def  _lowercase(  self		,		A=True    )			->			str:
								super().test_pt_tf_model_equivalence(allow_missing_keys=A    )

