





from dataclasses import dataclass
from typing import Dict, Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .attention_processor import AttentionProcessor, AttnProcessor
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder







@dataclass
class    __snake_case	(							__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					42







class    __snake_case	(							__lowerCamelCase       ,      __lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					True




       @register_to_config
       def __init__(  self			:   Union[str, Any]							,    A			:   int = 3							,    A			:   int = 3							,    A			:   Tuple[str] = ("DownEncoderBlock2D",)							,    A			:   Tuple[str] = ("UpDecoderBlock2D",)							,    A			:   Tuple[int] = (64,)							,    A			:   int = 1							,    A			:   str = "silu"							,    A			:   int = 4							,    A			:   int = 32							,    A			:   int = 32							,    A			:   float = 0.1_8215							,    ):
         super().__init__()

         # pass init params to Encoder
         __snake_case:						Any			  =						Encoder(
             in_channels=A							,    out_channels=A							,    down_block_types=A							,    block_out_channels=A							,    layers_per_block=A							,    act_fn=A							,    norm_num_groups=A							,    double_z=A							,    )

         # pass init params to Decoder
         __snake_case:						int			  =						Decoder(
             in_channels=A							,    out_channels=A							,    up_block_types=A							,    block_out_channels=A							,    layers_per_block=A							,    norm_num_groups=A							,    act_fn=A							,    )

         __snake_case:						Dict			  =						nn.Convad(2 * latent_channels							,    2 * latent_channels							,    1		)
         __snake_case:						int			  =						nn.Convad(A							,    A							,    1		)

         __snake_case:						List[str]			  =						False
         __snake_case:						Optional[int]			  =						False

         # only relevant if vae tiling is enabled
         __snake_case:						Any			  =						self.config.sample_size
         __snake_case:						int			  =						(
             self.config.sample_size[0]
             if isinstance(self.config.sample_size							,    (list, tuple)		)
             else self.config.sample_size
         )
         __snake_case:						Union[str, Any]			  =						int(sample_size / (2 ** (len(self.config.block_out_channels		) - 1))		)
         __snake_case:						Optional[int]			  =						0.25




       def 							UpperCAmelCase__			(  self			:   int							,    A			:   List[str]							,    A			:   Optional[Any]=False		):
         if isinstance(A							,    (Encoder, Decoder)		):
           __snake_case:						str			  =						value




       def 							UpperCAmelCase__			(  self			:   str							,    A			:   bool = True		):
         __snake_case:						Union[str, Any]			  =						use_tiling




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         self.enable_tiling(A		)




       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						List[str]			  =						True




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						List[str]			  =						False




       @property
       # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         __snake_case:						Any			  =						{}

         def fn_recursive_add_processors(A			:   str							,    A			:   torch.nn.Module							,    A			:   Dict[str, AttentionProcessor]		):
           if hasattr(A							,    """set_processor"""		):
             __snake_case:						List[Any]			  =						module.processor

           for sub_name, child in module.named_children():
             fn_recursive_add_processors(f'''{name}.{sub_name}'''							,    A							,    A		)

           return processors

         for name, module in self.named_children():
           fn_recursive_add_processors(A							,    A							,    A		)

         return processors




       def 							UpperCAmelCase__			(  self			:   Optional[int]							,    A			:   Union[AttentionProcessor, Dict[str, AttentionProcessor]]		):
         __snake_case:						Any			  =						len(self.attn_processors.keys()		)

         if isinstance(A							,    A		) and len(A		) != count:
           raise ValueError(
               f'''A dict of processors was passed, but the number of processors {len(A		)} does not match the'''
               f''' number of attention layers: {count}. Please make sure to pass {count} processor classes.'''		)

         def fn_recursive_attn_processor(A			:   str							,    A			:   torch.nn.Module							,    A			:   Optional[Any]		):
           if hasattr(A							,    """set_processor"""		):
             if not isinstance(A							,    A		):
               module.set_processor(A		)
             else:
               module.set_processor(processor.pop(f'''{name}.processor'''		)		)

           for sub_name, child in module.named_children():
             fn_recursive_attn_processor(f'''{name}.{sub_name}'''							,    A							,    A		)

         for name, module in self.named_children():
           fn_recursive_attn_processor(A							,    A							,    A		)




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         self.set_attn_processor(AttnProcessor()		)




       @apply_forward_hook
       def 							UpperCAmelCase__			(  self			:   Optional[Any]							,    A			:   torch.FloatTensor							,    A			:   bool = True		):
         if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size):
           return self.tiled_encode(A							,    return_dict=A		)

         if self.use_slicing and x.shape[0] > 1:
           __snake_case:						List[Any]			  =						[self.encoder(A		) for x_slice in x.split(1		)]
           __snake_case:						Optional[Any]			  =						torch.cat(A		)
         else:
           __snake_case:						str			  =						self.encoder(A		)

         __snake_case:						Any			  =						self.quant_conv(A		)
         __snake_case:						Tuple			  =						DiagonalGaussianDistribution(A		)

         if not return_dict:
           return (posterior,)

         return AutoencoderKLOutput(latent_dist=A		)




       def 							UpperCAmelCase__			(  self			:   Tuple							,    A			:   torch.FloatTensor							,    A			:   bool = True		):
         if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size):
           return self.tiled_decode(A							,    return_dict=A		)

         __snake_case:						Optional[int]			  =						self.post_quant_conv(A		)
         __snake_case:						Union[str, Any]			  =						self.decoder(A		)

         if not return_dict:
           return (dec,)

         return DecoderOutput(sample=A		)




       @apply_forward_hook
       def 							UpperCAmelCase__			(  self			:   Tuple							,    A			:   torch.FloatTensor							,    A			:   bool = True		):
         if self.use_slicing and z.shape[0] > 1:
           __snake_case:						Union[str, Any]			  =						[self._decode(A		).sample for z_slice in z.split(1		)]
           __snake_case:						List[str]			  =						torch.cat(A		)
         else:
           __snake_case:						int			  =						self._decode(A		).sample

         if not return_dict:
           return (decoded,)

         return DecoderOutput(sample=A		)




       def 							UpperCAmelCase__			(  self			:   Any							,    A			:   Tuple							,    A			:   int							,    A			:   List[Any]		):
         __snake_case:						int			  =						min(a.shape[2]							,    b.shape[2]							,    A		)
         for y in range(A		):
           __snake_case:						Dict			  =						a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent)
         return b




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]							,    A			:   Optional[Any]							,    A			:   List[str]							,    A			:   List[str]		):
         __snake_case:						Dict			  =						min(a.shape[3]							,    b.shape[3]							,    A		)
         for x in range(A		):
           __snake_case:						Tuple			  =						a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent)
         return b




       def 							UpperCAmelCase__			(  self			:   int							,    A			:   torch.FloatTensor							,    A			:   bool = True		):
         __snake_case:						List[str]			  =						int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)		)
         __snake_case:						Dict			  =						int(self.tile_latent_min_size * self.tile_overlap_factor		)
         __snake_case:						Dict			  =						self.tile_latent_min_size - blend_extent

         # Split the image into 512x512 tiles and encode them separately.
         __snake_case:						Optional[int]			  =						[]
         for i in range(0							,    x.shape[2]							,    A		):
           __snake_case:						Optional[int]			  =						[]
           for j in range(0							,    x.shape[3]							,    A		):
             __snake_case:						int			  =						x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size]
             __snake_case:						Tuple			  =						self.encoder(A		)
             __snake_case:						Dict			  =						self.quant_conv(A		)
             row.append(A		)
           rows.append(A		)
         __snake_case:						Tuple			  =						[]
         for i, row in enumerate(A		):
           __snake_case:						str			  =						[]
           for j, tile in enumerate(A		):
             # blend the above tile and the left tile
             # to the current tile and add the current tile to the result row
             if i > 0:
               __snake_case:						Optional[Any]			  =						self.blend_v(rows[i - 1][j]							,    A							,    A		)
             if j > 0:
               __snake_case:						Tuple			  =						self.blend_h(row[j - 1]							,    A							,    A		)
             result_row.append(tile[:, :, :row_limit, :row_limit]		)
           result_rows.append(torch.cat(A							,    dim=3		)		)

         __snake_case:						Tuple			  =						torch.cat(A							,    dim=2		)
         __snake_case:						Optional[int]			  =						DiagonalGaussianDistribution(A		)

         if not return_dict:
           return (posterior,)

         return AutoencoderKLOutput(latent_dist=A		)




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]							,    A			:   torch.FloatTensor							,    A			:   bool = True		):
         __snake_case:						Optional[Any]			  =						int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)		)
         __snake_case:						str			  =						int(self.tile_sample_min_size * self.tile_overlap_factor		)
         __snake_case:						int			  =						self.tile_sample_min_size - blend_extent

         # Split z into overlapping 64x64 tiles and decode them separately.
         # The tiles have an overlap to avoid seams between tiles.
         __snake_case:						List[Any]			  =						[]
         for i in range(0							,    z.shape[2]							,    A		):
           __snake_case:						Optional[Any]			  =						[]
           for j in range(0							,    z.shape[3]							,    A		):
             __snake_case:						Dict			  =						z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size]
             __snake_case:						Any			  =						self.post_quant_conv(A		)
             __snake_case:						Optional[Any]			  =						self.decoder(A		)
             row.append(A		)
           rows.append(A		)
         __snake_case:						Optional[Any]			  =						[]
         for i, row in enumerate(A		):
           __snake_case:						Optional[Any]			  =						[]
           for j, tile in enumerate(A		):
             # blend the above tile and the left tile
             # to the current tile and add the current tile to the result row
             if i > 0:
               __snake_case:						Tuple			  =						self.blend_v(rows[i - 1][j]							,    A							,    A		)
             if j > 0:
               __snake_case:						List[str]			  =						self.blend_h(row[j - 1]							,    A							,    A		)
             result_row.append(tile[:, :, :row_limit, :row_limit]		)
           result_rows.append(torch.cat(A							,    dim=3		)		)

         __snake_case:						Dict			  =						torch.cat(A							,    dim=2		)
         if not return_dict:
           return (dec,)

         return DecoderOutput(sample=A		)






       def 							UpperCAmelCase__			(  self			:   List[Any]							,    A			:   torch.FloatTensor							,    A			:   bool = False							,    A			:   bool = True							,    A			:   Optional[torch.Generator] = None							,    ):
         __snake_case:						Optional[Any]			  =						sample
         __snake_case:						Union[str, Any]			  =						self.encode(A		).latent_dist
         if sample_posterior:
           __snake_case:						Optional[Any]			  =						posterior.sample(generator=A		)
         else:
           __snake_case:						Dict			  =						posterior.mode()
         __snake_case:						Any			  =						self.decode(A		).sample

         if not return_dict:
           return (dec,)

         return DecoderOutput(sample=A		)













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		)






