
"""simple docstring"""






import argparse
import struct
import unittest



class 			lowercase					:






			def __init__(self  :	Any      ,SCREAMING_SNAKE_CASE_  :	bytes			)       ->	None:





				"""simple docstring"""


				lowerCAmelCase												=  data

				# Initialize hash values
				lowerCAmelCase												=  [
				    0X6A_09_E6_67,
				    0XBB_67_AE_85,
				    0X3C_6E_F3_72,
				    0XA5_4F_F5_3A,
				    0X51_0E_52_7F,
				    0X9B_05_68_8C,
				    0X1F_83_D9_AB,
				    0X5B_E0_CD_19,
				]

				# Initialize round constants
				lowerCAmelCase												=  [
				    0X42_8A_2F_98,
				    0X71_37_44_91,
				    0XB5_C0_FB_CF,
				    0XE9_B5_DB_A5,
				    0X39_56_C2_5B,
				    0X59_F1_11_F1,
				    0X92_3F_82_A4,
				    0XAB_1C_5E_D5,
				    0XD8_07_AA_98,
				    0X12_83_5B_01,
				    0X24_31_85_BE,
				    0X55_0C_7D_C3,
				    0X72_BE_5D_74,
				    0X80_DE_B1_FE,
				    0X9B_DC_06_A7,
				    0XC1_9B_F1_74,
				    0XE4_9B_69_C1,
				    0XEF_BE_47_86,
				    0X0F_C1_9D_C6,
				    0X24_0C_A1_CC,
				    0X2D_E9_2C_6F,
				    0X4A_74_84_AA,
				    0X5C_B0_A9_DC,
				    0X76_F9_88_DA,
				    0X98_3E_51_52,
				    0XA8_31_C6_6D,
				    0XB0_03_27_C8,
				    0XBF_59_7F_C7,
				    0XC6_E0_0B_F3,
				    0XD5_A7_91_47,
				    0X06_CA_63_51,
				    0X14_29_29_67,
				    0X27_B7_0A_85,
				    0X2E_1B_21_38,
				    0X4D_2C_6D_FC,
				    0X53_38_0D_13,
				    0X65_0A_73_54,
				    0X76_6A_0A_BB,
				    0X81_C2_C9_2E,
				    0X92_72_2C_85,
				    0XA2_BF_E8_A1,
				    0XA8_1A_66_4B,
				    0XC2_4B_8B_70,
				    0XC7_6C_51_A3,
				    0XD1_92_E8_19,
				    0XD6_99_06_24,
				    0XF4_0E_35_85,
				    0X10_6A_A0_70,
				    0X19_A4_C1_16,
				    0X1E_37_6C_08,
				    0X27_48_77_4C,
				    0X34_B0_BC_B5,
				    0X39_1C_0C_B3,
				    0X4E_D8_AA_4A,
				    0X5B_9C_CA_4F,
				    0X68_2E_6F_F3,
				    0X74_8F_82_EE,
				    0X78_A5_63_6F,
				    0X84_C8_78_14,
				    0X8C_C7_02_08,
				    0X90_BE_FF_FA,
				    0XA4_50_6C_EB,
				    0XBE_F9_A3_F7,
				    0XC6_71_78_F2,
				]

				lowerCAmelCase												=  self.preprocessing(self.data			)
				self.final_hash()






			@staticmethod
			def 					UpperCAmelCase							(SCREAMING_SNAKE_CASE_  :	bytes			)       ->	bytes:





				"""simple docstring"""


				lowerCAmelCase												=  B'''\x80''' + (B'''\x00''' * (63 - (len(SCREAMING_SNAKE_CASE_			) + 8) % 64))
				lowerCAmelCase												=  struct.pack('''>Q'''      ,(len(SCREAMING_SNAKE_CASE_			) * 8)			)
				return data + padding + big_endian_integer






			def 					UpperCAmelCase							(self  :	str			)       ->	None:





				"""simple docstring"""


				lowerCAmelCase												=  [
				    self.preprocessed_data[x : x + 64]
				    for x in range(0      ,len(self.preprocessed_data			)      ,64			)
				]

				for block in self.blocks:
					# Convert the given block into a list of 4 byte integers
					lowerCAmelCase												=  list(struct.unpack('''>16L'''      ,SCREAMING_SNAKE_CASE_			)			)
					# add 48 0-ed integers
					words += [0] * 48

					lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase												=  self.hashes

					for index in range(0      ,64			):
						if index > 15:
							# modify the zero-ed indexes at the end of the array
							lowerCAmelCase												=  (
							    self.ror(words[index - 15]      ,7			)
							    ^ self.ror(words[index - 15]      ,18			)
							    ^ (words[index - 15] >> 3)
							)
							lowerCAmelCase												=  (
							    self.ror(words[index - 2]      ,17			)
							    ^ self.ror(words[index - 2]      ,19			)
							    ^ (words[index - 2] >> 10)
							)

							lowerCAmelCase												=  (
							    words[index - 16] + sa + words[index - 7] + sa
							) % 0X1_00_00_00_00

						# Compression
						lowerCAmelCase												=  self.ror(SCREAMING_SNAKE_CASE_      ,6			) ^ self.ror(SCREAMING_SNAKE_CASE_      ,11			) ^ self.ror(SCREAMING_SNAKE_CASE_      ,25			)
						lowerCAmelCase												=  (e & f) ^ ((~e & 0XFF_FF_FF_FF) & g)
						lowerCAmelCase												=  (
						    h + sa + ch + self.round_constants[index] + words[index]
						) % 0X1_00_00_00_00
						lowerCAmelCase												=  self.ror(SCREAMING_SNAKE_CASE_      ,2			) ^ self.ror(SCREAMING_SNAKE_CASE_      ,13			) ^ self.ror(SCREAMING_SNAKE_CASE_      ,22			)
						lowerCAmelCase												=  (a & b) ^ (a & c) ^ (b & c)
						lowerCAmelCase												=  (sa + maj) % 0X1_00_00_00_00

						lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase							,       lowerCAmelCase												=  (
						    g,
						    f,
						    e,
						    ((d + tempa) % 0X1_00_00_00_00),
						    c,
						    b,
						    a,
						    ((tempa + tempa) % 0X1_00_00_00_00),
						)

					lowerCAmelCase												=  [a, b, c, d, e, f, g, h]

					# Modify final values
					lowerCAmelCase												=  [
					    ((element + mutated_hash_values[index]) % 0X1_00_00_00_00)
					    for index, element in enumerate(self.hashes			)
					]

				lowerCAmelCase												=  ''''''.join([hex(SCREAMING_SNAKE_CASE_			)[2:].zfill(8			) for value in self.hashes]			)






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





				"""simple docstring"""


				return 0XFF_FF_FF_FF & (value << (32 - rotations)) | (value >> rotations)





class 			lowercase					( unittest.TestCase		):






			def 					UpperCAmelCase							(self  :	str			)       ->	None:





				"""simple docstring"""


				import hashlib

				lowerCAmelCase												=  bytes('''Test String'''      ,'''utf-8'''			)
				self.assertEqual(SHAaaa(SCREAMING_SNAKE_CASE_			).hash      ,hashlib.shaaaa(SCREAMING_SNAKE_CASE_			).hexdigest()			)





def __magic_name__	(				)					->						None:

	'''simple docstring'''




	import doctest

	doctest.testmod()

	lowerCAmelCase												=  argparse.ArgumentParser()
	parser.add_argument(
	    '''-s''',					'''--string''',					dest='''input_string''',					default='''Hello World!! Welcome to Cryptography''',					help='''Hash the string''',					)
	parser.add_argument(
	    '''-f''',					'''--file''',					dest='''input_file''',					help='''Hash contents of a file'''			)

	lowerCAmelCase												=  parser.parse_args()

	lowerCAmelCase												=  args.input_string

	# hash input should be a bytestring
	if args.input_file:
		with open(args.input_file,					'''rb'''			) as f:
			lowerCAmelCase												=  f.read()
	else:
		lowerCAmelCase												=  bytes(_lowerCamelCase,					'''utf-8'''			)

	print(SHAaaa(_lowerCamelCase			).hash			)


if __name__ == "__main__":
					main()




"""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 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     DownBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


				lowerCAmelCase												=  [-0.02_32, -0.98_69, 0.80_54, -0.06_37, -0.16_88, -1.42_64, 0.44_70, -1.33_94, 0.09_04]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     ResnetDownsampleBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.07_10, 0.24_10, -0.73_20, -1.07_57, -1.13_43, 0.35_40, -0.01_33, -0.25_76, 0.09_48]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     AttnDownBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.06_36, 0.89_64, -0.62_34, -1.01_31, 0.08_44, 0.49_35, 0.34_37, 0.09_11, -0.29_57]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     CrossAttnDownBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


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






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.22_38, -0.73_96, -0.22_55, -0.38_29, 0.19_25, 1.16_65, 0.06_03, -0.72_95, 0.19_83]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     SimpleCrossAttnDownBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_encoder_hidden_states=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


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






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.79_21, -0.09_92, -0.19_62, -0.76_95, -0.42_42, 0.78_04, 0.47_37, 0.27_65, 0.33_38]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     SkipDownBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_skip_sample=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


				lowerCAmelCase												=  [-0.08_45, -0.20_87, -0.24_65, 0.09_71, 0.19_00, -0.04_84, 0.26_64, 0.41_79, 0.50_69]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     AttnSkipDownBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_skip_sample=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.55_39, 0.16_09, 0.49_24, 0.05_37, -0.19_95, 0.40_50, 0.09_79, -0.27_21, -0.06_42]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     DownEncoderBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_temb=SCREAMING_SNAKE_CASE_			)






			def 					UpperCAmelCase							(self  :	int			)       ->	Tuple:





				"""simple docstring"""


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






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





				"""simple docstring"""


				lowerCAmelCase												=  [1.11_02, 0.53_02, 0.48_72, -0.00_23, -0.80_42, 0.04_83, -0.34_89, -0.56_32, 0.76_26]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     AttnDownEncoderBlockaD  # noqa F405
			lowercase        =     '''down'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_temb=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


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






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.89_66, -0.14_86, 0.85_68, 0.81_41, -0.90_46, -0.13_42, -0.09_72, -0.74_17, 0.15_38]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     UNetMidBlockaD  # noqa F405
			lowercase        =     '''mid'''






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





				"""simple docstring"""


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






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





				"""simple docstring"""


				lowerCAmelCase												=  [-0.10_62, 1.72_48, 0.34_94, 1.45_69, -0.09_10, -1.24_21, -0.99_84, 0.67_36, 1.00_28]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     UNetMidBlockaDCrossAttn  # noqa F405
			lowercase        =     '''mid'''






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





				"""simple docstring"""


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






			def 					UpperCAmelCase							(self  :	Any			)       ->	Dict:





				"""simple docstring"""


				lowerCAmelCase												=  [0.01_87, 2.42_20, 0.44_84, 1.12_03, -0.61_21, -1.51_22, -0.82_70, 0.78_51, 1.83_35]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     UNetMidBlockaDSimpleCrossAttn  # noqa F405
			lowercase        =     '''mid'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_encoder_hidden_states=SCREAMING_SNAKE_CASE_			)






			def 					UpperCAmelCase							(self  :	int			)       ->	int:





				"""simple docstring"""


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






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.71_43, 1.99_74, 0.54_48, 1.39_77, 0.12_82, -1.12_37, -1.42_38, 0.55_30, 0.88_80]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     UpBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_res_hidden_states_tuple=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


				lowerCAmelCase												=  [-0.20_41, -0.41_65, -0.30_22, 0.00_41, -0.66_28, -0.70_53, 0.19_28, -0.03_25, 0.05_23]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     ResnetUpsampleBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_res_hidden_states_tuple=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.22_87, 0.35_49, -0.13_46, 0.47_97, -0.17_15, -0.96_49, 0.73_05, -0.58_64, -0.62_44]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     CrossAttnUpBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_res_hidden_states_tuple=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


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






			def 					UpperCAmelCase							(self  :	str			)       ->	Tuple:





				"""simple docstring"""


				lowerCAmelCase												=  [-0.14_03, -0.35_15, -0.04_20, -0.14_25, 0.31_67, 0.50_94, -0.21_81, 0.59_31, 0.55_82]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     SimpleCrossAttnUpBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


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






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





				"""simple docstring"""


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






			def 					UpperCAmelCase							(self  :	Tuple			)       ->	Any:





				"""simple docstring"""


				lowerCAmelCase												=  [0.26_45, 0.14_80, 0.09_09, 0.80_44, -0.97_58, -0.90_83, 0.09_94, -1.14_53, -0.74_02]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     AttnUpBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_res_hidden_states_tuple=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.09_79, 0.13_26, 0.00_21, 0.06_59, 0.22_49, 0.00_59, 0.11_32, 0.59_52, 0.10_33]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     SkipUpBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_res_hidden_states_tuple=SCREAMING_SNAKE_CASE_			)






			def 					UpperCAmelCase							(self  :	str			)       ->	int:





				"""simple docstring"""


				lowerCAmelCase												=  [-0.08_93, -0.12_34, -0.15_06, -0.03_32, 0.01_23, -0.02_11, 0.05_66, 0.01_43, 0.03_62]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     AttnSkipUpBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_res_hidden_states_tuple=SCREAMING_SNAKE_CASE_			)






			def 					UpperCAmelCase							(self  :	Any			)       ->	int:





				"""simple docstring"""


				lowerCAmelCase												=  [0.03_61, 0.06_17, 0.27_87, -0.03_50, 0.03_42, 0.34_21, -0.08_43, 0.09_13, 0.30_15]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     UpDecoderBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_temb=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


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

				lowerCAmelCase												=  self.dummy_input
				return init_dict, inputs_dict






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.44_04, 0.19_98, -0.98_86, -0.33_20, -0.31_28, -0.70_34, -0.69_55, -0.23_38, -0.31_37]
				super().test_output(SCREAMING_SNAKE_CASE_			)





class 			lowercase					( lowercase__   ,unittest.TestCase		):
			lowercase        =     AttnUpDecoderBlockaD  # noqa F405
			lowercase        =     '''up'''






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





				"""simple docstring"""


				return super().get_dummy_input(include_temb=SCREAMING_SNAKE_CASE_			)






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





				"""simple docstring"""


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

				lowerCAmelCase												=  self.dummy_input
				return init_dict, inputs_dict






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





				"""simple docstring"""


				lowerCAmelCase												=  [0.67_38, 0.44_91, 0.10_55, 1.07_10, 0.73_16, 0.33_39, 0.33_52, 0.10_23, 0.35_68]
				super().test_output(SCREAMING_SNAKE_CASE_			)


