

'''simple docstring'''

import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin






@skip_mps
class    snake_case     (      lowercase_,						lowercase_,						unittest.TestCase		):






				"""simple docstring"""
				_a    	=     IFImgaImgSuperResolutionPipeline
				_a    	=     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
				_a    	=     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}		)
				_a    	=     PipelineTesterMixin.required_optional_params - {"""latents"""}



				def   a__					(    self       )     ->							str:
											return self._get_superresolution_dummy_components()



				def   a__					(    self,     _lowercase,     _lowercase=0       )     ->							List[Any]:
											if str(_lowercase       ).startswith('mps'       ):
																		SCREAMING_SNAKE_CASE_				=				torch.manual_seed(_lowercase       )
											else:
																		SCREAMING_SNAKE_CASE_				=				torch.Generator(device=_lowercase       ).manual_seed(_lowercase       )

											SCREAMING_SNAKE_CASE_				=				floats_tensor((1, 3, 32, 32),     rng=random.Random(_lowercase       )       ).to(_lowercase       )
											SCREAMING_SNAKE_CASE_				=				floats_tensor((1, 3, 16, 16),     rng=random.Random(_lowercase       )       ).to(_lowercase       )

											SCREAMING_SNAKE_CASE_				=				{
											    'prompt': 'A painting of a squirrel eating a burger',
											    'image': image,
											    'original_image': original_image,
											    'generator': generator,
											    'num_inference_steps': 2,
											    'output_type': 'numpy',
											}

											return inputs



				@unittest.skipIf(
				    torch_device != 'cuda' or not is_xformers_available(),     reason='XFormers attention is only available with CUDA and `xformers` installed',     )
				def   a__					(    self       )     ->							List[Any]:
											self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3       )



				def   a__					(    self       )     ->							List[str]:
											self._test_save_load_optional_components()



				@unittest.skipIf(torch_device != 'cuda',     reason='float16 requires CUDA'       )
				def   a__					(    self       )     ->							Union[str, Any]:
											# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
											super().test_save_load_floataa(expected_max_diff=1E-1       )



				def   a__					(    self       )     ->							str:
											self._test_attention_slicing_forward_pass(expected_max_diff=1E-2       )



				def   a__					(    self       )     ->							Optional[int]:
											self._test_save_load_local()





				def   a__					(    self       )     ->							List[Any]:
											self._test_inference_batch_single_identical(
											    expected_max_diff=1E-2,     )








'''simple docstring'''

def 							_UpperCamelCase				(   lowerCAmelCase__:					int = 1000   )      -> int:
							SCREAMING_SNAKE_CASE_				=				2**power
							SCREAMING_SNAKE_CASE_				=				str(lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				list(lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				0

							for i in list_num:
														sum_of_num += int(lowerCAmelCase__   )

							return sum_of_num


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE							:				Tuple     	=			int(input("Enter the power of 2: ").strip())
							print("2 ^ ", power, " = ", 2**power)
							SCREAMING_SNAKE_CASE							:				str     	=			solution(power)
							print("Sum of the digits is: ", result)





