



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 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Any						  =				DownBlockaD  # noqa F405
	a__ :   Union[str, Any]						  =				"down"




	def     _SCREAMING_SNAKE_CASE						(      self      :		int	)     ->					Union[str, Any]:
							UpperCAmelCase_=  [-0.0_232, -0.9_869, 0.8_054, -0.0_637, -0.1_688, -1.4_264, 0.4_470, -1.3_394, 0.0_904]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Dict						  =				ResnetDownsampleBlockaD  # noqa F405
	a__ :   Optional[int]						  =				"down"




	def     _SCREAMING_SNAKE_CASE						(      self      :		Any	)     ->					Union[str, Any]:
							UpperCAmelCase_=  [0.0_710, 0.2_410, -0.7_320, -1.0_757, -1.1_343, 0.3_540, -0.0_133, -0.2_576, 0.0_948]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Dict						  =				AttnDownBlockaD  # noqa F405
	a__ :   str						  =				"down"




	def     _SCREAMING_SNAKE_CASE						(      self      :		Union[str, Any]	)     ->					Optional[int]:
							UpperCAmelCase_=  [0.0_636, 0.8_964, -0.6_234, -1.0_131, 0.0_844, 0.4_935, 0.3_437, 0.0_911, -0.2_957]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Tuple						  =				CrossAttnDownBlockaD  # noqa F405
	a__ :   Any						  =				"down"




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]	)     ->					Tuple:
							UpperCAmelCase_,  UpperCAmelCase_=  super().prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_=  32
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		List[str]	)     ->					Tuple:
							UpperCAmelCase_=  [0.2_238, -0.7_396, -0.2_255, -0.3_829, 0.1_925, 1.1_665, 0.0_603, -0.7_295, 0.1_983]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   int						  =				SimpleCrossAttnDownBlockaD  # noqa F405
	a__ :   str						  =				"down"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		List[str]	)     ->					List[Any]:
							return super().get_dummy_input(include_encoder_hidden_states=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Union[str, Any]	)     ->					Dict:
							UpperCAmelCase_,  UpperCAmelCase_=  super().prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_=  32
							return init_dict, inputs_dict




	@unittest.skipIf(torch_device == """mps"""		,    """MPS result is not consistent"""	)
	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple	)     ->					Dict:
							UpperCAmelCase_=  [0.7_921, -0.0_992, -0.1_962, -0.7_695, -0.4_242, 0.7_804, 0.4_737, 0.2_765, 0.3_338]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Optional[Any]						  =				SkipDownBlockaD  # noqa F405
	a__ :   Optional[int]						  =				"down"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[int]	)     ->					List[Any]:
							return super().get_dummy_input(include_skip_sample=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]	)     ->					Any:
							UpperCAmelCase_=  [-0.0_845, -0.2_087, -0.2_465, 0.0_971, 0.1_900, -0.0_484, 0.2_664, 0.4_179, 0.5_069]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   List[Any]						  =				AttnSkipDownBlockaD  # noqa F405
	a__ :   int						  =				"down"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Dict	)     ->					Dict:
							return super().get_dummy_input(include_skip_sample=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Dict	)     ->					Dict:
							UpperCAmelCase_=  [0.5_539, 0.1_609, 0.4_924, 0.0_537, -0.1_995, 0.4_050, 0.0_979, -0.2_721, -0.0_642]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   str						  =				DownEncoderBlockaD  # noqa F405
	a__ :   Dict						  =				"down"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		List[Any]	)     ->					str:
							return super().get_dummy_input(include_temb=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		List[str]	)     ->					List[Any]:
							UpperCAmelCase_=  {
							    """in_channels""": 32,
							    """out_channels""": 32,
							}
							UpperCAmelCase_=  self.dummy_input
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		int	)     ->					Any:
							UpperCAmelCase_=  [1.1_102, 0.5_302, 0.4_872, -0.0_023, -0.8_042, 0.0_483, -0.3_489, -0.5_632, 0.7_626]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Optional[int]						  =				AttnDownEncoderBlockaD  # noqa F405
	a__ :   str						  =				"down"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]	)     ->					Optional[Any]:
							return super().get_dummy_input(include_temb=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		int	)     ->					Union[str, Any]:
							UpperCAmelCase_=  {
							    """in_channels""": 32,
							    """out_channels""": 32,
							}
							UpperCAmelCase_=  self.dummy_input
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple	)     ->					Optional[int]:
							UpperCAmelCase_=  [0.8_966, -0.1_486, 0.8_568, 0.8_141, -0.9_046, -0.1_342, -0.0_972, -0.7_417, 0.1_538]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Union[str, Any]						  =				UNetMidBlockaD  # noqa F405
	a__ :   Optional[Any]						  =				"mid"




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[int]	)     ->					Optional[int]:
							UpperCAmelCase_=  {
							    """in_channels""": 32,
							    """temb_channels""": 128,
							}
							UpperCAmelCase_=  self.dummy_input
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[int]	)     ->					List[str]:
							UpperCAmelCase_=  [-0.1_062, 1.7_248, 0.3_494, 1.4_569, -0.0_910, -1.2_421, -0.9_984, 0.6_736, 1.0_028]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Any						  =				UNetMidBlockaDCrossAttn  # noqa F405
	a__ :   str						  =				"mid"




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]	)     ->					Tuple:
							UpperCAmelCase_,  UpperCAmelCase_=  super().prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_=  32
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		str	)     ->					Optional[int]:
							UpperCAmelCase_=  [0.0_187, 2.4_220, 0.4_484, 1.1_203, -0.6_121, -1.5_122, -0.8_270, 0.7_851, 1.8_335]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   int						  =				UNetMidBlockaDSimpleCrossAttn  # noqa F405
	a__ :   List[Any]						  =				"mid"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		int	)     ->					List[str]:
							return super().get_dummy_input(include_encoder_hidden_states=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Dict	)     ->					Any:
							UpperCAmelCase_,  UpperCAmelCase_=  super().prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_=  32
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple	)     ->					Optional[Any]:
							UpperCAmelCase_=  [0.7_143, 1.9_974, 0.5_448, 1.3_977, 0.1_282, -1.1_237, -1.4_238, 0.5_530, 0.8_880]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Any						  =				UpBlockaD  # noqa F405
	a__ :   Union[str, Any]						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple	)     ->					List[Any]:
							return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		str	)     ->					Tuple:
							UpperCAmelCase_=  [-0.2_041, -0.4_165, -0.3_022, 0.0_041, -0.6_628, -0.7_053, 0.1_928, -0.0_325, 0.0_523]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   List[Any]						  =				ResnetUpsampleBlockaD  # noqa F405
	a__ :   List[Any]						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[int]	)     ->					Optional[Any]:
							return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		str	)     ->					int:
							UpperCAmelCase_=  [0.2_287, 0.3_549, -0.1_346, 0.4_797, -0.1_715, -0.9_649, 0.7_305, -0.5_864, -0.6_244]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   int						  =				CrossAttnUpBlockaD  # noqa F405
	a__ :   Tuple						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		List[Any]	)     ->					str:
							return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		List[str]	)     ->					Dict:
							UpperCAmelCase_,  UpperCAmelCase_=  super().prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_=  32
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple	)     ->					int:
							UpperCAmelCase_=  [-0.1_403, -0.3_515, -0.0_420, -0.1_425, 0.3_167, 0.5_094, -0.2_181, 0.5_931, 0.5_582]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   Tuple						  =				SimpleCrossAttnUpBlockaD  # noqa F405
	a__ :   Dict						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[int]	)     ->					Optional[Any]:
							return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_		,    include_encoder_hidden_states=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]	)     ->					Optional[int]:
							UpperCAmelCase_,  UpperCAmelCase_=  super().prepare_init_args_and_inputs_for_common()
							UpperCAmelCase_=  32
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		List[str]	)     ->					str:
							UpperCAmelCase_=  [0.2_645, 0.1_480, 0.0_909, 0.8_044, -0.9_758, -0.9_083, 0.0_994, -1.1_453, -0.7_402]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   str						  =				AttnUpBlockaD  # noqa F405
	a__ :   Union[str, Any]						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		str	)     ->					Union[str, Any]:
							return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_	)




	@unittest.skipIf(torch_device == """mps"""		,    """MPS result is not consistent"""	)
	def     _SCREAMING_SNAKE_CASE						(      self      :		Any	)     ->					Any:
							UpperCAmelCase_=  [0.0_979, 0.1_326, 0.0_021, 0.0_659, 0.2_249, 0.0_059, 0.1_132, 0.5_952, 0.1_033]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   str						  =				SkipUpBlockaD  # noqa F405
	a__ :   Tuple						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[int]	)     ->					Tuple:
							return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		List[str]	)     ->					Dict:
							UpperCAmelCase_=  [-0.0_893, -0.1_234, -0.1_506, -0.0_332, 0.0_123, -0.0_211, 0.0_566, 0.0_143, 0.0_362]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   List[Any]						  =				AttnSkipUpBlockaD  # noqa F405
	a__ :   Tuple						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]	)     ->					Any:
							return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Any	)     ->					Union[str, Any]:
							UpperCAmelCase_=  [0.0_361, 0.0_617, 0.2_787, -0.0_350, 0.0_342, 0.3_421, -0.0_843, 0.0_913, 0.3_015]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   int						  =				UpDecoderBlockaD  # noqa F405
	a__ :   int						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		List[Any]	)     ->					Optional[int]:
							return super().get_dummy_input(include_temb=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple	)     ->					List[Any]:
							UpperCAmelCase_=  {"""in_channels""": 32, """out_channels""": 32}

							UpperCAmelCase_=  self.dummy_input
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		Dict	)     ->					Tuple:
							UpperCAmelCase_=  [0.4_404, 0.1_998, -0.9_886, -0.3_320, -0.3_128, -0.7_034, -0.6_955, -0.2_338, -0.3_137]
							super().test_output(snake_case_	)






class 						lowercase		(					snake_case__					,       unittest.TestCase):






	"""simple docstring"""


	a__ :   List[Any]						  =				AttnUpDecoderBlockaD  # noqa F405
	a__ :   Dict						  =				"up"




	@property
	def     _SCREAMING_SNAKE_CASE						(      self      :		Dict	)     ->					Dict:
							return super().get_dummy_input(include_temb=snake_case_	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[int]	)     ->					Any:
							UpperCAmelCase_=  {"""in_channels""": 32, """out_channels""": 32}

							UpperCAmelCase_=  self.dummy_input
							return init_dict, inputs_dict




	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple	)     ->					Optional[Any]:
							UpperCAmelCase_=  [0.6_738, 0.4_491, 0.1_055, 1.0_710, 0.7_316, 0.3_339, 0.3_352, 0.1_023, 0.3_568]
							super().test_output(snake_case_	)









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase_													=      {
    '''configuration_albert''': ['''ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''AlbertConfig''', '''AlbertOnnxConfig'''],
}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_													=      ['''AlbertTokenizer''']

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_													=      ['''AlbertTokenizerFast''']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_													=      [
				    '''ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''AlbertForMaskedLM''',
				    '''AlbertForMultipleChoice''',
				    '''AlbertForPreTraining''',
				    '''AlbertForQuestionAnswering''',
				    '''AlbertForSequenceClassification''',
				    '''AlbertForTokenClassification''',
				    '''AlbertModel''',
				    '''AlbertPreTrainedModel''',
				    '''load_tf_weights_in_albert''',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_													=      [
				    '''TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''TFAlbertForMaskedLM''',
				    '''TFAlbertForMultipleChoice''',
				    '''TFAlbertForPreTraining''',
				    '''TFAlbertForQuestionAnswering''',
				    '''TFAlbertForSequenceClassification''',
				    '''TFAlbertForTokenClassification''',
				    '''TFAlbertMainLayer''',
				    '''TFAlbertModel''',
				    '''TFAlbertPreTrainedModel''',
				]

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_													=      [
				    '''FlaxAlbertForMaskedLM''',
				    '''FlaxAlbertForMultipleChoice''',
				    '''FlaxAlbertForPreTraining''',
				    '''FlaxAlbertForQuestionAnswering''',
				    '''FlaxAlbertForSequenceClassification''',
				    '''FlaxAlbertForTokenClassification''',
				    '''FlaxAlbertModel''',
				    '''FlaxAlbertPreTrainedModel''',
				]

if TYPE_CHECKING:
				from .configuration_albert import ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, AlbertOnnxConfig

				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_albert import AlbertTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_albert_fast import AlbertTokenizerFast

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_albert import (
								    ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    AlbertForMaskedLM,
								    AlbertForMultipleChoice,
								    AlbertForPreTraining,
								    AlbertForQuestionAnswering,
								    AlbertForSequenceClassification,
								    AlbertForTokenClassification,
								    AlbertModel,
								    AlbertPreTrainedModel,
								    load_tf_weights_in_albert,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_albert import (
								    TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFAlbertForMaskedLM,
								    TFAlbertForMultipleChoice,
								    TFAlbertForPreTraining,
								    TFAlbertForQuestionAnswering,
								    TFAlbertForSequenceClassification,
								    TFAlbertForTokenClassification,
								    TFAlbertMainLayer,
								    TFAlbertModel,
								    TFAlbertPreTrainedModel,
								)

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_albert import (
								    FlaxAlbertForMaskedLM,
								    FlaxAlbertForMultipleChoice,
								    FlaxAlbertForPreTraining,
								    FlaxAlbertForQuestionAnswering,
								    FlaxAlbertForSequenceClassification,
								    FlaxAlbertForTokenClassification,
								    FlaxAlbertModel,
								    FlaxAlbertPreTrainedModel,
								)
else:
				import sys

				lowercase_													=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




