


'''simple docstring'''



import string

import numpy




def      _a     (						_lowercase :     int      , _lowercase :     int  ):





     '''simple docstring'''






     return b if a == 0 else greatest_common_divisor(b % a      , _lowercase  )



class      a    :


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       string.ascii_uppercase + string.digits
     # This cipher takes alphanumerics into account
     # i.e. a total of 36 characters

     # take x and return x % len(key_string)
     SCREAMING_SNAKE_CASE	:			Dict							       =       numpy.vectorize(lambda _a	: x % 3_6	)

     SCREAMING_SNAKE_CASE	:			str							       =       numpy.vectorize(_a	)

     def __init__(    self					:		int							,			snake_case					:		numpy.ndarray      )						->							None:
          __UpperCAmelCase     :			Optional[Any]  							=      self.modulus(snake_case      )  # mod36 calc's on the encrypt key
          self.check_determinant()  # validate the determinant of the encryption key
          __UpperCAmelCase     :			Any  							=      encrypt_key.shape[0]

     def 			lowerCamelCase__			(    self					:		Optional[Any]							,			snake_case					:		str      )						->							int:
          return self.key_string.index(snake_case      )

     def 			lowerCamelCase__			(    self					:		Any							,			snake_case					:		int      )						->							str:
          return self.key_string[round(snake_case      )]

     def 			lowerCamelCase__			(    self					:		List[str]      )						->							None:
          __UpperCAmelCase     :			Any  							=      round(numpy.linalg.det(self.encrypt_key      )      )

          if det < 0:
               __UpperCAmelCase     :			List[str]  							=      det % len(self.key_string      )

          __UpperCAmelCase     :			Union[str, Any]  							=      len(self.key_string      )
          if greatest_common_divisor(snake_case							,			len(self.key_string      )      ) != 1:
               __UpperCAmelCase     :			Union[str, Any]  							=      (
                   f'determinant modular {req_l} of encryption key({det}) '
                   f'is not co prime w.r.t {req_l}.\nTry another key.'
               )
               raise ValueError(snake_case      )

     def 			lowerCamelCase__			(    self					:		List[Any]							,			snake_case					:		str      )						->							str:
          __UpperCAmelCase     :			Tuple  							=      [char for char in text.upper() if char in self.key_string]

          __UpperCAmelCase     :			Tuple  							=      chars[-1]
          while len(snake_case      ) % self.break_key != 0:
               chars.append(snake_case      )

          return "".join(snake_case      )

     def 			lowerCamelCase__			(    self					:		List[str]							,			snake_case					:		str      )						->							str:
          __UpperCAmelCase     :			Optional[Any]  							=      self.process_text(text.upper()      )
          __UpperCAmelCase     :			int  							=      ''''''

          for i in range(0							,			len(snake_case      ) - self.break_key + 1							,			self.break_key      ):
               __UpperCAmelCase     :			List[Any]  							=      text[i : i + self.break_key]
               __UpperCAmelCase     :			str  							=      [self.replace_letters(snake_case      ) for char in batch]
               __UpperCAmelCase     :			Tuple  							=      numpy.array([vec]      ).T
               __UpperCAmelCase     :			Union[str, Any]  							=      self.modulus(self.encrypt_key.dot(snake_case      )      ).T.tolist()[
                   0
               ]
               __UpperCAmelCase     :			List[Any]  							=      ''''''.join(
                   self.replace_digits(snake_case      ) for num in batch_encrypted      )
               encrypted += encrypted_batch

          return encrypted

     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							numpy.ndarray:
          __UpperCAmelCase     :			Optional[Any]  							=      round(numpy.linalg.det(self.encrypt_key      )      )

          if det < 0:
               __UpperCAmelCase     :			List[str]  							=      det % len(self.key_string      )
          __UpperCAmelCase     :			str  							=      None
          for i in range(len(self.key_string      )      ):
               if (det * i) % len(self.key_string      ) == 1:
                    __UpperCAmelCase     :			Union[str, Any]  							=      i
                    break

          __UpperCAmelCase     :			int  							=      (
              det_inv
              * numpy.linalg.det(self.encrypt_key      )
              * numpy.linalg.inv(self.encrypt_key      )
          )

          return self.to_int(self.modulus(snake_case      )      )






     def 			lowerCamelCase__			(    self					:		Any							,			snake_case					:		str      )						->							str:
          __UpperCAmelCase     :			Tuple  							=      self.make_decrypt_key()
          __UpperCAmelCase     :			Union[str, Any]  							=      self.process_text(text.upper()      )
          __UpperCAmelCase     :			Dict  							=      ''''''

          for i in range(0							,			len(snake_case      ) - self.break_key + 1							,			self.break_key      ):
               __UpperCAmelCase     :			List[Any]  							=      text[i : i + self.break_key]
               __UpperCAmelCase     :			List[Any]  							=      [self.replace_letters(snake_case      ) for char in batch]
               __UpperCAmelCase     :			Optional[int]  							=      numpy.array([vec]      ).T
               __UpperCAmelCase     :			Union[str, Any]  							=      self.modulus(decrypt_key.dot(snake_case      )      ).T.tolist()[0]
               __UpperCAmelCase     :			List[Any]  							=      ''''''.join(
                   self.replace_digits(snake_case      ) for num in batch_decrypted      )
               decrypted += decrypted_batch

          return decrypted




def      _a     (						):





     '''simple docstring'''






     __UpperCAmelCase     :			int  							=      int(input('''Enter the order of the encryption key: '''  )  )
     __UpperCAmelCase     :			Tuple  							=      []

     print('''Enter each row of the encryption key with space separated integers'''  )
     for _ in range(_lowercase  ):
          __UpperCAmelCase     :			List[Any]  							=      [int(_lowercase  ) for x in input().split()]
          hill_matrix.append(_lowercase  )

     __UpperCAmelCase     :			Optional[Any]  							=      HillCipher(numpy.array(_lowercase  )  )

     print('''Would you like to encrypt or decrypt some text? (1 or 2)'''  )
     __UpperCAmelCase     :			int  							=      input('''\n1. Encrypt\n2. Decrypt\n'''  )
     if option == "1":
          __UpperCAmelCase     :			List[str]  							=      input('''What text would you like to encrypt?: '''  )
          print('''Your encrypted text is:'''  )
          print(hc.encrypt(_lowercase  )  )
     elif option == "2":
          __UpperCAmelCase     :			Optional[int]  							=      input('''What text would you like to decrypt?: '''  )
          print('''Your decrypted text is:'''  )
          print(hc.decrypt(_lowercase  )  )


if __name__ == "__main__":
      import doctest

      doctest.testmod()

      main()



'''simple docstring'''



import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class      a    (		_a     ,  _a     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       StableDiffusionXLImgaImgPipeline
     SCREAMING_SNAKE_CASE	:			Tuple							       =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       PipelineTesterMixin.required_optional_params - {"latents"}
     SCREAMING_SNAKE_CASE	:			int							       =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     SCREAMING_SNAKE_CASE	:			Union[str, Any]							       =       IMAGE_TO_IMAGE_IMAGE_PARAMS
     SCREAMING_SNAKE_CASE	:			Any							       =       IMAGE_TO_IMAGE_IMAGE_PARAMS

     def 			lowerCamelCase__			(    self					:		Any      )						->							Any:
          torch.manual_seed(0      )
          __UpperCAmelCase     :			Optional[Any]  							=      UNetaDConditionModel(
              block_out_channels=(32, 64)							,			layers_per_block=2							,			sample_size=32							,			in_channels=4							,			out_channels=4							,			down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							,			up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')							,			attention_head_dim=(2, 4)							,			use_linear_projection=snake_case							,			addition_embed_type='''text_time'''							,			addition_time_embed_dim=8							,			transformer_layers_per_block=(1, 2)							,			projection_class_embeddings_input_dim=80							,			cross_attention_dim=64							,			)
          __UpperCAmelCase     :			int  							=      EulerDiscreteScheduler(
              beta_start=0.00_085							,			beta_end=0.012							,			steps_offset=1							,			beta_schedule='''scaled_linear'''							,			timestep_spacing='''leading'''							,			)
          torch.manual_seed(0      )
          __UpperCAmelCase     :			Tuple  							=      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							,			sample_size=128							,			)
          torch.manual_seed(0      )
          __UpperCAmelCase     :			int  							=      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							,			hidden_act='''gelu'''							,			projection_dim=32							,			)
          __UpperCAmelCase     :			Tuple  							=      CLIPTextModel(snake_case      )
          __UpperCAmelCase     :			Optional[int]  							=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							,			local_files_only=snake_case      )

          __UpperCAmelCase     :			Optional[Any]  							=      CLIPTextModelWithProjection(snake_case      )
          __UpperCAmelCase     :			Union[str, Any]  							=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							,			local_files_only=snake_case      )

          __UpperCAmelCase     :			Tuple  							=      {
              '''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 			lowerCamelCase__			(    self					:		Dict							,			snake_case					:		Optional[int]							,			snake_case					:		List[str]=0      )						->							List[str]:
          __UpperCAmelCase     :			List[str]  							=      floats_tensor((1, 3, 32, 32)							,			rng=random.Random(snake_case      )      ).to(snake_case      )
          __UpperCAmelCase     :			Optional[Any]  							=      image / 2 + 0.5
          if str(snake_case      ).startswith('''mps'''      ):
               __UpperCAmelCase     :			List[str]  							=      torch.manual_seed(snake_case      )
          else:
               __UpperCAmelCase     :			Any  							=      torch.Generator(device=snake_case      ).manual_seed(snake_case      )
          __UpperCAmelCase     :			Optional[int]  							=      {
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''image''': image,
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''guidance_scale''': 5.0,
              '''output_type''': '''numpy''',
              '''strength''': 0.75,
          }
          return inputs

     def 			lowerCamelCase__			(    self					:		Tuple      )						->							Optional[int]:
          __UpperCAmelCase     :			Any  							=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator
          __UpperCAmelCase     :			Optional[Any]  							=      self.get_dummy_components()
          __UpperCAmelCase     :			Any  							=      StableDiffusionXLImgaImgPipeline(**snake_case      )
          __UpperCAmelCase     :			Union[str, Any]  							=      sd_pipe.to(snake_case      )
          sd_pipe.set_progress_bar_config(disable=snake_case      )

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

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

          __UpperCAmelCase     :			Any  							=      np.array([0.4_656, 0.4_840, 0.4_439, 0.6_698, 0.5_574, 0.4_524, 0.5_799, 0.5_943, 0.5_165]      )

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

     def 			lowerCamelCase__			(    self					:		Any      )						->							int:
          super().test_attention_slicing_forward_pass(expected_max_diff=3E-3      )

     def 			lowerCamelCase__			(    self					:		Optional[Any]      )						->							Optional[int]:
          super().test_inference_batch_single_identical(expected_max_diff=3E-3      )

     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							List[Any]:
          pass






     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							int:
          __UpperCAmelCase     :			Union[str, Any]  							=      self.get_dummy_components()
          __UpperCAmelCase     :			List[Any]  							=      StableDiffusionXLImgaImgPipeline(**snake_case      )
          __UpperCAmelCase     :			Tuple  							=      sd_pipe.to(snake_case      )
          __UpperCAmelCase     :			Tuple  							=      sd_pipe.to(snake_case      )
          sd_pipe.set_progress_bar_config(disable=snake_case      )

          # forward without prompt embeds
          __UpperCAmelCase     :			Tuple  							=      self.get_dummy_inputs(snake_case      )
          __UpperCAmelCase     :			Optional[Any]  							=      3 * ['''this is a negative prompt''']
          __UpperCAmelCase     :			Optional[int]  							=      negative_prompt
          __UpperCAmelCase     :			Tuple  							=      3 * [inputs['''prompt''']]

          __UpperCAmelCase     :			Optional[Any]  							=      sd_pipe(**snake_case      )
          __UpperCAmelCase     :			int  							=      output.images[0, -3:, -3:, -1]

          # forward with prompt embeds
          __UpperCAmelCase     :			Union[str, Any]  							=      self.get_dummy_inputs(snake_case      )
          __UpperCAmelCase     :			Tuple  							=      3 * ['''this is a negative prompt''']
          __UpperCAmelCase     :			str  							=      3 * [inputs.pop('''prompt'''      )]

          (
              (
              __UpperCAmelCase
          )							,       (
              __UpperCAmelCase
          )							,       (
              __UpperCAmelCase
          )							,       (
              __UpperCAmelCase
          )							,       
          )     :			Any  							=      sd_pipe.encode_prompt(snake_case							,			negative_prompt=snake_case      )

          __UpperCAmelCase     :			Dict  							=      sd_pipe(
              **snake_case							,			prompt_embeds=snake_case							,			negative_prompt_embeds=snake_case							,			pooled_prompt_embeds=snake_case							,			negative_pooled_prompt_embeds=snake_case							,			)
          __UpperCAmelCase     :			List[str]  							=      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



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


     """simple docstring"""






     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Optional[Any]:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()

     def 			lowerCamelCase__			(    self					:		int							,			snake_case					:		Any							,			snake_case					:		str="cpu"							,			snake_case					:		Tuple=torch.floataa							,			snake_case					:		List[str]=0      )						->							Tuple:
          __UpperCAmelCase     :			Optional[Any]  							=      torch.Generator(device=snake_case      ).manual_seed(snake_case      )
          __UpperCAmelCase     :			int  							=      np.random.RandomState(snake_case      ).standard_normal((1, 4, 64, 64)      )
          __UpperCAmelCase     :			str  							=      torch.from_numpy(snake_case      ).to(device=snake_case							,			dtype=snake_case      )
          __UpperCAmelCase     :			str  							=      {
              '''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 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							List[Any]:
          __UpperCAmelCase     :			str  							=      DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''      )
          pipe.to(snake_case      )
          pipe.set_progress_bar_config(disable=snake_case      )

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

          assert image.shape == (1, 512, 512, 3)
          __UpperCAmelCase     :			Tuple  							=      np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506]      )
          assert np.abs(image_slice - expected_slice      ).max() < 7E-3