
"""simple docstring"""

import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class __lowerCAmelCase						( __SCREAMING_SNAKE_CASE     ,    unittest.TestCase     ):
     lowercase		  =		KandinskyPipeline
     lowercase		  =		[
         """prompt""",
         """image_embeds""",
         """negative_image_embeds""",
     ]
     lowercase		  =		["""prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds"""]
     lowercase		  =		[
         """generator""",
         """height""",
         """width""",
         """latents""",
         """guidance_scale""",
         """negative_prompt""",
         """num_inference_steps""",
         """return_dict""",
         """guidance_scale""",
         """num_images_per_prompt""",
         """output_type""",
         """return_dict""",
     ]
     lowercase		  =		False





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      return 32





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      return 32





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      return self.time_input_dim





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      return self.time_input_dim * 4





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      return 100





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      __UpperCamelCase							    =			XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base' )
      return tokenizer





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      torch.manual_seed(0 )
      __UpperCamelCase							    =			MCLIPConfig(
          numDims=self.cross_attention_dim      ,	transformerDimensions=self.text_embedder_hidden_size      ,	hidden_size=self.text_embedder_hidden_size      ,	intermediate_size=37      ,	num_attention_heads=4      ,	num_hidden_layers=5      ,	vocab_size=1005      ,	)

      __UpperCamelCase							    =			MultilingualCLIP(_lowerCamelCase )
      __UpperCamelCase							    =			text_encoder.eval()

      return text_encoder





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      torch.manual_seed(0 )

      __UpperCamelCase							    =			{
          "in_channels": 4,
          # Out channels is double in channels because predicts mean and variance
          "out_channels": 8,
          "addition_embed_type": "text_image",
          "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
          "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
          "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
          "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
          "layers_per_block": 1,
          "encoder_hid_dim": self.text_embedder_hidden_size,
          "encoder_hid_dim_type": "text_image_proj",
          "cross_attention_dim": self.cross_attention_dim,
          "attention_head_dim": 4,
          "resnet_time_scale_shift": "scale_shift",
          "class_embed_type": None,
      }

      __UpperCamelCase							    =			UNetaDConditionModel(**_lowerCamelCase )
      return model





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      return {
          "block_out_channels": [32, 64],
          "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
          "in_channels": 3,
          "latent_channels": 4,
          "layers_per_block": 1,
          "norm_num_groups": 8,
          "norm_type": "spatial",
          "num_vq_embeddings": 12,
          "out_channels": 3,
          "up_block_types": [
              "AttnUpDecoderBlock2D",
              "UpDecoderBlock2D",
          ],
          "vq_embed_dim": 4,
      }





     @property
     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      torch.manual_seed(0 )
      __UpperCamelCase							    =			VQModel(**self.dummy_movq_kwargs )
      return model





     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      __UpperCamelCase							    =			self.dummy_text_encoder
      __UpperCamelCase							    =			self.dummy_tokenizer
      __UpperCamelCase							    =			self.dummy_unet
      __UpperCamelCase							    =			self.dummy_movq

      __UpperCamelCase							    =			DDIMScheduler(
          num_train_timesteps=1000      ,	beta_schedule='linear'      ,	beta_start=0.0_0_0_8_5      ,	beta_end=0.0_1_2      ,	clip_sample=_lowerCamelCase      ,	set_alpha_to_one=_lowerCamelCase      ,	steps_offset=1      ,	prediction_type='epsilon'      ,	thresholding=_lowerCamelCase      ,	)

      __UpperCamelCase							    =			{
          "text_encoder": text_encoder,
          "tokenizer": tokenizer,
          "unet": unet,
          "scheduler": scheduler,
          "movq": movq,
      }
      return components





     def 		UpperCAmelCase   (      self      ,	__UpperCAmelCase      ,	__UpperCAmelCase=0 ):

      '''simple docstring'''




      __UpperCamelCase							    =			floats_tensor((1, self.cross_attention_dim)      ,	rng=random.Random(_lowerCamelCase ) ).to(_lowerCamelCase )
      __UpperCamelCase							    =			floats_tensor((1, self.cross_attention_dim)      ,	rng=random.Random(seed + 1 ) ).to(_lowerCamelCase )
      if str(_lowerCamelCase ).startswith('mps' ):
       __UpperCamelCase							    =			torch.manual_seed(_lowerCamelCase )
      else:
       __UpperCamelCase							    =			torch.Generator(device=_lowerCamelCase ).manual_seed(_lowerCamelCase )
      __UpperCamelCase							    =			{
          "prompt": "horse",
          "image_embeds": image_embeds,
          "negative_image_embeds": negative_image_embeds,
          "generator": generator,
          "height": 64,
          "width": 64,
          "guidance_scale": 4.0,
          "num_inference_steps": 2,
          "output_type": "np",
      }
      return inputs







     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      __UpperCamelCase							    =			"cpu"

      __UpperCamelCase							    =			self.get_dummy_components()

      __UpperCamelCase							    =			self.pipeline_class(**_lowerCamelCase )
      __UpperCamelCase							    =			pipe.to(_lowerCamelCase )

      pipe.set_progress_bar_config(disable=_lowerCamelCase )

      __UpperCamelCase							    =			pipe(**self.get_dummy_inputs(_lowerCamelCase ) )
      __UpperCamelCase							    =			output.images

      __UpperCamelCase							    =			pipe(
          **self.get_dummy_inputs(_lowerCamelCase )      ,	return_dict=_lowerCamelCase      ,	)[0]

      __UpperCamelCase							    =			image[0, -3:, -3:, -1]
      __UpperCamelCase							    =			image_from_tuple[0, -3:, -3:, -1]

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

      __UpperCamelCase							    =			np.array(
          [0.3_2_8_6_6_3, 1.0, 0.2_3_2_1_6_8_7_3, 1.0, 0.9_2_7_1_7_5_6_4, 0.4_6_3_9_0_4_6, 0.9_6_8_9_4_7_7_7, 0.3_1_7_1_3_3_7_8, 0.6_2_9_3_9_5_3] )

      assert (
          np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
      ), F' expected_slice {expected_slice}, but got {image_slice.flatten()}'
      assert (
          np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2
      ), F' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'


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





     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




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







     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      __UpperCamelCase							    =			load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
          '/kandinsky/kandinsky_text2img_cat_fp16.npy' )

      __UpperCamelCase							    =			KandinskyPriorPipeline.from_pretrained(
          'kandinsky-community/kandinsky-2-1-prior'      ,	torch_dtype=torch.floataa )
      pipe_prior.to(_lowerCamelCase )

      __UpperCamelCase							    =			KandinskyPipeline.from_pretrained('kandinsky-community/kandinsky-2-1'      ,	torch_dtype=torch.floataa )
      __UpperCamelCase							    =			pipeline.to(_lowerCamelCase )
      pipeline.set_progress_bar_config(disable=_lowerCamelCase )

      __UpperCamelCase							    =			"red cat, 4k photo"

      __UpperCamelCase							    =			torch.Generator(device='cuda' ).manual_seed(0 )
      __UpperCamelCase							    =			pipe_prior(
          _lowerCamelCase      ,	generator=_lowerCamelCase      ,	num_inference_steps=5      ,	negative_prompt=''      ,	).to_tuple()

      __UpperCamelCase							    =			torch.Generator(device='cuda' ).manual_seed(0 )
      __UpperCamelCase							    =			pipeline(
          _lowerCamelCase      ,	image_embeds=_lowerCamelCase      ,	negative_image_embeds=_lowerCamelCase      ,	generator=_lowerCamelCase      ,	num_inference_steps=100      ,	output_type='np'      ,	)

      __UpperCamelCase							    =			output.images[0]

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

      assert_mean_pixel_difference(_lowerCamelCase      ,	_lowerCamelCase )





from __future__ import annotations

from string import ascii_letters




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      str:

							"""simple docstring"""






							_UpperCAmelCase  :			List[Any]	       =		alphabet or ascii_letters

							# The final result string
							_UpperCAmelCase  :			Optional[Any]	       =		""

							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
																					_UpperCAmelCase  :			Any	       =		(alpha.index(_SCREAMING_SNAKE_CASE  ) + key) % len(_SCREAMING_SNAKE_CASE  )

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

							return result




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      str:

							"""simple docstring"""






							key *= -1

							return encrypt(_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE  )




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE = None  )   ->      dict[int, str]:

							"""simple docstring"""






							_UpperCAmelCase  :			Any	       =		alphabet or ascii_letters

							# To store data on all the combinations
							_UpperCAmelCase  :			Dict	       =		{}

							# Cycle through each combination
							for key in range(1      ,	len(_SCREAMING_SNAKE_CASE  ) + 1  ):
														# Decrypt the message and store the result in the data
														_UpperCAmelCase  :			Union[str, Any]	       =		decrypt(_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE  )

							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




