


'''simple docstring'''




import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin

class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Dict		=     DownBlockaD  # noqa F405
     lowerCamelCase				:	List[str]		=     '''down'''





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  Any:
        lowerCAmelCase     =			[-0.0_232, -0.9_869, 0.8_054, -0.0_637, -0.1_688, -1.4_264, 0.4_470, -1.3_394, 0.0_904]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	int		=     ResnetDownsampleBlockaD  # noqa F405
     lowerCamelCase				:	int		=     '''down'''





     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Dict:
        lowerCAmelCase     =			[0.0_710, 0.2_410, -0.7_320, -1.0_757, -1.1_343, 0.3_540, -0.0_133, -0.2_576, 0.0_948]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Optional[int]		=     AttnDownBlockaD  # noqa F405
     lowerCamelCase				:	Union[str, Any]		=     '''down'''





     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  List[str]:
        lowerCAmelCase     =			[0.0_636, 0.8_964, -0.6_234, -1.0_131, 0.0_844, 0.4_935, 0.3_437, 0.0_911, -0.2_957]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	str		=     CrossAttnDownBlockaD  # noqa F405
     lowerCamelCase				:	List[str]		=     '''down'''





     def 							__UpperCAmelCase      ( self       :      Dict    )				->  Dict:
        lowerCAmelCase     ,  lowerCAmelCase     =			super().prepare_init_args_and_inputs_for_common()
        lowerCAmelCase     =			3_2
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  Union[str, Any]:
        lowerCAmelCase     =			[0.2_238, -0.7_396, -0.2_255, -0.3_829, 0.1_925, 1.1_665, 0.0_603, -0.7_295, 0.1_983]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Optional[int]		=     SimpleCrossAttnDownBlockaD  # noqa F405
     lowerCamelCase				:	str		=     '''down'''





     @property
     def 							__UpperCAmelCase      ( self       :      Dict    )				->  str:
        return super().get_dummy_input(include_encoder_hidden_states=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      int    )				->  str:
        lowerCAmelCase     ,  lowerCAmelCase     =			super().prepare_init_args_and_inputs_for_common()
        lowerCAmelCase     =			3_2
        return init_dict, inputs_dict





     @unittest.skipIf(torch_device == 'mps'    ,      'MPS result is not consistent'    )
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Union[str, Any]:
        lowerCAmelCase     =			[0.7_921, -0.0_992, -0.1_962, -0.7_695, -0.4_242, 0.7_804, 0.4_737, 0.2_765, 0.3_338]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	List[str]		=     SkipDownBlockaD  # noqa F405
     lowerCamelCase				:	int		=     '''down'''





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





     def 							__UpperCAmelCase      ( self       :      int    )				->  int:
        lowerCAmelCase     =			[-0.0_845, -0.2_087, -0.2_465, 0.0_971, 0.1_900, -0.0_484, 0.2_664, 0.4_179, 0.5_069]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Union[str, Any]		=     AttnSkipDownBlockaD  # noqa F405
     lowerCamelCase				:	str		=     '''down'''





     @property
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  str:
        return super().get_dummy_input(include_skip_sample=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      int    )				->  str:
        lowerCAmelCase     =			[0.5_539, 0.1_609, 0.4_924, 0.0_537, -0.1_995, 0.4_050, 0.0_979, -0.2_721, -0.0_642]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Optional[Any]		=     DownEncoderBlockaD  # noqa F405
     lowerCamelCase				:	Optional[Any]		=     '''down'''





     @property
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Dict:
        return super().get_dummy_input(include_temb=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Union[str, Any]:
        lowerCAmelCase     =			{
            'in_channels': 3_2,
            'out_channels': 3_2,
        }
        lowerCAmelCase     =			self.dummy_input
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    )				->  Optional[int]:
        lowerCAmelCase     =			[1.1_102, 0.5_302, 0.4_872, -0.0_023, -0.8_042, 0.0_483, -0.3_489, -0.5_632, 0.7_626]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	List[Any]		=     AttnDownEncoderBlockaD  # noqa F405
     lowerCamelCase				:	Dict		=     '''down'''





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





     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  Optional[int]:
        lowerCAmelCase     =			{
            'in_channels': 3_2,
            'out_channels': 3_2,
        }
        lowerCAmelCase     =			self.dummy_input
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      int    )				->  List[Any]:
        lowerCAmelCase     =			[0.8_966, -0.1_486, 0.8_568, 0.8_141, -0.9_046, -0.1_342, -0.0_972, -0.7_417, 0.1_538]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Union[str, Any]		=     UNetMidBlockaD  # noqa F405
     lowerCamelCase				:	Union[str, Any]		=     '''mid'''





     def 							__UpperCAmelCase      ( self       :      Dict    )				->  Optional[int]:
        lowerCAmelCase     =			{
            'in_channels': 3_2,
            'temb_channels': 1_2_8,
        }
        lowerCAmelCase     =			self.dummy_input
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      int    )				->  str:
        lowerCAmelCase     =			[-0.1_062, 1.7_248, 0.3_494, 1.4_569, -0.0_910, -1.2_421, -0.9_984, 0.6_736, 1.0_028]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	List[Any]		=     UNetMidBlockaDCrossAttn  # noqa F405
     lowerCamelCase				:	List[Any]		=     '''mid'''





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    )				->  List[str]:
        lowerCAmelCase     ,  lowerCAmelCase     =			super().prepare_init_args_and_inputs_for_common()
        lowerCAmelCase     =			3_2
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      int    )				->  Optional[int]:
        lowerCAmelCase     =			[0.0_187, 2.4_220, 0.4_484, 1.1_203, -0.6_121, -1.5_122, -0.8_270, 0.7_851, 1.8_335]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	int		=     UNetMidBlockaDSimpleCrossAttn  # noqa F405
     lowerCamelCase				:	List[str]		=     '''mid'''





     @property
     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  Tuple:
        return super().get_dummy_input(include_encoder_hidden_states=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  Union[str, Any]:
        lowerCAmelCase     ,  lowerCAmelCase     =			super().prepare_init_args_and_inputs_for_common()
        lowerCAmelCase     =			3_2
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  List[str]:
        lowerCAmelCase     =			[0.7_143, 1.9_974, 0.5_448, 1.3_977, 0.1_282, -1.1_237, -1.4_238, 0.5_530, 0.8_880]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Optional[int]		=     UpBlockaD  # noqa F405
     lowerCamelCase				:	int		=     '''up'''





     @property
     def 							__UpperCAmelCase      ( self       :      Optional[Any]    )				->  Optional[int]:
        return super().get_dummy_input(include_res_hidden_states_tuple=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  int:
        lowerCAmelCase     =			[-0.2_041, -0.4_165, -0.3_022, 0.0_041, -0.6_628, -0.7_053, 0.1_928, -0.0_325, 0.0_523]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Any		=     ResnetUpsampleBlockaD  # noqa F405
     lowerCamelCase				:	List[str]		=     '''up'''





     @property
     def 							__UpperCAmelCase      ( self       :      List[str]    )				->  Dict:
        return super().get_dummy_input(include_res_hidden_states_tuple=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  Union[str, Any]:
        lowerCAmelCase     =			[0.2_287, 0.3_549, -0.1_346, 0.4_797, -0.1_715, -0.9_649, 0.7_305, -0.5_864, -0.6_244]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	List[str]		=     CrossAttnUpBlockaD  # noqa F405
     lowerCamelCase				:	Tuple		=     '''up'''





     @property
     def 							__UpperCAmelCase      ( self       :      Dict    )				->  Optional[Any]:
        return super().get_dummy_input(include_res_hidden_states_tuple=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      List[str]    )				->  Union[str, Any]:
        lowerCAmelCase     ,  lowerCAmelCase     =			super().prepare_init_args_and_inputs_for_common()
        lowerCAmelCase     =			3_2
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  Dict:
        lowerCAmelCase     =			[-0.1_403, -0.3_515, -0.0_420, -0.1_425, 0.3_167, 0.5_094, -0.2_181, 0.5_931, 0.5_582]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Tuple		=     SimpleCrossAttnUpBlockaD  # noqa F405
     lowerCamelCase				:	Dict		=     '''up'''





     @property
     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  Union[str, Any]:
        return super().get_dummy_input(include_res_hidden_states_tuple=UpperCAmelCase__    ,      include_encoder_hidden_states=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  Tuple:
        lowerCAmelCase     ,  lowerCAmelCase     =			super().prepare_init_args_and_inputs_for_common()
        lowerCAmelCase     =			3_2
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  List[Any]:
        lowerCAmelCase     =			[0.2_645, 0.1_480, 0.0_909, 0.8_044, -0.9_758, -0.9_083, 0.0_994, -1.1_453, -0.7_402]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	int		=     AttnUpBlockaD  # noqa F405
     lowerCamelCase				:	List[str]		=     '''up'''





     @property
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Union[str, Any]:
        return super().get_dummy_input(include_res_hidden_states_tuple=UpperCAmelCase__    )





     @unittest.skipIf(torch_device == 'mps'    ,      'MPS result is not consistent'    )
     def 							__UpperCAmelCase      ( self       :      Optional[Any]    )				->  str:
        lowerCAmelCase     =			[0.0_979, 0.1_326, 0.0_021, 0.0_659, 0.2_249, 0.0_059, 0.1_132, 0.5_952, 0.1_033]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Tuple		=     SkipUpBlockaD  # noqa F405
     lowerCamelCase				:	str		=     '''up'''





     @property
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Union[str, Any]:
        return super().get_dummy_input(include_res_hidden_states_tuple=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    )				->  int:
        lowerCAmelCase     =			[-0.0_893, -0.1_234, -0.1_506, -0.0_332, 0.0_123, -0.0_211, 0.0_566, 0.0_143, 0.0_362]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Optional[Any]		=     AttnSkipUpBlockaD  # noqa F405
     lowerCamelCase				:	List[Any]		=     '''up'''





     @property
     def 							__UpperCAmelCase      ( self       :      int    )				->  Tuple:
        return super().get_dummy_input(include_res_hidden_states_tuple=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Any    )				->  List[Any]:
        lowerCAmelCase     =			[0.0_361, 0.0_617, 0.2_787, -0.0_350, 0.0_342, 0.3_421, -0.0_843, 0.0_913, 0.3_015]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	str		=     UpDecoderBlockaD  # noqa F405
     lowerCamelCase				:	List[str]		=     '''up'''





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





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  Dict:
        lowerCAmelCase     =			{'in_channels': 3_2, 'out_channels': 3_2}

        lowerCAmelCase     =			self.dummy_input
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    )				->  str:
        lowerCAmelCase     =			[0.4_404, 0.1_998, -0.9_886, -0.3_320, -0.3_128, -0.7_034, -0.6_955, -0.2_338, -0.3_137]
        super().test_output(UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase       ,	unittest.TestCase		):
     lowerCamelCase				:	Dict		=     AttnUpDecoderBlockaD  # noqa F405
     lowerCamelCase				:	Tuple		=     '''up'''





     @property
     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  int:
        return super().get_dummy_input(include_temb=UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  List[str]:
        lowerCAmelCase     =			{'in_channels': 3_2, 'out_channels': 3_2}

        lowerCAmelCase     =			self.dummy_input
        return init_dict, inputs_dict





     def 							__UpperCAmelCase      ( self       :      List[str]    )				->  Optional[int]:
        lowerCAmelCase     =			[0.6_738, 0.4_491, 0.1_055, 1.0_710, 0.7_316, 0.3_339, 0.3_352, 0.1_023, 0.3_568]
        super().test_output(UpperCAmelCase__    )









'''simple docstring'''




class 		UpperCAmelCase_      :





     def __init__( self       :      List[str]    ,      UpperCAmelCase__       :      list[int]    )				->  None:
        lowerCAmelCase     =			len(UpperCAmelCase__    )
        lowerCAmelCase     =			[0] * len_array

        if len_array > 0:
           lowerCAmelCase     =			array[0]

        for i in range(1    ,      UpperCAmelCase__    ):
           lowerCAmelCase     =			self.prefix_sum[i - 1] + array[i]





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    )				->  int:
        if start == 0:
           return self.prefix_sum[end]

        return self.prefix_sum[end] - self.prefix_sum[start - 1]





     def 							__UpperCAmelCase      ( self       :      int    ,      UpperCAmelCase__       :      int    )				->  bool:
        lowerCAmelCase     =			{0}
        for sum_item in self.prefix_sum:
           if sum_item - target_sum in sums:
              return True

           sums.add(UpperCAmelCase__    )

        return False


if __name__ == "__main__":
       import doctest

       doctest.testmod()





