



'''simple docstring'''






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     __snake_case		(   a__    ,   a__    ,   unittest.TestCase):
					_lowerCAmelCase			     =	StableDiffusionPanoramaPipeline
					_lowerCAmelCase			     =	TEXT_TO_IMAGE_PARAMS
					_lowerCAmelCase			     =	TEXT_TO_IMAGE_BATCH_PARAMS
					_lowerCAmelCase			     =	TEXT_TO_IMAGE_IMAGE_PARAMS
					_lowerCAmelCase			     =	TEXT_TO_IMAGE_IMAGE_PARAMS
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									torch.manual_seed(0      )
									lowerCamelCase					:			Dict									= 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,    )
									lowerCamelCase					:			int									= DDIMScheduler()
									torch.manual_seed(0      )
									lowerCamelCase					:			int									= 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      )
									lowerCamelCase					:			List[Any]									= CLIPTextConfig(
									    bos_token_id=0,    eos_token_id=2,    hidden_size=32,    intermediate_size=37,    layer_norm_eps=1e-05,    num_attention_heads=4,    num_hidden_layers=5,    pad_token_id=1,    vocab_size=1000,    )
									lowerCamelCase					:			Any									= CLIPTextModel(A      )
									lowerCamelCase					:			Optional[Any]									= CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

									lowerCamelCase					:			Optional[Any]									= {
									    'unet': unet,
									    'scheduler': scheduler,
									    'vae': vae,
									    'text_encoder': text_encoder,
									    'tokenizer': tokenizer,
									    'safety_checker': None,
									    'feature_extractor': None,
									}
									return components
					def     UpperCAmelCase_							(     self,    A,    A=0      ):

									"""simple docstring"""


									lowerCamelCase					:			Optional[int]									= torch.manual_seed(A      )
									lowerCamelCase					:			List[Any]									= {
									    '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      ):

									"""simple docstring"""


									lowerCamelCase					:			List[str]									= 'cpu'  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase					:			List[Any]									= self.get_dummy_components()
									lowerCamelCase					:			Tuple									= StableDiffusionPanoramaPipeline(**A      )
									lowerCamelCase					:			str									= sd_pipe.to(A      )
									sd_pipe.set_progress_bar_config(disable=A      )

									lowerCamelCase					:			Any									= self.get_dummy_inputs(A      )
									lowerCamelCase					:			Tuple									= sd_pipe(**A      ).images
									lowerCamelCase					:			Union[str, Any]									= image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									lowerCamelCase					:			List[str]									= np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757]      )

									assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									super().test_inference_batch_consistent(batch_sizes=[1, 2]      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									super().test_inference_batch_single_identical(batch_size=2,    expected_max_diff=3.25e-3      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			Dict									= 'cpu'  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase					:			List[Any]									= self.get_dummy_components()
									lowerCamelCase					:			Any									= StableDiffusionPanoramaPipeline(**A      )
									lowerCamelCase					:			Union[str, Any]									= sd_pipe.to(A      )
									sd_pipe.set_progress_bar_config(disable=A      )

									lowerCamelCase					:			Tuple									= self.get_dummy_inputs(A      )
									lowerCamelCase					:			Tuple									= 'french fries'
									lowerCamelCase					:			Dict									= sd_pipe(**A,    negative_prompt=A      )
									lowerCamelCase					:			Tuple									= output.images
									lowerCamelCase					:			str									= image[0, -3:, -3:, -1]

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

									lowerCamelCase					:			Optional[int]									= np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]      )

									assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


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

									lowerCamelCase					:			int									= self.get_dummy_inputs(A      )
									lowerCamelCase					:			Dict									= sd_pipe(**A,    view_batch_size=2      )
									lowerCamelCase					:			Optional[int]									= output.images
									lowerCamelCase					:			Optional[int]									= image[0, -3:, -3:, -1]

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

									lowerCamelCase					:			Any									= np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]      )

									assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			List[str]									= 'cpu'  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase					:			Tuple									= self.get_dummy_components()
									lowerCamelCase					:			Optional[Any]									= EulerAncestralDiscreteScheduler(
									    beta_start=0.0_0085,    beta_end=0.012,    beta_schedule='scaled_linear'      )
									lowerCamelCase					:			int									= StableDiffusionPanoramaPipeline(**A      )
									lowerCamelCase					:			Optional[int]									= sd_pipe.to(A      )
									sd_pipe.set_progress_bar_config(disable=A      )

									lowerCamelCase					:			Optional[int]									= self.get_dummy_inputs(A      )
									lowerCamelCase					:			str									= sd_pipe(**A      ).images
									lowerCamelCase					:			int									= image[0, -3:, -3:, -1]

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

									lowerCamelCase					:			List[Any]									= np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952]      )

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




					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			Any									= 'cpu'  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase					:			Tuple									= self.get_dummy_components()
									lowerCamelCase					:			List[str]									= PNDMScheduler(
									    beta_start=0.0_0085,    beta_end=0.012,    beta_schedule='scaled_linear',    skip_prk_steps=A      )
									lowerCamelCase					:			str									= StableDiffusionPanoramaPipeline(**A      )
									lowerCamelCase					:			Tuple									= sd_pipe.to(A      )
									sd_pipe.set_progress_bar_config(disable=A      )

									lowerCamelCase					:			str									= self.get_dummy_inputs(A      )
									lowerCamelCase					:			Dict									= sd_pipe(**A      ).images
									lowerCamelCase					:			Optional[Any]									= image[0, -3:, -3:, -1]

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

									lowerCamelCase					:			Optional[int]									= np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539]      )

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





@slow
@require_torch_gpu
class     __snake_case		(   unittest.TestCase):
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()
					def     UpperCAmelCase_							(     self,    A=0      ):

									"""simple docstring"""


									lowerCamelCase					:			Union[str, Any]									= torch.manual_seed(A      )
									lowerCamelCase					:			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      ):

									"""simple docstring"""


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

									lowerCamelCase					:			Any									= self.get_inputs()
									lowerCamelCase					:			int									= pipe(**A      ).images
									lowerCamelCase					:			List[Any]									= image[0, -3:, -3:, -1].flatten()

									assert image.shape == (1, 512, 2048, 3)

									lowerCamelCase					:			str									= np.array(
									    [
									        0.3696_8392,
									        0.2702_5372,
									        0.3244_6766,
									        0.2837_9387,
									        0.3636_3274,
									        0.3073_3347,
									        0.2710_0027,
									        0.2705_4125,
									        0.2553_6096,
									    ]      )

									assert np.abs(expected_slice - image_slice      ).max() < 1e-2
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			Any									= StableDiffusionPanoramaPipeline.from_pretrained(
									    'stabilityai/stable-diffusion-2-base',    safety_checker=A      )
									lowerCamelCase					:			Union[str, Any]									= LMSDiscreteScheduler.from_config(pipe.scheduler.config      )
									pipe.to(A      )
									pipe.set_progress_bar_config(disable=A      )
									pipe.enable_attention_slicing()

									lowerCamelCase					:			Dict									= self.get_inputs()
									lowerCamelCase					:			List[str]									= pipe(**A      ).images
									lowerCamelCase					:			Tuple									= image[0, -3:, -3:, -1].flatten()

									assert image.shape == (1, 512, 2048, 3)

									lowerCamelCase					:			Union[str, Any]									= 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      ):

									"""simple docstring"""


									lowerCamelCase					:			str									= 0

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

																	lowerCamelCase					:			str									= np.array(
																	    [
																	        0.1868_1869,
																	        0.3390_7816,
																	        0.536_1276,
																	        0.1443_2865,
																	        -0.0285_6611,
																	        -0.7394_1123,
																	        0.2339_7987,
																	        0.4732_2682,
																	        -0.3782_3164,
																	    ]      )
																	assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5e-2
													elif step == 2:
																	lowerCamelCase					:			Optional[int]									= latents.detach().cpu().numpy()
																	assert latents.shape == (1, 4, 64, 256)
																	lowerCamelCase					:			int									= latents[0, -3:, -3:, -1]

																	lowerCamelCase					:			Any									= np.array(
																	    [
																	        0.1853_9645,
																	        0.3398_7248,
																	        0.537_8559,
																	        0.1443_7142,
																	        -0.0245_5261,
																	        -0.733_8317,
																	        0.2399_0755,
																	        0.4735_6272,
																	        -0.378_6505,
																	    ]      )

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

									lowerCamelCase					:			int									= False

									lowerCamelCase					:			Dict									= 'stabilityai/stable-diffusion-2-base'
									lowerCamelCase					:			List[Any]									= DDIMScheduler.from_pretrained(A,    subfolder='scheduler'      )
									lowerCamelCase					:			Union[str, Any]									= StableDiffusionPanoramaPipeline.from_pretrained(A,    scheduler=A,    safety_checker=A      )
									lowerCamelCase					:			str									= pipe.to(A      )
									pipe.set_progress_bar_config(disable=A      )
									pipe.enable_attention_slicing()

									lowerCamelCase					:			Optional[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      ):

									"""simple docstring"""


									torch.cuda.empty_cache()
									torch.cuda.reset_max_memory_allocated()
									torch.cuda.reset_peak_memory_stats()

									lowerCamelCase					:			Optional[Any]									= 'stabilityai/stable-diffusion-2-base'
									lowerCamelCase					:			Union[str, Any]									= DDIMScheduler.from_pretrained(A,    subfolder='scheduler'      )
									lowerCamelCase					:			Optional[int]									= StableDiffusionPanoramaPipeline.from_pretrained(A,    scheduler=A,    safety_checker=A      )
									lowerCamelCase					:			Dict									= pipe.to(A      )
									pipe.set_progress_bar_config(disable=A      )
									pipe.enable_attention_slicing(1      )
									pipe.enable_sequential_cpu_offload()

									lowerCamelCase					:			List[str]									= self.get_inputs()
									lowerCamelCase					:			str									= pipe(**A      )

									lowerCamelCase					:			Union[str, Any]									= torch.cuda.max_memory_allocated()
									# make sure that less than 5.2 GB is allocated
									assert mem_bytes < 5.5 * 10**9


'''simple docstring'''






import string

# frequency taken from https://en.wikipedia.org/wiki/Letter_frequency
A			      =      {
    'E': 12.70,
    'T': 9.06,
    'A': 8.17,
    'O': 7.51,
    'I': 6.97,
    'N': 6.75,
    'S': 6.33,
    'H': 6.09,
    'R': 5.99,
    'D': 4.25,
    'L': 4.03,
    'C': 2.78,
    'U': 2.76,
    'M': 2.41,
    'W': 2.36,
    'F': 2.23,
    'G': 2.02,
    'Y': 1.97,
    'P': 1.93,
    'B': 1.29,
    'V': 0.98,
    'K': 0.77,
    'J': 0.15,
    'X': 0.15,
    'Q': 0.10,
    'Z': 0.07,
}
A			      =      'ETAOINSHRDLCUMWFGYPBVKJXQZ'
A			      =      'ABCDEFGHIJKLMNOPQRSTUVWXYZ'





def    UpperCAmelCase							(  UpperCAmelCase__							:							str):
				lowerCamelCase					:			Optional[Any]									= {letter: 0 for letter in string.ascii_uppercase}
				for letter in message.upper():
								if letter in LETTERS:
												letter_count[letter] += 1

				return letter_count





def    UpperCAmelCase							(  UpperCAmelCase__							:							tuple):
				return x[0]





def    UpperCAmelCase							(  UpperCAmelCase__							:							str):
				lowerCamelCase					:			Optional[Any]									= get_letter_count(UpperCAmelCase__)
				lowerCamelCase					:			dict[int, list[str]]									= {
				    freq: [] for letter, freq in letter_to_freq.items()
				}
				for letter in LETTERS:
								freq_to_letter[letter_to_freq[letter]].append(UpperCAmelCase__)

				lowerCamelCase					:			dict[int, str]									= {}

				for freq in freq_to_letter:
								freq_to_letter[freq].sort(key=ETAOIN.find       ,							reverse=UpperCAmelCase__)
								lowerCamelCase					:			int									= ''.join(freq_to_letter[freq])

				lowerCamelCase					:			Any									= list(freq_to_letter_str.items())
				freq_pairs.sort(key=UpperCAmelCase__       ,							reverse=UpperCAmelCase__)

				lowerCamelCase					:			list[str]									= [freq_pair[1] for freq_pair in freq_pairs]

				return "".join(UpperCAmelCase__)





def    UpperCAmelCase							(  UpperCAmelCase__							:							str):
				lowerCamelCase					:			Optional[Any]									= get_frequency_order(UpperCAmelCase__)
				lowerCamelCase					:			Optional[Any]									= 0
				for common_letter in ETAOIN[:6]:
								if common_letter in freq_order[:6]:
												match_score += 1

				for uncommon_letter in ETAOIN[-6:]:
								if uncommon_letter in freq_order[-6:]:
												match_score += 1

				return match_score


if __name__ == "__main__":
					import doctest

					doctest.testmod()
