






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    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 							a_				(		a_			,			a_			,			unittest.TestCase	):


							'''simple docstring'''






							__a:			str									=					StableDiffusionXLPipeline
							__a:			Optional[Any]									=					TEXT_TO_IMAGE_PARAMS
							__a:			Union[str, Any]									=					TEXT_TO_IMAGE_BATCH_PARAMS
							__a:			Tuple									=					TEXT_TO_IMAGE_IMAGE_PARAMS
							__a:			Union[str, Any]									=					TEXT_TO_IMAGE_IMAGE_PARAMS

							def   _lowercase (	self     )      ->      List[str]:
														'''simple docstring'''

														torch.manual_seed(0     )
														lowerCAmelCase_       		=  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')    ,    attention_head_dim=(2, 4)    ,    use_linear_projection=lowercase_    ,    addition_embed_type='text_time'    ,    addition_time_embed_dim=8    ,    transformer_layers_per_block=(1, 2)    ,    projection_class_embeddings_input_dim=8_0    ,    cross_attention_dim=6_4    ,    )
														lowerCAmelCase_       		=  EulerDiscreteScheduler(
														    beta_start=0.0_00_85    ,    beta_end=0.0_12    ,    steps_offset=1    ,    beta_schedule='scaled_linear'    ,    timestep_spacing='leading'    ,    )
														torch.manual_seed(0     )
														lowerCAmelCase_       		=  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_       		=  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=3_2    ,    )
														lowerCAmelCase_       		=  CLIPTextModel(lowercase_     )
														lowerCAmelCase_       		=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    ,    local_files_only=lowercase_     )

														lowerCAmelCase_       		=  CLIPTextModelWithProjection(lowercase_     )
														lowerCAmelCase_       		=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    ,    local_files_only=lowercase_     )

														lowerCAmelCase_       		=  {
														    'unet': unet,
														    'scheduler': scheduler,
														    'vae': vae,
														    'text_encoder': text_encoder,
														    'tokenizer': tokenizer,
														    'text_encoder_2': text_encoder_a,
														    'tokenizer_2': tokenizer_a,
														    # "safety_checker": None,
														    # "feature_extractor": None,
														}
														return components

							def   _lowercase (	self    ,    lowercase_    ,    lowercase_=0     )      ->      str:
														'''simple docstring'''

														if str(lowercase_     ).startswith('mps'     ):
																					lowerCAmelCase_       		=  torch.manual_seed(lowercase_     )
														else:
																					lowerCAmelCase_       		=  torch.Generator(device=lowercase_     ).manual_seed(lowercase_     )
														lowerCAmelCase_       		=  {
														    'prompt': 'A painting of a squirrel eating a burger',
														    'generator': generator,
														    'num_inference_steps': 2,
														    'guidance_scale': 5.0,
														    'output_type': 'numpy',
														}
														return inputs

							def   _lowercase (	self     )      ->      List[Any]:
														'''simple docstring'''

														lowerCAmelCase_       		=  'cpu'  # ensure determinism for the device-dependent torch.Generator
														lowerCAmelCase_       		=  self.get_dummy_components()
														lowerCAmelCase_       		=  StableDiffusionXLPipeline(**lowercase_     )
														lowerCAmelCase_       		=  sd_pipe.to(lowercase_     )
														sd_pipe.set_progress_bar_config(disable=lowercase_     )

														lowerCAmelCase_       		=  self.get_dummy_inputs(lowercase_     )
														lowerCAmelCase_       		=  sd_pipe(**lowercase_     ).images
														lowerCAmelCase_       		=  image[0, -3:, -3:, -1]

														assert image.shape == (1, 6_4, 6_4, 3)
														lowerCAmelCase_       		=  np.array([0.58_73, 0.61_28, 0.47_97, 0.51_22, 0.56_74, 0.46_39, 0.52_27, 0.51_49, 0.47_47]     )

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

							def   _lowercase (	self     )      ->      Optional[int]:
														'''simple docstring'''

														lowerCAmelCase_       		=  self.get_dummy_components()
														lowerCAmelCase_       		=  StableDiffusionXLPipeline(**lowercase_     )
														lowerCAmelCase_       		=  sd_pipe.to(lowercase_     )
														lowerCAmelCase_       		=  sd_pipe.to(lowercase_     )
														sd_pipe.set_progress_bar_config(disable=lowercase_     )

														# forward without prompt embeds
														lowerCAmelCase_       		=  self.get_dummy_inputs(lowercase_     )
														lowerCAmelCase_       		=  3 * ['this is a negative prompt']
														lowerCAmelCase_       		=  negative_prompt
														lowerCAmelCase_       		=  3 * [inputs['prompt']]

														lowerCAmelCase_       		=  sd_pipe(**lowercase_     )
														lowerCAmelCase_       		=  output.images[0, -3:, -3:, -1]

														# forward with prompt embeds
														lowerCAmelCase_       		=  self.get_dummy_inputs(lowercase_     )
														lowerCAmelCase_       		=  3 * ['this is a negative prompt']
														lowerCAmelCase_       		=  3 * [inputs.pop('prompt'     )]

														(
														    (
														    lowerCAmelCase_
														)		,     (
														    lowerCAmelCase_
														)		,     (
														    lowerCAmelCase_
														)		,     (
														    lowerCAmelCase_
														)		,     
														)       		=  sd_pipe.encode_prompt(lowercase_    ,    negative_prompt=lowercase_     )

														lowerCAmelCase_       		=  sd_pipe(
														    **lowercase_    ,    prompt_embeds=lowercase_    ,    negative_prompt_embeds=lowercase_    ,    pooled_prompt_embeds=lowercase_    ,    negative_pooled_prompt_embeds=lowercase_    ,    )
														lowerCAmelCase_       		=  output.images[0, -3:, -3:, -1]

														# make sure that it's equal
														assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()     ).max() < 1e-4

							def   _lowercase (	self     )      ->      Optional[int]:
														'''simple docstring'''

														super().test_attention_slicing_forward_pass(expected_max_diff=3e-3     )






							def   _lowercase (	self     )      ->      Any:
														'''simple docstring'''

														super().test_inference_batch_single_identical(expected_max_diff=3e-3     )




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


							'''simple docstring'''






							def   _lowercase (	self     )      ->      List[str]:
														'''simple docstring'''

														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()

							def   _lowercase (	self    ,    lowercase_    ,    lowercase_="cpu"    ,    lowercase_=torch.floataa    ,    lowercase_=0     )      ->      int:
														'''simple docstring'''

														lowerCAmelCase_       		=  torch.Generator(device=lowercase_     ).manual_seed(lowercase_     )
														lowerCAmelCase_       		=  np.random.RandomState(lowercase_     ).standard_normal((1, 4, 6_4, 6_4)     )
														lowerCAmelCase_       		=  torch.from_numpy(lowercase_     ).to(device=lowercase_    ,    dtype=lowercase_     )
														lowerCAmelCase_       		=  {
														    'prompt': 'a photograph of an astronaut riding a horse',
														    'latents': latents,
														    'generator': generator,
														    'num_inference_steps': 3,
														    'guidance_scale': 7.5,
														    'output_type': 'numpy',
														}
														return inputs






							def   _lowercase (	self     )      ->      Optional[Any]:
														'''simple docstring'''

														lowerCAmelCase_       		=  DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base'     )
														pipe.to(lowercase_     )
														pipe.set_progress_bar_config(disable=lowercase_     )

														lowerCAmelCase_       		=  self.get_inputs(lowercase_     )
														lowerCAmelCase_       		=  pipe(**lowercase_     ).images
														lowerCAmelCase_       		=  image[0, -3:, -3:, -1].flatten()

														assert image.shape == (1, 5_1_2, 5_1_2, 3)
														lowerCAmelCase_       		=  np.array([0.4_94_93, 0.4_78_96, 0.4_07_98, 0.5_42_14, 0.5_32_12, 0.4_82_02, 0.4_76_56, 0.4_63_29, 0.4_85_06]     )
														assert np.abs(image_slice - expected_slice     ).max() < 7e-3











from __future__ import annotations

from string import ascii_letters
def   lowerCamelCase      (		a_				,		a_				,		a_ = None			)			->    str:
							lowerCAmelCase_       		=  alphabet or ascii_letters

							# The final result string
							lowerCAmelCase_       		=  ''

							for character in input_string:
														if character not in alpha:
																					# Append without encryption if character is not in the alphabet
																					result += character
														else:
																					# Get the index of the new key and make sure it isn't too large
																					lowerCAmelCase_       		=  (alpha.index(a_			) + key) % len(a_			)

																					# Append the encoded character to the alphabet
																					result += alpha[new_key]

							return result
def   lowerCamelCase      (		a_				,		a_				,		a_ = None			)			->    str:
							key *= -1

							return encrypt(a_				,		a_				,		a_			)
def   lowerCamelCase      (		a_				,		a_ = None			)			->    dict[int, str]:
							lowerCAmelCase_       		=  alphabet or ascii_letters

							# To store data on all the combinations
							lowerCAmelCase_       		=  {}

							# Cycle through each combination
							for key in range(1				,		len(a_			) + 1			):
														# Decrypt the message and store the result in the data
														lowerCAmelCase_       		=  decrypt(a_				,		a_				,		a_			)

							return brute_force_data


if __name__ == "__main__":
		while True:
				print(f'''\n{"-" * 1_0}\n Menu\n{"-" * 1_0}''')
				print(*["""1.Encrypt""", """2.Decrypt""", """3.BruteForce""", """4.Quit"""], sep="""\n""")

				# get user input
				lowerCamelCase_		  =						input("""\nWhat would you like to do?: """).strip() or """4"""

				# run functions based on what the user chose
				if choice not in ("1", "2", "3", "4"):
						print("""Invalid choice, please enter a valid choice""")
				elif choice == "1":
						lowerCamelCase_		  =						input("""Please enter the string to be encrypted: """)
						lowerCamelCase_		  =						int(input("""Please enter off-set: """).strip())

						print(encrypt(input_string, key))
				elif choice == "2":
						lowerCamelCase_		  =						input("""Please enter the string to be decrypted: """)
						lowerCamelCase_		  =						int(input("""Please enter off-set: """).strip())

						print(decrypt(input_string, key))
				elif choice == "3":
						lowerCamelCase_		  =						input("""Please enter the string to be decrypted: """)
						lowerCamelCase_		  =						brute_force(input_string)

						for key, value in brute_force_data.items():
								print(f'''Key: {key} | Message: {value}''')

				elif choice == "4":
						print("""Goodbye.""")
						break



