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        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Optional[int]      =			DownBlockaD  # noqa F405
						a__		:Optional[int]      =			'''down'''





						def        A_							(self						)				->				Optional[int]:
												UpperCamelCase_		:							List[Any]  =		[-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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Tuple      =			ResnetDownsampleBlockaD  # noqa F405
						a__		:int      =			'''down'''





						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_		:							Dict  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:List[str]      =			AttnDownBlockaD  # noqa F405
						a__		:Tuple      =			'''down'''





						def        A_							(self						)				->				Optional[int]:
												UpperCamelCase_		:							List[Any]  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:int      =			CrossAttnDownBlockaD  # noqa F405
						a__		:int      =			'''down'''





						def        A_							(self						)				->				List[Any]:
												UpperCamelCase_,UpperCamelCase_		:							Any  =		super().prepare_init_args_and_inputs_for_common()
												UpperCamelCase_		:							Tuple  =		32
												return init_dict, inputs_dict





						def        A_							(self						)				->				str:
												UpperCamelCase_		:							Any  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Union[str, Any]      =			SimpleCrossAttnDownBlockaD  # noqa F405
						a__		:Any      =			'''down'''





						@property
						def        A_							(self						)				->				Optional[int]:
												return super().get_dummy_input(include_encoder_hidden_states=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				int:
												UpperCamelCase_,UpperCamelCase_		:							List[Any]  =		super().prepare_init_args_and_inputs_for_common()
												UpperCamelCase_		:							str  =		32
												return init_dict, inputs_dict





						@unittest.skipIf(torch_device == """mps"""			,     """MPS result is not consistent"""						)
						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							Dict  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:int      =			SkipDownBlockaD  # noqa F405
						a__		:str      =			'''down'''





						@property
						def        A_							(self						)				->				str:
												return super().get_dummy_input(include_skip_sample=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				List[str]:
												UpperCamelCase_		:							Optional[int]  =		[-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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:int      =			AttnSkipDownBlockaD  # noqa F405
						a__		:int      =			'''down'''





						@property
						def        A_							(self						)				->				Optional[int]:
												return super().get_dummy_input(include_skip_sample=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				int:
												UpperCamelCase_		:							Tuple  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Dict      =			DownEncoderBlockaD  # noqa F405
						a__		:Dict      =			'''down'''





						@property
						def        A_							(self						)				->				str:
												return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE						)





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





						def        A_							(self						)				->				List[Any]:
												UpperCamelCase_		:							Dict  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Optional[int]      =			AttnDownEncoderBlockaD  # noqa F405
						a__		:str      =			'''down'''





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





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





						def        A_							(self						)				->				List[str]:
												UpperCamelCase_		:							Dict  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:int      =			UNetMidBlockaD  # noqa F405
						a__		:str      =			'''mid'''





						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_		:							Tuple  =		{
												    """in_channels""": 32,
												    """temb_channels""": 128,
												}
												UpperCamelCase_		:							Dict  =		self.dummy_input
												return init_dict, inputs_dict





						def        A_							(self						)				->				List[str]:
												UpperCamelCase_		:							Optional[Any]  =		[-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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Tuple      =			UNetMidBlockaDCrossAttn  # noqa F405
						a__		:Optional[Any]      =			'''mid'''





						def        A_							(self						)				->				Optional[int]:
												UpperCamelCase_,UpperCamelCase_		:							str  =		super().prepare_init_args_and_inputs_for_common()
												UpperCamelCase_		:							str  =		32
												return init_dict, inputs_dict





						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							Optional[int]  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:int      =			UNetMidBlockaDSimpleCrossAttn  # noqa F405
						a__		:Optional[int]      =			'''mid'''





						@property
						def        A_							(self						)				->				List[str]:
												return super().get_dummy_input(include_encoder_hidden_states=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				Any:
												UpperCamelCase_,UpperCamelCase_		:							List[Any]  =		super().prepare_init_args_and_inputs_for_common()
												UpperCamelCase_		:							List[Any]  =		32
												return init_dict, inputs_dict





						def        A_							(self						)				->				Optional[int]:
												UpperCamelCase_		:							Union[str, Any]  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Any      =			UpBlockaD  # noqa F405
						a__		:str      =			'''up'''





						@property
						def        A_							(self						)				->				Optional[int]:
												return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				List[str]:
												UpperCamelCase_		:							List[Any]  =		[-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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Any      =			ResnetUpsampleBlockaD  # noqa F405
						a__		:Optional[Any]      =			'''up'''





						@property
						def        A_							(self						)				->				List[Any]:
												return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				str:
												UpperCamelCase_		:							int  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Any      =			CrossAttnUpBlockaD  # noqa F405
						a__		:Optional[int]      =			'''up'''





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





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





						def        A_							(self						)				->				str:
												UpperCamelCase_		:							Optional[Any]  =		[-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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Any      =			SimpleCrossAttnUpBlockaD  # noqa F405
						a__		:Optional[Any]      =			'''up'''





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





						def        A_							(self						)				->				str:
												UpperCamelCase_,UpperCamelCase_		:							int  =		super().prepare_init_args_and_inputs_for_common()
												UpperCamelCase_		:							Tuple  =		32
												return init_dict, inputs_dict





						def        A_							(self						)				->				Tuple:
												UpperCamelCase_		:							List[Any]  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Any      =			AttnUpBlockaD  # noqa F405
						a__		:Dict      =			'''up'''





						@property
						def        A_							(self						)				->				int:
												return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)





						@unittest.skipIf(torch_device == """mps"""			,     """MPS result is not consistent"""						)
						def        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_		:							Tuple  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Optional[Any]      =			SkipUpBlockaD  # noqa F405
						a__		:List[str]      =			'''up'''





						@property
						def        A_							(self						)				->				Optional[int]:
												return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				int:
												UpperCamelCase_		:							List[str]  =		[-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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Tuple      =			AttnSkipUpBlockaD  # noqa F405
						a__		:Union[str, Any]      =			'''up'''





						@property
						def        A_							(self						)				->				List[Any]:
												return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				int:
												UpperCamelCase_		:							int  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:Any      =			UpDecoderBlockaD  # noqa F405
						a__		:Optional[Any]      =			'''up'''





						@property
						def        A_							(self						)				->				Optional[int]:
												return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				Any:
												UpperCamelCase_		:							Optional[Any]  =		{"""in_channels""": 32, """out_channels""": 32}

												UpperCamelCase_		:							List[Any]  =		self.dummy_input
												return init_dict, inputs_dict





						def        A_							(self						)				->				Tuple:
												UpperCamelCase_		:							List[Any]  =		[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(__SCREAMING_SNAKE_CASE						)


class        UpperCamelCase						(				a_	,	unittest.TestCase				):
						a__		:int      =			AttnUpDecoderBlockaD  # noqa F405
						a__		:List[str]      =			'''up'''





						@property
						def        A_							(self						)				->				List[Any]:
												return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE						)





						def        A_							(self						)				->				str:
												UpperCamelCase_		:							Optional[Any]  =		{"""in_channels""": 32, """out_channels""": 32}

												UpperCamelCase_		:							List[str]  =		self.dummy_input
												return init_dict, inputs_dict





						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							Union[str, Any]  =		[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(__SCREAMING_SNAKE_CASE						)







from typing import Any



def 	__A		(      _A       ):



 """simple docstring"""


 if not input_list:
  return []
 __a							=	[input_list.count(_A       ) for value in input_list]
 __a							=	max(_A       )  # Gets the maximum count in the input list.
 # Gets values of modes
 return sorted({input_list[i] for i, value in enumerate(_A       ) if value == y}       )


if __name__ == "__main__":
  import doctest

  doctest.testmod()


