
"""simple docstring"""

import random
import unittest

import torch

from diffusers import IFInpaintingSuperResolutionPipeline
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_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin






@skip_mps
class 	_lowercase       (    __UpperCAmelCase    ,	__UpperCAmelCase    ,	unittest.TestCase		):
	lowercase_				=     IFInpaintingSuperResolutionPipeline
	lowercase_				=     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'width', 'height'}
	lowercase_				=     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({'original_image'}		)
	lowercase_				=     PipelineTesterMixin.required_optional_params - {'latents'}




	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			return self._get_superresolution_dummy_components()




	def       _UpperCamelCase   (			self		,			UpperCAmelCase_		,			UpperCAmelCase_=0 )		->							Any:
			if str(UpperCAmelCase_ ).startswith('mps' ):
					lowerCamelCase					:      Optional[int]          =   torch.manual_seed(UpperCAmelCase_ )
			else:
					lowerCamelCase					:      Optional[Any]          =   torch.Generator(device=UpperCAmelCase_ ).manual_seed(UpperCAmelCase_ )

			lowerCamelCase					:      Dict          =   floats_tensor((1, 3, 16, 16)		,			rng=random.Random(UpperCAmelCase_ ) ).to(UpperCAmelCase_ )
			lowerCamelCase					:      Union[str, Any]          =   floats_tensor((1, 3, 32, 32)		,			rng=random.Random(UpperCAmelCase_ ) ).to(UpperCAmelCase_ )
			lowerCamelCase					:      Union[str, Any]          =   floats_tensor((1, 3, 32, 32)		,			rng=random.Random(UpperCAmelCase_ ) ).to(UpperCAmelCase_ )

			lowerCamelCase					:      List[str]          =   {
			    'prompt': 'A painting of a squirrel eating a burger',
			    'image': image,
			    'original_image': original_image,
			    'mask_image': mask_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       _UpperCamelCase   (			self )		->							List[str]:
			self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 )




	def       _UpperCamelCase   (			self )		->							Dict:
			self._test_save_load_optional_components()




	@unittest.skipIf(torch_device != 'cuda'		,			reason='float16 requires CUDA' )
	def       _UpperCamelCase   (			self )		->							List[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       _UpperCamelCase   (			self )		->							str:
			self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 )




	def       _UpperCamelCase   (			self )		->							Any:
			self._test_save_load_local()




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








"""simple docstring"""

def 		UpperCAmelCase (		a_ = 1000      ):





		'''simple docstring'''


		lowerCamelCase					:      Dict          =   2**power
		lowerCamelCase					:      List[str]          =   str(a_      )
		lowerCamelCase					:      Dict          =   list(a_      )
		lowerCamelCase					:      Optional[Any]          =   0

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

		return sum_of_num


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






