

"""simple docstring"""





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    require_torch_gpu,
)

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()







class        SCREAMING_SNAKE_CASE      (	a_					,							a_					,							unittest.TestCase ):






					"""simple docstring"""



					lowercase__       				= StableDiffusionParadigmsPipeline
					lowercase__       				= TEXT_TO_IMAGE_PARAMS
					lowercase__       				= TEXT_TO_IMAGE_BATCH_PARAMS
					lowercase__       				= TEXT_TO_IMAGE_IMAGE_PARAMS
					lowercase__       				= TEXT_TO_IMAGE_IMAGE_PARAMS







					def  __lowerCAmelCase				( self    :       Optional[Any]	):
						torch.manual_seed(0	)
						lowerCAmelCase__			:		Union[str, Any]						       =			UNetaDConditionModel(
						    block_out_channels=(3_2, 6_4)     ,layers_per_block=2     ,sample_size=3_2     ,in_channels=4     ,out_channels=4     ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')     ,cross_attention_dim=3_2     ,attention_head_dim=(2, 4)     ,use_linear_projection=lowercase_     ,)
						lowerCAmelCase__			:		Tuple						       =			DDIMParallelScheduler(
						    beta_start=0.0_0085     ,beta_end=0.012     ,beta_schedule='''scaled_linear'''     ,clip_sample=lowercase_     ,set_alpha_to_one=lowercase_     ,)
						torch.manual_seed(0	)
						lowerCAmelCase__			:		Dict						       =			AutoencoderKL(
						    block_out_channels=[3_2, 6_4]     ,in_channels=3     ,out_channels=3     ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']     ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']     ,latent_channels=4     ,sample_size=1_2_8     ,)
						torch.manual_seed(0	)
						lowerCAmelCase__			:		Tuple						       =			CLIPTextConfig(
						    bos_token_id=0     ,eos_token_id=2     ,hidden_size=3_2     ,intermediate_size=3_7     ,layer_norm_eps=1E-05     ,num_attention_heads=4     ,num_hidden_layers=5     ,pad_token_id=1     ,vocab_size=1_0_0_0     ,hidden_act='''gelu'''     ,projection_dim=5_1_2     ,)
						lowerCAmelCase__			:		Optional[Any]						       =			CLIPTextModel(lowercase_	)
						lowerCAmelCase__			:		str						       =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

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







					def  __lowerCAmelCase				( self    :       List[Any]     ,lowercase_    :       Optional[int]     ,lowercase_    :       str=0	):
						if str(lowercase_	).startswith('''mps'''	):
							lowerCAmelCase__			:		List[Any]						       =			torch.manual_seed(lowercase_	)
						else:
							lowerCAmelCase__			:		Optional[Any]						       =			torch.Generator(device=lowercase_	).manual_seed(lowercase_	)
						lowerCAmelCase__			:		List[str]						       =			{
						    '''prompt''': '''a photograph of an astronaut riding a horse''',
						    '''generator''': generator,
						    '''num_inference_steps''': 1_0,
						    '''guidance_scale''': 6.0,
						    '''output_type''': '''numpy''',
						    '''parallel''': 3,
						    '''debug''': True,
						}
						return inputs







					def  __lowerCAmelCase				( self    :       str	):
						lowerCAmelCase__			:		str						       =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
						lowerCAmelCase__			:		Union[str, Any]						       =			self.get_dummy_components()
						lowerCAmelCase__			:		Union[str, Any]						       =			StableDiffusionParadigmsPipeline(**lowercase_	)
						lowerCAmelCase__			:		int						       =			sd_pipe.to(lowercase_	)
						sd_pipe.set_progress_bar_config(disable=lowercase_	)

						lowerCAmelCase__			:		Any						       =			self.get_dummy_inputs(lowercase_	)
						lowerCAmelCase__			:		List[str]						       =			sd_pipe(**lowercase_	).images
						lowerCAmelCase__			:		str						       =			image[0, -3:, -3:, -1]
						assert image.shape == (1, 6_4, 6_4, 3)

						lowerCAmelCase__			:		Any						       =			np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]	)

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







					def  __lowerCAmelCase				( self    :       str	):
						lowerCAmelCase__			:		Union[str, Any]						       =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
						lowerCAmelCase__			:		Any						       =			self.get_dummy_components()
						torch.manual_seed(0	)
						lowerCAmelCase__			:		Optional[Any]						       =			DDPMParallelScheduler()
						torch.manual_seed(0	)
						lowerCAmelCase__			:		Union[str, Any]						       =			StableDiffusionParadigmsPipeline(**lowercase_	)
						lowerCAmelCase__			:		List[str]						       =			sd_pipe.to(lowercase_	)
						sd_pipe.set_progress_bar_config(disable=lowercase_	)

						lowerCAmelCase__			:		Optional[Any]						       =			self.get_dummy_inputs(lowercase_	)
						lowerCAmelCase__			:		Dict						       =			sd_pipe(**lowercase_	).images
						lowerCAmelCase__			:		Union[str, Any]						       =			image[0, -3:, -3:, -1]
						assert image.shape == (1, 6_4, 6_4, 3)

						lowerCAmelCase__			:		int						       =			np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]	)

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







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







					def  __lowerCAmelCase				( self    :       List[str]	):
						super().test_inference_batch_single_identical(batch_size=2     ,expected_max_diff=3E-3	)







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

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

						assert image.shape == (1, 6_4, 6_4, 3)

						lowerCAmelCase__			:		List[str]						       =			np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]	)

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







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






					"""simple docstring"""



					def  __lowerCAmelCase				( self    :       Optional[Any]	):
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()







					def  __lowerCAmelCase				( self    :       List[Any]     ,lowercase_    :       List[Any]=0	):
						lowerCAmelCase__			:		List[str]						       =			torch.Generator(device=lowercase_	).manual_seed(lowercase_	)
						lowerCAmelCase__			:		Any						       =			{
						    '''prompt''': '''a photograph of an astronaut riding a horse''',
						    '''generator''': generator,
						    '''num_inference_steps''': 1_0,
						    '''guidance_scale''': 7.5,
						    '''output_type''': '''numpy''',
						    '''parallel''': 3,
						    '''debug''': True,
						}
						return inputs







					def  __lowerCAmelCase				( self    :       Optional[int]	):
						lowerCAmelCase__			:		Dict						       =			'''stabilityai/stable-diffusion-2-base'''
						lowerCAmelCase__			:		Union[str, Any]						       =			DDIMParallelScheduler.from_pretrained(lowercase_     ,subfolder='''scheduler'''	)
						lowerCAmelCase__			:		Optional[Any]						       =			StableDiffusionParadigmsPipeline.from_pretrained(lowercase_     ,scheduler=lowercase_     ,safety_checker=lowercase_	)
						pipe.to(lowercase_	)
						pipe.set_progress_bar_config(disable=lowercase_	)
						pipe.enable_attention_slicing()

						lowerCAmelCase__			:		Optional[Any]						       =			self.get_inputs()
						lowerCAmelCase__			:		List[str]						       =			pipe(**lowercase_	).images
						lowerCAmelCase__			:		List[str]						       =			image[0, -3:, -3:, -1].flatten()

						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						lowerCAmelCase__			:		Union[str, Any]						       =			np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]	)

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







"""simple docstring"""





import random
import sys

__UpperCamelCase						:   Tuple							   =	'''ABCDEFGHIJKLMNOPQRSTUVWXYZ'''

def 						__SCREAMING_SNAKE_CASE						(   ):
	lowerCAmelCase__			:		List[str]						       =			input('''Enter message: '''				)
	lowerCAmelCase__			:		Optional[int]						       =			'''LFWOAYUISVKMNXPBDCRJTQEGHZ'''
	lowerCAmelCase__			:		List[Any]						       =			input('''Encrypt/Decrypt [e/d]: '''				)

	check_valid_key(A_				)

	if resp.lower().startswith('''e'''				):
		lowerCAmelCase__			:		Tuple						       =			'''encrypt'''
		lowerCAmelCase__			:		Union[str, Any]						       =			encrypt_message(A_		,  A_				)
	elif resp.lower().startswith('''d'''				):
		lowerCAmelCase__			:		Dict						       =			'''decrypt'''
		lowerCAmelCase__			:		str						       =			decrypt_message(A_		,  A_				)

	print(f'\n{mode.title()}ion: \n{translated}'				)

def 						__SCREAMING_SNAKE_CASE						(   A_				):
	lowerCAmelCase__			:		str						       =			list(A_				)
	lowerCAmelCase__			:		int						       =			list(A_				)
	key_list.sort()
	letters_list.sort()

	if key_list != letters_list:
		sys.exit('''Error in the key or symbol set.'''				)

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_				):
	return translate_message(A_		,  A_		,  '''encrypt'''				)

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_				):
	return translate_message(A_		,  A_		,  '''decrypt'''				)

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_		,  A_				):
	lowerCAmelCase__			:		str						       =			''''''
	lowerCAmelCase__			:		List[str]						       =			LETTERS
	lowerCAmelCase__			:		Optional[int]						       =			key

	if mode == "decrypt":
		lowerCAmelCase__       ,lowerCAmelCase__			:		int						       =			chars_b, chars_a

	for symbol in message:
		if symbol.upper() in chars_a:
			lowerCAmelCase__			:		int						       =			chars_a.find(symbol.upper()				)
			if symbol.isupper():
				translated += chars_b[sym_index].upper()
			else:
				translated += chars_b[sym_index].lower()
		else:
			translated += symbol

	return translated

def 						__SCREAMING_SNAKE_CASE						(   ):
	lowerCAmelCase__			:		Optional[int]						       =			list(A_				)
	random.shuffle(A_				)
	return "".join(A_				)


if __name__ == "__main__":
							main()




