





"""simple docstring"""




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		):
							lowerCamelCase     :      Any         =DownBlockaD  # noqa F405
							lowerCamelCase     :      List[str]         ="""down"""






							def 					__a     (     self   )			->				List[str]:
								a   :	Optional[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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Tuple         =ResnetDownsampleBlockaD  # noqa F405
							lowerCamelCase     :      Tuple         ="""down"""






							def 					__a     (     self   )			->				Dict:
								a   :	Any			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Optional[Any]         =AttnDownBlockaD  # noqa F405
							lowerCamelCase     :      Optional[int]         ="""down"""






							def 					__a     (     self   )			->				Union[str, Any]:
								a   :	int			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      List[str]         =CrossAttnDownBlockaD  # noqa F405
							lowerCamelCase     :      List[Any]         ="""down"""






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






							def 					__a     (     self   )			->				List[Any]:
								a   :	str			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      List[str]         =SimpleCrossAttnDownBlockaD  # noqa F405
							lowerCamelCase     :      Union[str, Any]         ="""down"""






							@property
							def 					__a     (     self   )			->				Dict:
								return super().get_dummy_input(include_encoder_hidden_states=lowerCAmelCase__   )






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	List[str]			=       super().prepare_init_args_and_inputs_for_common()
								a   :	Optional[Any]			=       32
								return init_dict, inputs_dict






							@unittest.skipIf(torch_device == "mps"   ,      "MPS result is not consistent"   )
							def 					__a     (     self   )			->				List[Any]:
								a   :	Optional[int]			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Dict         =SkipDownBlockaD  # noqa F405
							lowerCamelCase     :      int         ="""down"""






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






							def 					__a     (     self   )			->				Dict:
								a   :	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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      List[str]         =AttnSkipDownBlockaD  # noqa F405
							lowerCamelCase     :      Optional[Any]         ="""down"""






							@property
							def 					__a     (     self   )			->				Optional[Any]:
								return super().get_dummy_input(include_skip_sample=lowerCAmelCase__   )






							def 					__a     (     self   )			->				Union[str, Any]:
								a   :	int			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Optional[Any]         =DownEncoderBlockaD  # noqa F405
							lowerCamelCase     :      Optional[Any]         ="""down"""






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






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






							def 					__a     (     self   )			->				Tuple:
								a   :	Optional[Any]			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      List[Any]         =AttnDownEncoderBlockaD  # noqa F405
							lowerCamelCase     :      str         ="""down"""






							@property
							def 					__a     (     self   )			->				Tuple:
								return super().get_dummy_input(include_temb=lowerCAmelCase__   )






							def 					__a     (     self   )			->				List[str]:
								a   :	int			=       {
								    "in_channels": 32,
								    "out_channels": 32,
								}
								a   :	Optional[int]			=       self.dummy_input
								return init_dict, inputs_dict






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	Union[str, Any]			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      str         =UNetMidBlockaD  # noqa F405
							lowerCamelCase     :      Optional[int]         ="""mid"""






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






							def 					__a     (     self   )			->				Tuple:
								a   :	Tuple			=       [-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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      List[str]         =UNetMidBlockaDCrossAttn  # noqa F405
							lowerCamelCase     :      Optional[Any]         ="""mid"""






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






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	Tuple			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Union[str, Any]         =UNetMidBlockaDSimpleCrossAttn  # noqa F405
							lowerCamelCase     :      Dict         ="""mid"""






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






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






							def 					__a     (     self   )			->				Dict:
								a   :	List[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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Optional[Any]         =UpBlockaD  # noqa F405
							lowerCamelCase     :      Dict         ="""up"""






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






							def 					__a     (     self   )			->				List[Any]:
								a   :	Tuple			=       [-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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Optional[int]         =ResnetUpsampleBlockaD  # noqa F405
							lowerCamelCase     :      Dict         ="""up"""






							@property
							def 					__a     (     self   )			->				Any:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__   )






							def 					__a     (     self   )			->				int:
								a   :	Tuple			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Dict         =CrossAttnUpBlockaD  # noqa F405
							lowerCamelCase     :      str         ="""up"""






							@property
							def 					__a     (     self   )			->				Tuple:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__   )






							def 					__a     (     self   )			->				Union[str, Any]:
								a   :	List[str]			=       super().prepare_init_args_and_inputs_for_common()
								a   :	Optional[int]			=       32
								return init_dict, inputs_dict






							def 					__a     (     self   )			->				Union[str, Any]:
								a   :	Tuple			=       [-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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      int         =SimpleCrossAttnUpBlockaD  # noqa F405
							lowerCamelCase     :      Any         ="""up"""






							@property
							def 					__a     (     self   )			->				Tuple:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__   ,      include_encoder_hidden_states=lowerCAmelCase__   )






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






							def 					__a     (     self   )			->				Dict:
								a   :	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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      str         =AttnUpBlockaD  # noqa F405
							lowerCamelCase     :      Any         ="""up"""






							@property
							def 					__a     (     self   )			->				Any:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__   )






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


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      str         =SkipUpBlockaD  # noqa F405
							lowerCamelCase     :      Dict         ="""up"""






							@property
							def 					__a     (     self   )			->				Any:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__   )






							def 					__a     (     self   )			->				Union[str, Any]:
								a   :	Dict			=       [-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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      List[Any]         =AttnSkipUpBlockaD  # noqa F405
							lowerCamelCase     :      Tuple         ="""up"""






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






							def 					__a     (     self   )			->				Tuple:
								a   :	Optional[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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      Optional[Any]         =UpDecoderBlockaD  # noqa F405
							lowerCamelCase     :      Optional[int]         ="""up"""






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






							def 					__a     (     self   )			->				List[str]:
								a   :	Union[str, Any]			=       {"in_channels": 32, "out_channels": 32}

								a   :	Dict			=       self.dummy_input
								return init_dict, inputs_dict






							def 					__a     (     self   )			->				Dict:
								a   :	int			=       [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(lowerCAmelCase__   )


class  __UpperCamelCase       (		a__	, unittest.TestCase		):
							lowerCamelCase     :      int         =AttnUpDecoderBlockaD  # noqa F405
							lowerCamelCase     :      int         ="""up"""






							@property
							def 					__a     (     self   )			->				List[str]:
								return super().get_dummy_input(include_temb=lowerCAmelCase__   )






							def 					__a     (     self   )			->				Dict:
								a   :	Tuple			=       {"in_channels": 32, "out_channels": 32}

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






							def 					__a     (     self   )			->				Optional[int]:
								a   :	str			=       [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(lowerCAmelCase__   )









"""simple docstring"""




def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					int = 10					, _lowercase		:					int = 1000					, _lowercase		:					bool = True      )				->int:






	'''simple docstring'''






	assert (
	    isinstance(_lowercase					, _lowercase      )
	    and isinstance(_lowercase					, _lowercase      )
	    and isinstance(_lowercase					, _lowercase      )
	), "Invalid type of value(s) specified to function!"

	if min_val > max_val:
		raise ValueError("Invalid value for min_val or max_val (min_value < max_value)"      )
	return min_val if option else max_val






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					int					, _lowercase		:					int      )				->int:






	'''simple docstring'''






	return int((number_a + number_a) / 2      )






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					int					, _lowercase		:					int					, _lowercase		:					int      )				->None:






	'''simple docstring'''






	assert (
	    isinstance(_lowercase					, _lowercase      ) and isinstance(_lowercase					, _lowercase      ) and isinstance(_lowercase					, _lowercase      )
	), 'argument values must be type of "int"'

	if lower > higher:
		raise ValueError("argument value for lower and higher must be(lower > higher)"      )

	if not lower < to_guess < higher:
		raise ValueError(
		    "guess value must be within the range of lower and higher value"      )

	def answer(_lowercase		:					int      ) -> str:
		if number > to_guess:
			return "high"
		elif number < to_guess:
			return "low"
		else:
			return "same"

	print("started..."      )

	a   :	Optional[Any]			=       lower
	a   :	List[Any]			=       higher

	a   :	Tuple			=       []

	while True:
		a   :	List[Any]			=       get_avg(_lowercase					, _lowercase      )
		last_numbers.append(_lowercase      )

		if answer(_lowercase      ) == "low":
			a   :	Optional[int]			=       number
		elif answer(_lowercase      ) == "high":
			a   :	Tuple			=       number
		else:
			break

	print(F"""guess the number : {last_numbers[-1]}"""      )
	print(F"""details : {last_numbers!s}"""      )






def    _SCREAMING_SNAKE_CASE	(			)				->None:






	'''simple docstring'''






	a   :	Tuple			=       int(input("Enter lower value : "      ).strip()      )
	a   :	Dict			=       int(input("Enter high value : "      ).strip()      )
	a   :	Optional[int]			=       int(input("Enter value to guess : "      ).strip()      )
	guess_the_number(_lowercase					, _lowercase					, _lowercase      )


if __name__ == "__main__":
		main()


