





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





       '''simple docstring'''







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




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						int			  =						ids_tensor([self.batch_size, self.seq_length]							,    self.vocab_size		)

         __snake_case:						int			  =						None
         if self.use_input_mask:
           __snake_case:						Tuple			  =						random_attention_mask([self.batch_size, self.seq_length]		)

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

         __snake_case:						str			  =						self.get_config()

         return config, input_ids, tf.convert_to_tensor(A		)




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







@require_tf
class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					(TFBlipTextModel,) if is_tf_available() else ()
       lowerCAmelCase__						=					False
       lowerCAmelCase__						=					False
       lowerCAmelCase__						=					False




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Optional[int]			  =						BlipTextModelTester(self		)
         __snake_case:						str			  =						ConfigTester(self							,    config_class=A							,    hidden_size=37		)




       def 							UpperCAmelCase__			(  self			:   int		):
         self.config_tester.run_common_tests()




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						Any			  =						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A		)




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         pass




       def 							UpperCAmelCase__			(  self			:   Any		):
         pass




       @unittest.skip(reason="""Blip does not use inputs_embeds"""		)
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         pass




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




       @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""		)
       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         pass




       @slow
       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __snake_case:						Tuple			  =						TFBlipTextModel.from_pretrained(A		)
           self.assertIsNotNone(A		)






       def 							UpperCAmelCase__			(  self			:   Optional[int]							,    A			:   str=True		):
         super().test_pt_tf_model_equivalence(allow_missing_keys=A		)













import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					DownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						str			  =						[-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					ResnetDownsampleBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Union[str, Any]			  =						[0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Union[str, Any]			  =						[0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					CrossAttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case  ,       __snake_case:						List[str]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						List[Any]			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						[0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SimpleCrossAttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case  ,       __snake_case:						Union[str, Any]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						Optional[Any]			  =						32
         return init_dict, inputs_dict






       @unittest.skipIf(torch_device == """mps"""							,    """MPS result is not consistent"""		)
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Optional[Any]			  =						[0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SkipDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Any		):
         return super().get_dummy_input(include_skip_sample=A		)






       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Optional[Any]			  =						[-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnSkipDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         return super().get_dummy_input(include_skip_sample=A		)






       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						str			  =						[0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					DownEncoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						str			  =						{
             """in_channels""": 32,
             """out_channels""": 32,
         }
         __snake_case:						Dict			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Optional[int]			  =						[1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnDownEncoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Optional[Any]			  =						{
             """in_channels""": 32,
             """out_channels""": 32,
         }
         __snake_case:						Tuple			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Dict			  =						[0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaD  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Optional[int]			  =						{
             """in_channels""": 32,
             """temb_channels""": 128,
         }
         __snake_case:						List[str]			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Tuple			  =						[-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaDCrossAttn  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						int			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						int			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						[0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaDSimpleCrossAttn  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						Any			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						str			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						[0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Tuple		):
         __snake_case:						Tuple			  =						[-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					ResnetUpsampleBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						int			  =						[0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					CrossAttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case  ,       __snake_case:						Any			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						Optional[int]			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						List[Any]			  =						[-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SimpleCrossAttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A							,    include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case  ,       __snake_case:						Optional[Any]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						str			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Union[str, Any]			  =						[0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   int		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       @unittest.skipIf(torch_device == """mps"""							,    """MPS result is not consistent"""		)
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						Optional[Any]			  =						[0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SkipUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   str		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[int]			  =						[-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnSkipUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   str		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						[0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UpDecoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Union[str, Any]			  =						{"""in_channels""": 32, """out_channels""": 32}

         __snake_case:						Dict			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Dict			  =						[0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnUpDecoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						{"""in_channels""": 32, """out_channels""": 32}

         __snake_case:						Any			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						Any			  =						[0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
         super().test_output(A		)






