





import tempfile

import torch

from diffusers import (
    DEISMultistepScheduler,
    DPMSolverMultistepScheduler,
    DPMSolverSinglestepScheduler,
    UniPCMultistepScheduler,
)

from .test_schedulers import SchedulerCommonTest







class    __snake_case	(							__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					(UniPCMultistepScheduler,)
       lowerCAmelCase__						=					(("""num_inference_steps""", 25),)




       def 							UpperCAmelCase__			(  self			:   Any							,    **A			:   Optional[int]		):
         __snake_case:						int			  =						{
             """num_train_timesteps""": 1_000,
             """beta_start""": 0.0001,
             """beta_end""": 0.02,
             """beta_schedule""": """linear""",
             """solver_order""": 2,
             """solver_type""": """bh2""",
         }

         config.update(**A		)
         return config




       def 							UpperCAmelCase__			(  self			:   str							,    A			:   Optional[Any]=0							,    **A			:   List[str]		):
         __snake_case:						Dict			  =						dict(self.forward_default_kwargs		)
         __snake_case:						Tuple			  =						kwargs.pop("""num_inference_steps"""							,    A		)
         __snake_case:						Optional[Any]			  =						self.dummy_sample
         __snake_case:						List[Any]			  =						0.1 * sample
         __snake_case:						List[Any]			  =						[residual + 0.2, residual + 0.15, residual + 0.10]

         for scheduler_class in self.scheduler_classes:
           __snake_case:						str			  =						self.get_scheduler_config(**A		)
           __snake_case:						Union[str, Any]			  =						scheduler_class(**A		)
           scheduler.set_timesteps(A		)
           # copy over dummy past residuals
           __snake_case:						Union[str, Any]			  =						dummy_past_residuals[: scheduler.config.solver_order]

           with tempfile.TemporaryDirectory() as tmpdirname:
             scheduler.save_config(A		)
             __snake_case:						Union[str, Any]			  =						scheduler_class.from_pretrained(A		)
             new_scheduler.set_timesteps(A		)
             # copy over dummy past residuals
             __snake_case:						str			  =						dummy_past_residuals[: new_scheduler.config.solver_order]

           __snake_case:						int			  =						sample, sample
           for t in range(A							,    time_step + scheduler.config.solver_order + 1		):
             __snake_case:						List[str]			  =						scheduler.step(A							,    A							,    A							,    **A		).prev_sample
             __snake_case:						str			  =						new_scheduler.step(A							,    A							,    A							,    **A		).prev_sample

             assert torch.sum(torch.abs(output - new_output		)		) < 1E-5, "Scheduler outputs are not identical"




       def 							UpperCAmelCase__			(  self			:   int							,    A			:   Dict=0							,    **A			:   str		):
         __snake_case:						Tuple			  =						dict(self.forward_default_kwargs		)
         __snake_case:						Optional[Any]			  =						kwargs.pop("""num_inference_steps"""							,    A		)
         __snake_case:						Optional[Any]			  =						self.dummy_sample
         __snake_case:						Any			  =						0.1 * sample
         __snake_case:						str			  =						[residual + 0.2, residual + 0.15, residual + 0.10]

         for scheduler_class in self.scheduler_classes:
           __snake_case:						List[Any]			  =						self.get_scheduler_config()
           __snake_case:						Tuple			  =						scheduler_class(**A		)
           scheduler.set_timesteps(A		)

           # copy over dummy past residuals (must be after setting timesteps)
           __snake_case:						int			  =						dummy_past_residuals[: scheduler.config.solver_order]

           with tempfile.TemporaryDirectory() as tmpdirname:
             scheduler.save_config(A		)
             __snake_case:						List[str]			  =						scheduler_class.from_pretrained(A		)
             # copy over dummy past residuals
             new_scheduler.set_timesteps(A		)

             # copy over dummy past residual (must be after setting timesteps)
             __snake_case:						Any			  =						dummy_past_residuals[: new_scheduler.config.solver_order]

           __snake_case:						int			  =						scheduler.step(A							,    A							,    A							,    **A		).prev_sample
           __snake_case:						int			  =						new_scheduler.step(A							,    A							,    A							,    **A		).prev_sample

           assert torch.sum(torch.abs(output - new_output		)		) < 1E-5, "Scheduler outputs are not identical"




       def 							UpperCAmelCase__			(  self			:   str							,    A			:   str=None							,    **A			:   Any		):
         if scheduler is None:
           __snake_case:						Any			  =						self.scheduler_classes[0]
           __snake_case:						Any			  =						self.get_scheduler_config(**A		)
           __snake_case:						Optional[Any]			  =						scheduler_class(**A		)

         __snake_case:						Optional[Any]			  =						self.scheduler_classes[0]
         __snake_case:						List[Any]			  =						self.get_scheduler_config(**A		)
         __snake_case:						Any			  =						scheduler_class(**A		)

         __snake_case:						Optional[int]			  =						10
         __snake_case:						List[Any]			  =						self.dummy_model()
         __snake_case:						Tuple			  =						self.dummy_sample_deter
         scheduler.set_timesteps(A		)

         for i, t in enumerate(scheduler.timesteps		):
           __snake_case:						Tuple			  =						model(A							,    A		)
           __snake_case:						List[str]			  =						scheduler.step(A							,    A							,    A		).prev_sample

         return sample




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						int			  =						dict(self.forward_default_kwargs		)

         __snake_case:						Union[str, Any]			  =						kwargs.pop("""num_inference_steps"""							,    A		)

         for scheduler_class in self.scheduler_classes:
           __snake_case:						Optional[Any]			  =						self.get_scheduler_config()
           __snake_case:						Tuple			  =						scheduler_class(**A		)

           __snake_case:						int			  =						self.dummy_sample
           __snake_case:						str			  =						0.1 * sample

           if num_inference_steps is not None and hasattr(A							,    """set_timesteps"""		):
             scheduler.set_timesteps(A		)
           elif num_inference_steps is not None and not hasattr(A							,    """set_timesteps"""		):
             __snake_case:						Union[str, Any]			  =						num_inference_steps

           # copy over dummy past residuals (must be done after set_timesteps)
           __snake_case:						Any			  =						[residual + 0.2, residual + 0.15, residual + 0.10]
           __snake_case:						str			  =						dummy_past_residuals[: scheduler.config.solver_order]

           __snake_case:						Dict			  =						scheduler.timesteps[5]
           __snake_case:						Union[str, Any]			  =						scheduler.timesteps[6]

           __snake_case:						Dict			  =						scheduler.step(A							,    A							,    A							,    **A		).prev_sample
           __snake_case:						Optional[Any]			  =						scheduler.step(A							,    A							,    A							,    **A		).prev_sample

           self.assertEqual(output_a.shape							,    sample.shape		)
           self.assertEqual(output_a.shape							,    output_a.shape		)




       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         # make sure that iterating over schedulers with same config names gives same results
         # for defaults
         __snake_case:						str			  =						UniPCMultistepScheduler(**self.get_scheduler_config()		)
         __snake_case:						str			  =						self.full_loop(scheduler=A		)
         __snake_case:						int			  =						torch.mean(torch.abs(A		)		)

         assert abs(result_mean.item() - 0.2464		) < 1E-3

         __snake_case:						Optional[int]			  =						DPMSolverSinglestepScheduler.from_config(scheduler.config		)
         __snake_case:						Dict			  =						DEISMultistepScheduler.from_config(scheduler.config		)
         __snake_case:						Optional[Any]			  =						DPMSolverMultistepScheduler.from_config(scheduler.config		)
         __snake_case:						Tuple			  =						UniPCMultistepScheduler.from_config(scheduler.config		)

         __snake_case:						Optional[int]			  =						self.full_loop(scheduler=A		)
         __snake_case:						Dict			  =						torch.mean(torch.abs(A		)		)

         assert abs(result_mean.item() - 0.2464		) < 1E-3




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         for timesteps in [25, 50, 100, 999, 1_000]:
           self.check_over_configs(num_train_timesteps=A		)




       def 							UpperCAmelCase__			(  self			:   Any		):
         self.check_over_configs(thresholding=A		)
         for order in [1, 2, 3]:
           for solver_type in ["bh1", "bh2"]:
             for threshold in [0.5, 1.0, 2.0]:
               for prediction_type in ["epsilon", "sample"]:
                 self.check_over_configs(
                     thresholding=A							,    prediction_type=A							,    sample_max_value=A							,    solver_order=A							,    solver_type=A							,    )




       def 							UpperCAmelCase__			(  self			:   Dict		):
         for prediction_type in ["epsilon", "v_prediction"]:
           self.check_over_configs(prediction_type=A		)




       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         for solver_type in ["bh1", "bh2"]:
           for order in [1, 2, 3]:
             for prediction_type in ["epsilon", "sample"]:
               self.check_over_configs(
                   solver_order=A							,    solver_type=A							,    prediction_type=A							,    )
               __snake_case:						List[str]			  =						self.full_loop(
                   solver_order=A							,    solver_type=A							,    prediction_type=A							,    )
               assert not torch.isnan(A		).any(), "Samples have nan numbers"




       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         self.check_over_configs(lower_order_final=A		)
         self.check_over_configs(lower_order_final=A		)




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         for num_inference_steps in [1, 2, 3, 5, 10, 50, 100, 999, 1_000]:
           self.check_over_forward(num_inference_steps=A							,    time_step=0		)




       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						str			  =						self.full_loop()
         __snake_case:						Dict			  =						torch.mean(torch.abs(A		)		)

         assert abs(result_mean.item() - 0.2464		) < 1E-3




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						List[Any]			  =						self.full_loop(prediction_type="""v_prediction"""		)
         __snake_case:						List[str]			  =						torch.mean(torch.abs(A		)		)

         assert abs(result_mean.item() - 0.1014		) < 1E-3




       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Optional[int]			  =						self.scheduler_classes[0]
         __snake_case:						List[str]			  =						self.get_scheduler_config(thresholding=A							,    dynamic_thresholding_ratio=0		)
         __snake_case:						List[str]			  =						scheduler_class(**A		)

         __snake_case:						Optional[Any]			  =						10
         __snake_case:						Union[str, Any]			  =						self.dummy_model()
         __snake_case:						int			  =						self.dummy_sample_deter.half()
         scheduler.set_timesteps(A		)

         for i, t in enumerate(scheduler.timesteps		):
           __snake_case:						List[str]			  =						model(A							,    A		)
           __snake_case:						Union[str, Any]			  =						scheduler.step(A							,    A							,    A		).prev_sample

         assert sample.dtype == torch.floataa






       def 							UpperCAmelCase__			(  self			:   List[str]							,    **A			:   List[str]		):
         for scheduler_class in self.scheduler_classes:
           __snake_case:						str			  =						self.get_scheduler_config(**A		)
           __snake_case:						Optional[int]			  =						scheduler_class(**A		)

           scheduler.set_timesteps(scheduler.config.num_train_timesteps		)
           assert len(scheduler.timesteps.unique()		) == scheduler.num_inference_steps













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





       '''simple docstring'''







       lowerCAmelCase__						=					DownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						str			  =						[-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					ResnetDownsampleBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Union[str, Any]			  =						[0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Union[str, Any]			  =						[0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					CrossAttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case  ,       __snake_case:						List[str]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						List[Any]			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						[0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SimpleCrossAttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case  ,       __snake_case:						Union[str, Any]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						Optional[Any]			  =						32
         return init_dict, inputs_dict






       @unittest.skipIf(torch_device == """mps"""							,    """MPS result is not consistent"""		)
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Optional[Any]			  =						[0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SkipDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Any		):
         return super().get_dummy_input(include_skip_sample=A		)






       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Optional[Any]			  =						[-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnSkipDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         return super().get_dummy_input(include_skip_sample=A		)






       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						str			  =						[0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					DownEncoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						str			  =						{
             """in_channels""": 32,
             """out_channels""": 32,
         }
         __snake_case:						Dict			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Optional[int]			  =						[1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnDownEncoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         return super().get_dummy_input(include_temb=A		)




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






       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Dict			  =						[0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaD  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Optional[int]			  =						{
             """in_channels""": 32,
             """temb_channels""": 128,
         }
         __snake_case:						List[str]			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Tuple			  =						[-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaDCrossAttn  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						int			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						int			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						[0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaDSimpleCrossAttn  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						Any			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						str			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						[0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Tuple		):
         __snake_case:						Tuple			  =						[-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					ResnetUpsampleBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						int			  =						[0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					CrossAttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case  ,       __snake_case:						Any			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						Optional[int]			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						List[Any]			  =						[-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SimpleCrossAttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A							,    include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case  ,       __snake_case:						Optional[Any]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						str			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Union[str, Any]			  =						[0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   int		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       @unittest.skipIf(torch_device == """mps"""							,    """MPS result is not consistent"""		)
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						Optional[Any]			  =						[0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SkipUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   str		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[int]			  =						[-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnSkipUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   str		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						[0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UpDecoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Union[str, Any]			  =						{"""in_channels""": 32, """out_channels""": 32}

         __snake_case:						Dict			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Dict			  =						[0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnUpDecoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						{"""in_channels""": 32, """out_channels""": 32}

         __snake_case:						Any			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						Any			  =						[0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
         super().test_output(A		)






