


'''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      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			str							       =       DownBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			List[str]							       =       "down"

     def 			lowerCamelCase__			(    self					:		Dict      )						->							Dict:
          __UpperCAmelCase     :			int  							=      [-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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       ResnetDownsampleBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       "down"

     def 			lowerCamelCase__			(    self					:		Any      )						->							Optional[int]:
          __UpperCAmelCase     :			Any  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       AttnDownBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       "down"

     def 			lowerCamelCase__			(    self					:		str      )						->							Optional[int]:
          __UpperCAmelCase     :			Optional[int]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Any							       =       CrossAttnDownBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       "down"

     def 			lowerCamelCase__			(    self					:		Dict      )						->							int:
          __UpperCAmelCase							,       __UpperCAmelCase     :			Dict  							=      super().prepare_init_args_and_inputs_for_common()
          __UpperCAmelCase     :			Optional[Any]  							=      32
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Dict      )						->							Tuple:
          __UpperCAmelCase     :			Optional[int]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Union[str, Any]							       =       SimpleCrossAttnDownBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Tuple							       =       "down"

     @property
     def 			lowerCamelCase__			(    self					:		Dict      )						->							Any:
          return super().get_dummy_input(include_encoder_hidden_states=_a      )

     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							int:
          __UpperCAmelCase							,       __UpperCAmelCase     :			Optional[int]  							=      super().prepare_init_args_and_inputs_for_common()
          __UpperCAmelCase     :			Dict  							=      32
          return init_dict, inputs_dict






     @unittest.skipIf(torch_device == '''mps'''							,			'''MPS result is not consistent'''      )
     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Optional[Any]:
          __UpperCAmelCase     :			List[str]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Tuple							       =       SkipDownBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Any							       =       "down"

     @property
     def 			lowerCamelCase__			(    self					:		Dict      )						->							Optional[int]:
          return super().get_dummy_input(include_skip_sample=_a      )






     def 			lowerCamelCase__			(    self					:		Dict      )						->							Union[str, Any]:
          __UpperCAmelCase     :			Tuple  							=      [-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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			str							       =       AttnSkipDownBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       "down"

     @property
     def 			lowerCamelCase__			(    self					:		List[str]      )						->							Any:
          return super().get_dummy_input(include_skip_sample=_a      )






     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Optional[Any]:
          __UpperCAmelCase     :			Union[str, Any]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       DownEncoderBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Dict							       =       "down"

     @property
     def 			lowerCamelCase__			(    self					:		Dict      )						->							Union[str, Any]:
          return super().get_dummy_input(include_temb=_a      )

     def 			lowerCamelCase__			(    self					:		Any      )						->							Dict:
          __UpperCAmelCase     :			Any  							=      {
              '''in_channels''': 32,
              '''out_channels''': 32,
          }
          __UpperCAmelCase     :			Optional[Any]  							=      self.dummy_input
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							Dict:
          __UpperCAmelCase     :			Tuple  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Union[str, Any]							       =       AttnDownEncoderBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Union[str, Any]							       =       "down"

     @property
     def 			lowerCamelCase__			(    self					:		List[str]      )						->							List[Any]:
          return super().get_dummy_input(include_temb=_a      )

     def 			lowerCamelCase__			(    self					:		Dict      )						->							Dict:
          __UpperCAmelCase     :			List[Any]  							=      {
              '''in_channels''': 32,
              '''out_channels''': 32,
          }
          __UpperCAmelCase     :			List[Any]  							=      self.dummy_input
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Tuple      )						->							Optional[Any]:
          __UpperCAmelCase     :			List[Any]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			str							       =       UNetMidBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Union[str, Any]							       =       "mid"

     def 			lowerCamelCase__			(    self					:		int      )						->							Optional[int]:
          __UpperCAmelCase     :			int  							=      {
              '''in_channels''': 32,
              '''temb_channels''': 128,
          }
          __UpperCAmelCase     :			int  							=      self.dummy_input
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Any      )						->							List[str]:
          __UpperCAmelCase     :			List[Any]  							=      [-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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       UNetMidBlockaDCrossAttn  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       "mid"

     def 			lowerCamelCase__			(    self					:		str      )						->							int:
          __UpperCAmelCase							,       __UpperCAmelCase     :			List[Any]  							=      super().prepare_init_args_and_inputs_for_common()
          __UpperCAmelCase     :			List[Any]  							=      32
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Dict      )						->							Tuple:
          __UpperCAmelCase     :			int  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       UNetMidBlockaDSimpleCrossAttn  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       "mid"

     @property
     def 			lowerCamelCase__			(    self					:		Dict      )						->							Dict:
          return super().get_dummy_input(include_encoder_hidden_states=_a      )

     def 			lowerCamelCase__			(    self					:		int      )						->							Any:
          __UpperCAmelCase							,       __UpperCAmelCase     :			Tuple  							=      super().prepare_init_args_and_inputs_for_common()
          __UpperCAmelCase     :			List[Any]  							=      32
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Optional[int]:
          __UpperCAmelCase     :			Any  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Any							       =       UpBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       "up"

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






     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Optional[Any]:
          __UpperCAmelCase     :			Any  							=      [-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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Any							       =       ResnetUpsampleBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       "up"

     @property
     def 			lowerCamelCase__			(    self					:		List[str]      )						->							str:
          return super().get_dummy_input(include_res_hidden_states_tuple=_a      )






     def 			lowerCamelCase__			(    self					:		str      )						->							Union[str, Any]:
          __UpperCAmelCase     :			Union[str, Any]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			List[str]							       =       CrossAttnUpBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			List[Any]							       =       "up"

     @property
     def 			lowerCamelCase__			(    self					:		Dict      )						->							str:
          return super().get_dummy_input(include_res_hidden_states_tuple=_a      )

     def 			lowerCamelCase__			(    self					:		int      )						->							Tuple:
          __UpperCAmelCase							,       __UpperCAmelCase     :			Tuple  							=      super().prepare_init_args_and_inputs_for_common()
          __UpperCAmelCase     :			Dict  							=      32
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		List[str]      )						->							Optional[int]:
          __UpperCAmelCase     :			int  							=      [-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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       SimpleCrossAttnUpBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Any							       =       "up"

     @property
     def 			lowerCamelCase__			(    self					:		int      )						->							Union[str, Any]:
          return super().get_dummy_input(include_res_hidden_states_tuple=_a							,			include_encoder_hidden_states=_a      )

     def 			lowerCamelCase__			(    self					:		str      )						->							Optional[Any]:
          __UpperCAmelCase							,       __UpperCAmelCase     :			List[Any]  							=      super().prepare_init_args_and_inputs_for_common()
          __UpperCAmelCase     :			Any  							=      32
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Dict:
          __UpperCAmelCase     :			Union[str, Any]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Tuple							       =       AttnUpBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       "up"

     @property
     def 			lowerCamelCase__			(    self					:		List[str]      )						->							Any:
          return super().get_dummy_input(include_res_hidden_states_tuple=_a      )






     @unittest.skipIf(torch_device == '''mps'''							,			'''MPS result is not consistent'''      )
     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Any:
          __UpperCAmelCase     :			Optional[int]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       SkipUpBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			List[Any]							       =       "up"

     @property
     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							List[str]:
          return super().get_dummy_input(include_res_hidden_states_tuple=_a      )






     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							Tuple:
          __UpperCAmelCase     :			List[str]  							=      [-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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       AttnSkipUpBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       "up"

     @property
     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							str:
          return super().get_dummy_input(include_res_hidden_states_tuple=_a      )






     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							Any:
          __UpperCAmelCase     :			Dict  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       UpDecoderBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			Tuple							       =       "up"

     @property
     def 			lowerCamelCase__			(    self					:		Optional[Any]      )						->							int:
          return super().get_dummy_input(include_temb=_a      )

     def 			lowerCamelCase__			(    self					:		Any      )						->							Union[str, Any]:
          __UpperCAmelCase     :			str  							=      {'''in_channels''': 32, '''out_channels''': 32}

          __UpperCAmelCase     :			List[Any]  							=      self.dummy_input
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							int:
          __UpperCAmelCase     :			List[str]  							=      [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(_a      )



class      a    (		__lowercase     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Any							       =       AttnUpDecoderBlockaD  # noqa F405
     SCREAMING_SNAKE_CASE	:			List[str]							       =       "up"

     @property
     def 			lowerCamelCase__			(    self					:		str      )						->							Tuple:
          return super().get_dummy_input(include_temb=_a      )

     def 			lowerCamelCase__			(    self					:		str      )						->							Optional[Any]:
          __UpperCAmelCase     :			List[Any]  							=      {'''in_channels''': 32, '''out_channels''': 32}

          __UpperCAmelCase     :			str  							=      self.dummy_input
          return init_dict, inputs_dict






     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							Union[str, Any]:
          __UpperCAmelCase     :			Optional[int]  							=      [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(_a      )



'''simple docstring'''



import requests

__UpperCAmelCase      :Union[str, Any]			    =       "https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey="




def      _a     (						_lowercase :     str  ):





     '''simple docstring'''






     __UpperCAmelCase     :			Union[str, Any]  							=      requests.get(_NEWS_API + bbc_news_api_key  ).json()
     # each article in the list is a dict
     for i, article in enumerate(bbc_news_page['''articles''']      , 1  ):
          print(F'{i}.) {article["title"]}'  )


if __name__ == "__main__":
      fetch_bbc_news(bbc_news_api_key="<Your BBC News API key goes here>")