
import unittest
from pathlib import Path
from tempfile import NamedTemporaryFile, TemporaryDirectory

from transformers import BertConfig, BertTokenizerFast, FeatureExtractionPipeline
from transformers.convert_graph_to_onnx import (
    convert,
    ensure_valid_input,
    generate_identified_filename,
    infer_shapes,
    quantize,
)
from transformers.testing_utils import require_tf, require_tokenizers, require_torch, slow







class 			A_  :




	'''simple docstring'''


	def       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case			):
		return None







class 			A_  :




	'''simple docstring'''


	def       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case						,       snake_case			):
		return None







class 			A_  (     unittest.TestCase  ):




	'''simple docstring'''


	_UpperCamelCase	:	Optional[Any]									=			[
	    # (model_name, model_kwargs)
	    ("""bert-base-cased""", {}),
	    ("""gpt2""", {"""use_cache""": False}),  # We don't support exporting GPT2 past keys anymore
	]





	@require_tf
	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
			self._test_export(snake_case						,       'tf'						,       12						,       **snake_case			)





	@require_torch
	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
			self._test_export(snake_case						,       'pt'						,       12						,       **snake_case			)





	@require_torch
	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		from transformers import BertModel

		lowercase	    =       ['[UNK]', '[SEP]', '[CLS]', '[PAD]', '[MASK]', 'some', 'other', 'words']
		with NamedTemporaryFile(mode='w+t'			) as vocab_file:
			vocab_file.write('\n'.join(snake_case			)			)
			vocab_file.flush()
			lowercase	    =       BertTokenizerFast(vocab_file.name			)

		with TemporaryDirectory() as bert_save_dir:
			lowercase	    =       BertModel(BertConfig(vocab_size=len(snake_case			)			)			)
			model.save_pretrained(snake_case			)
			self._test_export(snake_case						,       'pt'						,       12						,       snake_case			)





	@require_tf
	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
			lowercase	    =       self._test_export(snake_case						,       'tf'						,       12						,       **snake_case			)
			lowercase	    =       quantize(Path(snake_case			)			)

			# Ensure the actual quantized model is not bigger than the original one
			if quantized_path.stat().st_size >= Path(snake_case			).stat().st_size:
				self.fail('Quantized model is bigger than initial ONNX model'			)





	@require_torch
	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
			lowercase	    =       self._test_export(snake_case						,       'pt'						,       12						,       **snake_case			)
			lowercase	    =       quantize(snake_case			)

			# Ensure the actual quantized model is not bigger than the original one
			if quantized_path.stat().st_size >= Path(snake_case			).stat().st_size:
				self.fail('Quantized model is bigger than initial ONNX model'			)





	def       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case						,       snake_case=None						,       **snake_case			):
		try:
			# Compute path
			with TemporaryDirectory() as tempdir:
				lowercase	    =       Path(snake_case			).joinpath('model.onnx'			)

			# Remove folder if exists
			if path.parent.exists():
				path.parent.rmdir()

			# Export
			convert(snake_case						,       snake_case						,       snake_case						,       snake_case						,       snake_case						,       **snake_case			)

			return path
		except Exception as e:
			self.fail(snake_case			)





	@require_torch
	@require_tokenizers
	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		from transformers import BertModel

		lowercase	    =       BertModel(BertConfig.from_pretrained('lysandre/tiny-bert-random'			)			)
		lowercase	    =       BertTokenizerFast.from_pretrained('lysandre/tiny-bert-random'			)
		self._test_infer_dynamic_axis(snake_case						,       snake_case						,       'pt'			)





	@require_tf
	@require_tokenizers
	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		from transformers import TFBertModel

		lowercase	    =       TFBertModel(BertConfig.from_pretrained('lysandre/tiny-bert-random'			)			)
		lowercase	    =       BertTokenizerFast.from_pretrained('lysandre/tiny-bert-random'			)
		self._test_infer_dynamic_axis(snake_case						,       snake_case						,       'tf'			)





	def       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case			):
		lowercase	    =       FeatureExtractionPipeline(snake_case						,       snake_case			)

		lowercase	    =       ['input_ids', 'token_type_ids', 'attention_mask', 'output_0', 'output_1']
		lowercase    ,   lowercase    ,   lowercase    ,   lowercase	    =       infer_shapes(snake_case						,       snake_case			)

		# Assert all variables are present
		self.assertEqual(len(snake_case			)						,       len(snake_case			)			)
		self.assertTrue(all(var_name in shapes for var_name in variable_names			)			)
		self.assertSequenceEqual(variable_names[:3]						,       snake_case			)
		self.assertSequenceEqual(variable_names[3:]						,       snake_case			)

		# Assert inputs are {0: batch, 1: sequence}
		for var_name in ["input_ids", "token_type_ids", "attention_mask"]:
			self.assertDictEqual(shapes[var_name]						,       {0: 'batch', 1: 'sequence'}			)

		# Assert outputs are {0: batch, 1: sequence} and {0: batch}
		self.assertDictEqual(shapes['output_0']						,       {0: 'batch', 1: 'sequence'}			)
		self.assertDictEqual(shapes['output_1']						,       {0: 'batch'}			)





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       ['input_ids', 'attention_mask', 'token_type_ids']
		lowercase	    =       {'input_ids': [1, 2, 3, 4], 'attention_mask': [0, 0, 0, 0], 'token_type_ids': [1, 1, 1, 1]}
		lowercase    ,   lowercase	    =       ensure_valid_input(FuncContiguousArgs()						,       snake_case						,       snake_case			)

		# Should have exactly the same number of args (all are valid)
		self.assertEqual(len(snake_case			)						,       3			)

		# Should have exactly the same input names
		self.assertEqual(set(snake_case			)						,       set(snake_case			)			)

		# Parameter should be reordered according to their respective place in the function:
		# (input_ids, token_type_ids, attention_mask)
		self.assertEqual(snake_case						,       (tokens['input_ids'], tokens['token_type_ids'], tokens['attention_mask'])			)

		# Generated args are interleaved with another args (for instance parameter "past" in GPT2)
		lowercase    ,   lowercase	    =       ensure_valid_input(FuncNonContiguousArgs()						,       snake_case						,       snake_case			)

		# Should have exactly the one arg (all before the one not provided "some_other_args")
		self.assertEqual(len(snake_case			)						,       1			)
		self.assertEqual(len(snake_case			)						,       1			)

		# Should have only "input_ids"
		self.assertEqual(inputs_args[0]						,       tokens['input_ids']			)
		self.assertEqual(ordered_input_names[0]						,       'input_ids'			)





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       generate_identified_filename(Path('/home/something/my_fake_model.onnx'			)						,       '-test'			)
		self.assertEqual('/home/something/my_fake_model-test.onnx'						,       generated.as_posix()			)








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   )




