import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


@skip_mps
class 	lowerCamelCase_     (   UpperCAmelCase_						,	UpperCAmelCase_						,	unittest.TestCase ):






    '''simple docstring'''






    a__	:						str						=      StableDiffusionPanoramaPipeline
    a__	:						List[Any]						=      TEXT_TO_IMAGE_PARAMS
    a__	:						Union[str, Any]						=      TEXT_TO_IMAGE_BATCH_PARAMS
    a__	:						int						=      TEXT_TO_IMAGE_IMAGE_PARAMS
    a__	:						Tuple						=      TEXT_TO_IMAGE_IMAGE_PARAMS







    def 			UpperCamelCase__   (	self)       ->	Dict:
        torch.manual_seed(0)
        __UpperCamelCase     :List[str]			  =		UNetaDConditionModel(
            block_out_channels=(32, 64) , layers_per_block=1 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , )
        __UpperCamelCase     :Union[str, Any]			  =		DDIMScheduler()
        torch.manual_seed(0)
        __UpperCamelCase     :Dict			  =		AutoencoderKL(
            block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , )
        torch.manual_seed(0)
        __UpperCamelCase     :Dict			  =		CLIPTextConfig(
            bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-0_5 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_000 , )
        __UpperCamelCase     :List[str]			  =		CLIPTextModel(__a)
        __UpperCamelCase     :List[Any]			  =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

        __UpperCamelCase     :Dict			  =		{
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''safety_checker''': None,
            '''feature_extractor''': None,
        }
        return components







    def 			UpperCamelCase__   (	self , __lowercase , __lowercase=0)       ->	int:
        __UpperCamelCase     :List[str]			  =		torch.manual_seed(__a)
        __UpperCamelCase     :Optional[int]			  =		{
            '''prompt''': '''a photo of the dolomites''',
            '''generator''': generator,
            # Setting height and width to None to prevent OOMs on CPU.
            '''height''': None,
            '''width''': None,
            '''num_inference_steps''': 1,
            '''guidance_scale''': 6.0,
            '''output_type''': '''numpy''',
        }
        return inputs







    def 			UpperCamelCase__   (	self)       ->	Dict:
        __UpperCamelCase     :int			  =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        __UpperCamelCase     :Tuple			  =		self.get_dummy_components()
        __UpperCamelCase     :Union[str, Any]			  =		StableDiffusionPanoramaPipeline(**__a)
        __UpperCamelCase     :str			  =		sd_pipe.to(__a)
        sd_pipe.set_progress_bar_config(disable=__a)

        __UpperCamelCase     :str			  =		self.get_dummy_inputs(__a)
        __UpperCamelCase     :Optional[int]			  =		sd_pipe(**__a).images
        __UpperCamelCase     :str			  =		image[0, -3:, -3:, -1]
        assert image.shape == (1, 64, 64, 3)

        __UpperCamelCase     :Any			  =		np.array([0.61_86, 0.53_74, 0.49_15, 0.41_35, 0.41_14, 0.45_63, 0.51_28, 0.49_77, 0.47_57])

        assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







    def 			UpperCamelCase__   (	self)       ->	Optional[int]:
        super().test_inference_batch_consistent(batch_sizes=[1, 2])







    def 			UpperCamelCase__   (	self)       ->	Tuple:
        super().test_inference_batch_single_identical(batch_size=2 , expected_max_diff=3.2_5E-3)







    def 			UpperCamelCase__   (	self)       ->	List[str]:
        __UpperCamelCase     :Tuple			  =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        __UpperCamelCase     :List[Any]			  =		self.get_dummy_components()
        __UpperCamelCase     :Dict			  =		StableDiffusionPanoramaPipeline(**__a)
        __UpperCamelCase     :int			  =		sd_pipe.to(__a)
        sd_pipe.set_progress_bar_config(disable=__a)

        __UpperCamelCase     :List[str]			  =		self.get_dummy_inputs(__a)
        __UpperCamelCase     :Optional[Any]			  =		'''french fries'''
        __UpperCamelCase     :List[str]			  =		sd_pipe(**__a , negative_prompt=__a)
        __UpperCamelCase     :Optional[Any]			  =		output.images
        __UpperCamelCase     :int			  =		image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)

        __UpperCamelCase     :Any			  =		np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57])

        assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







    def 			UpperCamelCase__   (	self)       ->	Any:
        __UpperCamelCase     :str			  =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        __UpperCamelCase     :Optional[int]			  =		self.get_dummy_components()
        __UpperCamelCase     :Any			  =		StableDiffusionPanoramaPipeline(**__a)
        __UpperCamelCase     :Union[str, Any]			  =		sd_pipe.to(__a)
        sd_pipe.set_progress_bar_config(disable=__a)

        __UpperCamelCase     :str			  =		self.get_dummy_inputs(__a)
        __UpperCamelCase     :Optional[int]			  =		sd_pipe(**__a , view_batch_size=2)
        __UpperCamelCase     :Any			  =		output.images
        __UpperCamelCase     :List[str]			  =		image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)

        __UpperCamelCase     :Optional[Any]			  =		np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57])

        assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







    def 			UpperCamelCase__   (	self)       ->	str:
        __UpperCamelCase     :str			  =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        __UpperCamelCase     :Optional[Any]			  =		self.get_dummy_components()
        __UpperCamelCase     :Optional[Any]			  =		EulerAncestralDiscreteScheduler(
            beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''')
        __UpperCamelCase     :int			  =		StableDiffusionPanoramaPipeline(**__a)
        __UpperCamelCase     :str			  =		sd_pipe.to(__a)
        sd_pipe.set_progress_bar_config(disable=__a)

        __UpperCamelCase     :Union[str, Any]			  =		self.get_dummy_inputs(__a)
        __UpperCamelCase     :int			  =		sd_pipe(**__a).images
        __UpperCamelCase     :int			  =		image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)

        __UpperCamelCase     :int			  =		np.array([0.40_24, 0.65_10, 0.49_01, 0.53_78, 0.58_13, 0.56_22, 0.47_95, 0.44_67, 0.49_52])

        assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







    def 			UpperCamelCase__   (	self)       ->	Any:
        __UpperCamelCase     :Optional[Any]			  =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
        __UpperCamelCase     :Optional[int]			  =		self.get_dummy_components()
        __UpperCamelCase     :Tuple			  =		PNDMScheduler(
            beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''' , skip_prk_steps=__a)
        __UpperCamelCase     :List[Any]			  =		StableDiffusionPanoramaPipeline(**__a)
        __UpperCamelCase     :Dict			  =		sd_pipe.to(__a)
        sd_pipe.set_progress_bar_config(disable=__a)

        __UpperCamelCase     :int			  =		self.get_dummy_inputs(__a)
        __UpperCamelCase     :List[Any]			  =		sd_pipe(**__a).images
        __UpperCamelCase     :Tuple			  =		image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)

        __UpperCamelCase     :Optional[Any]			  =		np.array([0.63_91, 0.62_91, 0.48_61, 0.51_34, 0.55_52, 0.45_78, 0.50_32, 0.50_23, 0.45_39])

        assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2


@slow
@require_torch_gpu
class 	lowerCamelCase_     (   unittest.TestCase ):






    '''simple docstring'''






    def 			UpperCamelCase__   (	self)       ->	Tuple:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







    def 			UpperCamelCase__   (	self , __lowercase=0)       ->	List[str]:
        __UpperCamelCase     :int			  =		torch.manual_seed(__a)
        __UpperCamelCase     :Dict			  =		{
            '''prompt''': '''a photo of the dolomites''',
            '''generator''': generator,
            '''num_inference_steps''': 3,
            '''guidance_scale''': 7.5,
            '''output_type''': '''numpy''',
        }
        return inputs







    def 			UpperCamelCase__   (	self)       ->	Any:
        __UpperCamelCase     :Dict			  =		'''stabilityai/stable-diffusion-2-base'''
        __UpperCamelCase     :str			  =		DDIMScheduler.from_pretrained(__a , subfolder='''scheduler''')
        __UpperCamelCase     :str			  =		StableDiffusionPanoramaPipeline.from_pretrained(__a , scheduler=__a , safety_checker=__a)
        pipe.to(__a)
        pipe.set_progress_bar_config(disable=__a)
        pipe.enable_attention_slicing()

        __UpperCamelCase     :Any			  =		self.get_inputs()
        __UpperCamelCase     :Optional[int]			  =		pipe(**__a).images
        __UpperCamelCase     :Union[str, Any]			  =		image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 512, 2_048, 3)

        __UpperCamelCase     :Dict			  =		np.array(
            [
                0.36_96_83_92,
                0.27_02_53_72,
                0.32_44_67_66,
                0.28_37_93_87,
                0.36_36_32_74,
                0.30_73_33_47,
                0.27_10_00_27,
                0.27_05_41_25,
                0.25_53_60_96,
            ])

        assert np.abs(expected_slice - image_slice).max() < 1E-2







    def 			UpperCamelCase__   (	self)       ->	str:
        __UpperCamelCase     :List[Any]			  =		StableDiffusionPanoramaPipeline.from_pretrained(
            '''stabilityai/stable-diffusion-2-base''' , safety_checker=__a)
        __UpperCamelCase     :str			  =		LMSDiscreteScheduler.from_config(pipe.scheduler.config)
        pipe.to(__a)
        pipe.set_progress_bar_config(disable=__a)
        pipe.enable_attention_slicing()

        __UpperCamelCase     :List[str]			  =		self.get_inputs()
        __UpperCamelCase     :List[Any]			  =		pipe(**__a).images
        __UpperCamelCase     :Union[str, Any]			  =		image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 512, 2_048, 3)

        __UpperCamelCase     :List[str]			  =		np.array(
            [
                [
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                ]
            ])

        assert np.abs(expected_slice - image_slice).max() < 1E-3







    def 			UpperCamelCase__   (	self)       ->	Dict:
        __UpperCamelCase     :List[str]			  =		0

        def callback_fn(__lowercase , __lowercase , __lowercase) -> None:
            __UpperCamelCase     :Union[str, Any]			  =		True
            nonlocal number_of_steps
            number_of_steps += 1
            if step == 1:
                __UpperCamelCase     :Union[str, Any]			  =		latents.detach().cpu().numpy()
                assert latents.shape == (1, 4, 64, 256)
                __UpperCamelCase     :Dict			  =		latents[0, -3:, -3:, -1]

                __UpperCamelCase     :List[Any]			  =		np.array(
                    [
                        0.18_68_18_69,
                        0.33_90_78_16,
                        0.5_36_12_76,
                        0.14_43_28_65,
                        -0.02_85_66_11,
                        -0.73_94_11_23,
                        0.23_39_79_87,
                        0.47_32_26_82,
                        -0.37_82_31_64,
                    ])
                assert np.abs(latents_slice.flatten() - expected_slice).max() < 5E-2
            elif step == 2:
                __UpperCamelCase     :int			  =		latents.detach().cpu().numpy()
                assert latents.shape == (1, 4, 64, 256)
                __UpperCamelCase     :int			  =		latents[0, -3:, -3:, -1]

                __UpperCamelCase     :Tuple			  =		np.array(
                    [
                        0.18_53_96_45,
                        0.33_98_72_48,
                        0.5_37_85_59,
                        0.14_43_71_42,
                        -0.02_45_52_61,
                        -0.7_33_83_17,
                        0.23_99_07_55,
                        0.47_35_62_72,
                        -0.3_78_65_05,
                    ])

                assert np.abs(latents_slice.flatten() - expected_slice).max() < 5E-2

        __UpperCamelCase     :str			  =		False

        __UpperCamelCase     :Dict			  =		'''stabilityai/stable-diffusion-2-base'''
        __UpperCamelCase     :List[Any]			  =		DDIMScheduler.from_pretrained(__a , subfolder='''scheduler''')
        __UpperCamelCase     :Optional[Any]			  =		StableDiffusionPanoramaPipeline.from_pretrained(__a , scheduler=__a , safety_checker=__a)
        __UpperCamelCase     :Optional[int]			  =		pipe.to(__a)
        pipe.set_progress_bar_config(disable=__a)
        pipe.enable_attention_slicing()

        __UpperCamelCase     :int			  =		self.get_inputs()
        pipe(**__a , callback=__a , callback_steps=1)
        assert callback_fn.has_been_called
        assert number_of_steps == 3







    def 			UpperCamelCase__   (	self)       ->	Optional[int]:
        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()
        torch.cuda.reset_peak_memory_stats()

        __UpperCamelCase     :Dict			  =		'''stabilityai/stable-diffusion-2-base'''
        __UpperCamelCase     :Any			  =		DDIMScheduler.from_pretrained(__a , subfolder='''scheduler''')
        __UpperCamelCase     :int			  =		StableDiffusionPanoramaPipeline.from_pretrained(__a , scheduler=__a , safety_checker=__a)
        __UpperCamelCase     :Dict			  =		pipe.to(__a)
        pipe.set_progress_bar_config(disable=__a)
        pipe.enable_attention_slicing(1)
        pipe.enable_sequential_cpu_offload()

        __UpperCamelCase     :Optional[Any]			  =		self.get_inputs()
        __UpperCamelCase     :int			  =		pipe(**__a)

        __UpperCamelCase     :Dict			  =		torch.cuda.max_memory_allocated()
        # make sure that less than 5.2 GB is allocated
        assert mem_bytes < 5.5 * 10**9







"""simple docstring"""





def       lowerCamelCase__		(			__snake_case = 10_00	)							->		int:


					"""simple docstring"""





					_UpperCamelCase							 =  2**power
					_UpperCamelCase							 =  str(__snake_case	)
					_UpperCamelCase							 =  list(__snake_case	)
					_UpperCamelCase							 =  0

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

					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)






