



import unittest

from transformers import DebertaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    DebertaForMaskedLM,
							    DebertaForQuestionAnswering,
							    DebertaForSequenceClassification,
							    DebertaForTokenClassification,
							    DebertaModel,
							)
							from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST
class 					_snake_case      (       UpperCAmelCase_):




				def __init__(    self       :    int,       __lowercase       :    List[Any],       __lowercase       :    str=13,       __lowercase       :    str=7,       __lowercase       :    List[str]=True,       __lowercase       :    Tuple=True,       __lowercase       :    Dict=True,       __lowercase       :    str=True,       __lowercase       :    List[str]=99,       __lowercase       :    str=32,       __lowercase       :    int=5,       __lowercase       :    Optional[Any]=4,       __lowercase       :    Union[str, Any]=37,       __lowercase       :    Optional[Any]="gelu",       __lowercase       :    List[Any]=0.1,       __lowercase       :    str=0.1,       __lowercase       :    Optional[int]=512,       __lowercase       :    List[str]=16,       __lowercase       :    Tuple=2,       __lowercase       :    str=0.02,       __lowercase       :    Optional[int]=False,       __lowercase       :    Tuple=True,       __lowercase       :    str="None",       __lowercase       :    str=3,       __lowercase       :    List[Any]=4,       __lowercase       :    str=None,       ):
							lowercase__       	=					parent
							lowercase__       	=					batch_size
							lowercase__       	=					seq_length
							lowercase__       	=					is_training
							lowercase__       	=					use_input_mask
							lowercase__       	=					use_token_type_ids
							lowercase__       	=					use_labels
							lowercase__       	=					vocab_size
							lowercase__       	=					hidden_size
							lowercase__       	=					num_hidden_layers
							lowercase__       	=					num_attention_heads
							lowercase__       	=					intermediate_size
							lowercase__       	=					hidden_act
							lowercase__       	=					hidden_dropout_prob
							lowercase__       	=					attention_probs_dropout_prob
							lowercase__       	=					max_position_embeddings
							lowercase__       	=					type_vocab_size
							lowercase__       	=					type_sequence_label_size
							lowercase__       	=					initializer_range
							lowercase__       	=					num_labels
							lowercase__       	=					num_choices
							lowercase__       	=					relative_attention
							lowercase__       	=					position_biased_input
							lowercase__       	=					pos_att_type
							lowercase__       	=					scope




				def 				A__   (    self       :    Optional[Any]    ):
							lowercase__       	=					ids_tensor([self.batch_size, self.seq_length],       self.vocab_size    )

							lowercase__       	=					None
							if self.use_input_mask:
										lowercase__       	=					ids_tensor([self.batch_size, self.seq_length],       vocab_size=2    )

							lowercase__       	=					None
							if self.use_token_type_ids:
										lowercase__       	=					ids_tensor([self.batch_size, self.seq_length],       self.type_vocab_size    )

							lowercase__       	=					None
							lowercase__       	=					None
							lowercase__       	=					None
							if self.use_labels:
										lowercase__       	=					ids_tensor([self.batch_size],       self.type_sequence_label_size    )
										lowercase__       	=					ids_tensor([self.batch_size, self.seq_length],       self.num_labels    )
										lowercase__       	=					ids_tensor([self.batch_size],       self.num_choices    )

							lowercase__       	=					self.get_config()

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




				def 				A__   (    self       :    Optional[Any]    ):
							return DebertaConfig(
							    vocab_size=self.vocab_size,       hidden_size=self.hidden_size,       num_hidden_layers=self.num_hidden_layers,       num_attention_heads=self.num_attention_heads,       intermediate_size=self.intermediate_size,       hidden_act=self.hidden_act,       hidden_dropout_prob=self.hidden_dropout_prob,       attention_probs_dropout_prob=self.attention_probs_dropout_prob,       max_position_embeddings=self.max_position_embeddings,       type_vocab_size=self.type_vocab_size,       initializer_range=self.initializer_range,       relative_attention=self.relative_attention,       position_biased_input=self.position_biased_input,       pos_att_type=self.pos_att_type,       )




				def 				A__   (    self       :    Any    ):
							lowercase__       	=					self.get_config()
							lowercase__       	=					300
							return config




				def 				A__   (    self       :    Optional[Any],       __lowercase       :    Optional[Any]    ):
							self.parent.assertListEqual(list(result.loss.size()    ),       []    )




				def 				A__   (    self       :    int,       __lowercase       :    Tuple,       __lowercase       :    Any,       __lowercase       :    Optional[Any],       __lowercase       :    Dict,       __lowercase       :    str,       __lowercase       :    int,       __lowercase       :    Dict    ):
							lowercase__       	=					DebertaModel(config=__lowerCamelCase    )
							model.to(__lowerCamelCase    )
							model.eval()
							lowercase__       	=					model(__lowerCamelCase,       attention_mask=__lowerCamelCase,       token_type_ids=__lowerCamelCase    )[0]
							lowercase__       	=					model(__lowerCamelCase,       token_type_ids=__lowerCamelCase    )[0]
							lowercase__       	=					model(__lowerCamelCase    )[0]

							self.parent.assertListEqual(list(sequence_output.size()    ),       [self.batch_size, self.seq_length, self.hidden_size]    )




				def 				A__   (    self       :    Any,       __lowercase       :    int,       __lowercase       :    int,       __lowercase       :    List[str],       __lowercase       :    Tuple,       __lowercase       :    int,       __lowercase       :    Dict,       __lowercase       :    List[str]    ):
							lowercase__       	=					DebertaForMaskedLM(config=__lowerCamelCase    )
							model.to(__lowerCamelCase    )
							model.eval()
							lowercase__       	=					model(__lowerCamelCase,       attention_mask=__lowerCamelCase,       token_type_ids=__lowerCamelCase,       labels=__lowerCamelCase    )

							self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.seq_length, self.vocab_size)    )




				def 				A__   (    self       :    Union[str, Any],       __lowercase       :    str,       __lowercase       :    Optional[int],       __lowercase       :    List[str],       __lowercase       :    Optional[int],       __lowercase       :    Union[str, Any],       __lowercase       :    List[Any],       __lowercase       :    Union[str, Any]    ):
							lowercase__       	=					self.num_labels
							lowercase__       	=					DebertaForSequenceClassification(__lowerCamelCase    )
							model.to(__lowerCamelCase    )
							model.eval()
							lowercase__       	=					model(__lowerCamelCase,       attention_mask=__lowerCamelCase,       token_type_ids=__lowerCamelCase,       labels=__lowerCamelCase    )
							self.parent.assertListEqual(list(result.logits.size()    ),       [self.batch_size, self.num_labels]    )
							self.check_loss_output(__lowerCamelCase    )




				def 				A__   (    self       :    Union[str, Any],       __lowercase       :    str,       __lowercase       :    List[Any],       __lowercase       :    List[Any],       __lowercase       :    str,       __lowercase       :    Tuple,       __lowercase       :    Optional[int],       __lowercase       :    Dict    ):
							lowercase__       	=					self.num_labels
							lowercase__       	=					DebertaForTokenClassification(config=__lowerCamelCase    )
							model.to(__lowerCamelCase    )
							model.eval()
							lowercase__       	=					model(__lowerCamelCase,       attention_mask=__lowerCamelCase,       token_type_ids=__lowerCamelCase,       labels=__lowerCamelCase    )
							self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.seq_length, self.num_labels)    )




				def 				A__   (    self       :    Tuple,       __lowercase       :    int,       __lowercase       :    Any,       __lowercase       :    List[str],       __lowercase       :    Union[str, Any],       __lowercase       :    Dict,       __lowercase       :    int,       __lowercase       :    Dict    ):
							lowercase__       	=					DebertaForQuestionAnswering(config=__lowerCamelCase    )
							model.to(__lowerCamelCase    )
							model.eval()
							lowercase__       	=					model(
							    __lowerCamelCase,       attention_mask=__lowerCamelCase,       token_type_ids=__lowerCamelCase,       start_positions=__lowerCamelCase,       end_positions=__lowerCamelCase,       )
							self.parent.assertEqual(result.start_logits.shape,       (self.batch_size, self.seq_length)    )
							self.parent.assertEqual(result.end_logits.shape,       (self.batch_size, self.seq_length)    )




				def 				A__   (    self       :    int    ):
							lowercase__       	=					self.prepare_config_and_inputs()
							(
							    (
							    lowercase__      
							)	,							(
							    lowercase__      
							)	,							(
							    lowercase__      
							)	,							(
							    lowercase__      
							)	,							(
							    lowercase__      
							)	,							(
							    lowercase__      
							)	,							(
							    lowercase__      
							)	,							      
							)       	=					config_and_inputs
							lowercase__       	=					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
							return config, inputs_dict
@require_torch
class 					_snake_case      (       UpperCAmelCase_     ,						UpperCAmelCase_     ,						unittest.TestCase):
				UpperCamelCase__					:       int  		=(
				    (
				        DebertaModel,
				        DebertaForMaskedLM,
				        DebertaForSequenceClassification,
				        DebertaForTokenClassification,
				        DebertaForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				UpperCamelCase__					:       Optional[int]  		=(
				    {
				        """feature-extraction""": DebertaModel,
				        """fill-mask""": DebertaForMaskedLM,
				        """question-answering""": DebertaForQuestionAnswering,
				        """text-classification""": DebertaForSequenceClassification,
				        """token-classification""": DebertaForTokenClassification,
				        """zero-shot""": DebertaForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)

				UpperCamelCase__					:       str  		=True
				UpperCamelCase__					:       int  		=False
				UpperCamelCase__					:       List[Any]  		=False
				UpperCamelCase__					:       Dict  		=False
				UpperCamelCase__					:       List[str]  		=False




				def 				A__   (    self       :    Union[str, Any]    ):
							lowercase__       	=					DebertaModelTester(self    )
							lowercase__       	=					ConfigTester(self,       config_class=__lowerCamelCase,       hidden_size=37    )




				def 				A__   (    self       :    Optional[int]    ):
							self.config_tester.run_common_tests()




				def 				A__   (    self       :    Any    ):
							lowercase__       	=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_deberta_model(*__lowerCamelCase    )




				def 				A__   (    self       :    int    ):
							lowercase__       	=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_deberta_for_sequence_classification(*__lowerCamelCase    )




				def 				A__   (    self       :    Dict    ):
							lowercase__       	=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_deberta_for_masked_lm(*__lowerCamelCase    )




				def 				A__   (    self       :    Optional[int]    ):
							lowercase__       	=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_deberta_for_question_answering(*__lowerCamelCase    )




				def 				A__   (    self       :    Optional[Any]    ):
							lowercase__       	=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_deberta_for_token_classification(*__lowerCamelCase    )




				@slow
				def 				A__   (    self       :    int    ):




							for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowercase__       	=					DebertaModel.from_pretrained(__lowerCamelCase    )
										self.assertIsNotNone(__lowerCamelCase    )
@require_torch
@require_sentencepiece
@require_tokenizers
class 					_snake_case      (       unittest.TestCase):




				@unittest.skip(reason="Model not available yet"    )
				def 				A__   (    self       :    List[str]    ):
							pass




				@slow
				def 				A__   (    self       :    Any    ):
							lowercase__       	=					DebertaModel.from_pretrained("microsoft/deberta-base"    )

							lowercase__       	=					torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]    )
							lowercase__       	=					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]    )
							with torch.no_grad():
										lowercase__       	=					model(__lowerCamelCase,       attention_mask=__lowerCamelCase    )[0]
							# compare the actual values for a slice.
							lowercase__       	=					torch.tensor(
							    [[[-0.5986, -0.8055, -0.8462], [1.4484, -0.9348, -0.8059], [0.3123, 0.0032, -1.4131]]]    )
							self.assertTrue(torch.allclose(output[:, 1:4, 1:4],       __lowerCamelCase,       atol=1e-4    ),       F'''{output[:, 1:4, 1:4]}'''    )











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_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		DownBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




	def    UpperCAmelCase			(						self							:     Optional[Any]   )       -> Tuple:

			'''simple docstring'''




			__lowercase											=     [-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		ResnetDownsampleBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




	def    UpperCAmelCase			(						self							:     str   )       -> int:

			'''simple docstring'''




			__lowercase											=     [0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		AttnDownBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




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

			'''simple docstring'''




			__lowercase											=     [0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		CrossAttnDownBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




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

			'''simple docstring'''




			__lowercase						,      __lowercase											=     super().prepare_init_args_and_inputs_for_common()
			__lowercase											=     32
			return init_dict, inputs_dict






	def    UpperCAmelCase			(						self							:     Any   )       -> int:

			'''simple docstring'''




			__lowercase											=     [0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		SimpleCrossAttnDownBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_encoder_hidden_states=__lowerCamelCase   )




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

			'''simple docstring'''




			__lowercase						,      __lowercase											=     super().prepare_init_args_and_inputs_for_common()
			__lowercase											=     32
			return init_dict, inputs_dict






	@unittest.skipIf(torch_device == 'mps'					,      'MPS result is not consistent'   )
	def    UpperCAmelCase			(						self							:     Dict   )       -> Optional[int]:

			'''simple docstring'''




			__lowercase											=     [0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		SkipDownBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_skip_sample=__lowerCamelCase   )






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

			'''simple docstring'''




			__lowercase											=     [-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		AttnSkipDownBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_skip_sample=__lowerCamelCase   )






	def    UpperCAmelCase			(						self							:     Tuple   )       -> Optional[Any]:

			'''simple docstring'''




			__lowercase											=     [0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		DownEncoderBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_temb=__lowerCamelCase   )




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

			'''simple docstring'''




			__lowercase											=     {
			    'in_channels': 32,
			    'out_channels': 32,
			}
			__lowercase											=     self.dummy_input
			return init_dict, inputs_dict






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

			'''simple docstring'''




			__lowercase											=     [1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		AttnDownEncoderBlockaD  # noqa F405
	__UpperCamelCase   =		'''down'''




	@property
	def    UpperCAmelCase			(						self							:     int   )       -> str:

			'''simple docstring'''




			return super().get_dummy_input(include_temb=__lowerCamelCase   )




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

			'''simple docstring'''




			__lowercase											=     {
			    'in_channels': 32,
			    'out_channels': 32,
			}
			__lowercase											=     self.dummy_input
			return init_dict, inputs_dict






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

			'''simple docstring'''




			__lowercase											=     [0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		UNetMidBlockaD  # noqa F405
	__UpperCamelCase   =		'''mid'''




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

			'''simple docstring'''




			__lowercase											=     {
			    'in_channels': 32,
			    'temb_channels': 128,
			}
			__lowercase											=     self.dummy_input
			return init_dict, inputs_dict






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

			'''simple docstring'''




			__lowercase											=     [-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		UNetMidBlockaDCrossAttn  # noqa F405
	__UpperCamelCase   =		'''mid'''




	def    UpperCAmelCase			(						self							:     int   )       -> Tuple:

			'''simple docstring'''




			__lowercase						,      __lowercase											=     super().prepare_init_args_and_inputs_for_common()
			__lowercase											=     32
			return init_dict, inputs_dict






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

			'''simple docstring'''




			__lowercase											=     [0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		UNetMidBlockaDSimpleCrossAttn  # noqa F405
	__UpperCamelCase   =		'''mid'''




	@property
	def    UpperCAmelCase			(						self							:     str   )       -> Tuple:

			'''simple docstring'''




			return super().get_dummy_input(include_encoder_hidden_states=__lowerCamelCase   )




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

			'''simple docstring'''




			__lowercase						,      __lowercase											=     super().prepare_init_args_and_inputs_for_common()
			__lowercase											=     32
			return init_dict, inputs_dict






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

			'''simple docstring'''




			__lowercase											=     [0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		UpBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_res_hidden_states_tuple=__lowerCamelCase   )






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

			'''simple docstring'''




			__lowercase											=     [-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		ResnetUpsampleBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_res_hidden_states_tuple=__lowerCamelCase   )






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

			'''simple docstring'''




			__lowercase											=     [0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		CrossAttnUpBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_res_hidden_states_tuple=__lowerCamelCase   )




	def    UpperCAmelCase			(						self							:     Any   )       -> Tuple:

			'''simple docstring'''




			__lowercase						,      __lowercase											=     super().prepare_init_args_and_inputs_for_common()
			__lowercase											=     32
			return init_dict, inputs_dict






	def    UpperCAmelCase			(						self							:     Dict   )       -> int:

			'''simple docstring'''




			__lowercase											=     [-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		SimpleCrossAttnUpBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_res_hidden_states_tuple=__lowerCamelCase					,      include_encoder_hidden_states=__lowerCamelCase   )




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

			'''simple docstring'''




			__lowercase						,      __lowercase											=     super().prepare_init_args_and_inputs_for_common()
			__lowercase											=     32
			return init_dict, inputs_dict






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

			'''simple docstring'''




			__lowercase											=     [0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		AttnUpBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_res_hidden_states_tuple=__lowerCamelCase   )






	@unittest.skipIf(torch_device == 'mps'					,      'MPS result is not consistent'   )
	def    UpperCAmelCase			(						self							:     int   )       -> str:

			'''simple docstring'''




			__lowercase											=     [0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		SkipUpBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




	@property
	def    UpperCAmelCase			(						self							:     int   )       -> str:

			'''simple docstring'''




			return super().get_dummy_input(include_res_hidden_states_tuple=__lowerCamelCase   )






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

			'''simple docstring'''




			__lowercase											=     [-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		AttnSkipUpBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




	@property
	def    UpperCAmelCase			(						self							:     int   )       -> Any:

			'''simple docstring'''




			return super().get_dummy_input(include_res_hidden_states_tuple=__lowerCamelCase   )






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

			'''simple docstring'''




			__lowercase											=     [0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		UpDecoderBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




	@property
	def    UpperCAmelCase			(						self							:     Tuple   )       -> Any:

			'''simple docstring'''




			return super().get_dummy_input(include_temb=__lowerCamelCase   )




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

			'''simple docstring'''




			__lowercase											=     {'in_channels': 32, 'out_channels': 32}

			__lowercase											=     self.dummy_input
			return init_dict, inputs_dict






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

			'''simple docstring'''




			__lowercase											=     [0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
			super().test_output(__lowerCamelCase   )





class 		snake_case_   (							UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		AttnUpDecoderBlockaD  # noqa F405
	__UpperCamelCase   =		'''up'''




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

			'''simple docstring'''




			return super().get_dummy_input(include_temb=__lowerCamelCase   )




	def    UpperCAmelCase			(						self							:     Dict   )       -> Dict:

			'''simple docstring'''




			__lowercase											=     {'in_channels': 32, 'out_channels': 32}

			__lowercase											=     self.dummy_input
			return init_dict, inputs_dict






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

			'''simple docstring'''




			__lowercase											=     [0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
			super().test_output(__lowerCamelCase   )




