

import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()

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

   def     UpperCamelCase					(				self	:    List[str]       ) ->			int:
         """simple docstring"""





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

   def     UpperCamelCase					(				self	:    List[str]       ) ->			Union[str, Any]:
         """simple docstring"""





         A_							       =		StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''       )
         A_							       =		sd_pipe.to(lowerCamelCase__       )
         sd_pipe.set_progress_bar_config(disable=lowerCamelCase__       )

         sd_pipe.set_scheduler('''sample_euler'''       )

         A_							       =		'''A painting of a squirrel eating a burger'''
         A_							       =		torch.manual_seed(0       )
         A_							       =		sd_pipe([prompt]			,						generator=lowerCamelCase__			,						guidance_scale=9.0			,						num_inference_steps=2_0			,						output_type='''np'''       )

         A_							       =		output.images

         A_							       =		image[0, -3:, -3:, -1]

         assert image.shape == (1, 5_1_2, 5_1_2, 3)
         A_							       =		np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]       )

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

   def     UpperCamelCase					(				self	:    Tuple       ) ->			int:
         """simple docstring"""





         A_							       =		StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''       )
         A_							       =		sd_pipe.to(lowerCamelCase__       )
         sd_pipe.set_progress_bar_config(disable=lowerCamelCase__       )

         sd_pipe.set_scheduler('''sample_euler'''       )

         A_							       =		'''A painting of a squirrel eating a burger'''
         A_							       =		torch.manual_seed(0       )
         A_							       =		sd_pipe([prompt]			,						generator=lowerCamelCase__			,						guidance_scale=9.0			,						num_inference_steps=2_0			,						output_type='''np'''       )

         A_							       =		output.images

         A_							       =		image[0, -3:, -3:, -1]

         assert image.shape == (1, 5_1_2, 5_1_2, 3)
         A_							       =		np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]       )

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





   def     UpperCamelCase					(				self	:    str       ) ->			Union[str, Any]:
         """simple docstring"""





         A_							       =		StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''       )
         A_							       =		sd_pipe.to(lowerCamelCase__       )
         sd_pipe.set_progress_bar_config(disable=lowerCamelCase__       )

         sd_pipe.set_scheduler('''sample_dpmpp_2m'''       )

         A_							       =		'''A painting of a squirrel eating a burger'''
         A_							       =		torch.manual_seed(0       )
         A_							       =		sd_pipe(
             [prompt]			,						generator=lowerCamelCase__			,						guidance_scale=7.5			,						num_inference_steps=1_5			,						output_type='''np'''			,						use_karras_sigmas=lowerCamelCase__			,						)

         A_							       =		output.images

         A_							       =		image[0, -3:, -3:, -1]

         assert image.shape == (1, 5_1_2, 5_1_2, 3)
         A_							       =		np.array(
             [0.11381689, 0.12112921, 0.1389457, 0.12549606, 0.1244964, 0.10831517, 0.11562866, 0.10867816, 0.10499048]       )

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








import random

class    _lowercase				:

   @staticmethod
   def     UpperCamelCase					(				lowerCamelCase__	:    str       ) ->			tuple[list[int], list[int]]:
         """simple docstring"""





         A_							       =		[ord(lowerCamelCase__       ) for i in text]
         A_							       =		[]
         A_							       =		[]
         for i in plain:
               A_							       =		random.randint(1			,						3_0_0       )
               A_							       =		(i + k) * k
               cipher.append(lowerCamelCase__       )
               key.append(lowerCamelCase__       )
         return cipher, key





   @staticmethod
   def     UpperCamelCase					(				lowerCamelCase__	:    list[int]			,						lowerCamelCase__	:    list[int]       ) ->			str:
         """simple docstring"""





         A_							       =		[]
         for i in range(len(lowerCamelCase__       )       ):
               A_							       =		int((cipher[i] - (key[i]) ** 2) / key[i]       )
               plain.append(chr(lowerCamelCase__       )       )
         return "".join(lowerCamelCase__       )


if __name__ == "__main__":
      __lowercase      ,				__lowercase				      =						Onepad().encrypt("""Hello""")
      print(c, k)
      print(Onepad().decrypt(c, k))





