






"""simple docstring"""



import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class 	_UpperCamelCase ( __UpperCamelCase		,     __UpperCamelCase		,     __UpperCamelCase		,     unittest.TestCase							):



    '''simple docstring'''


    __lowercase    :   Union[str, Any]											=						StableDiffusionImageVariationPipeline
    __lowercase    :   Optional[Any]											=						IMAGE_VARIATION_PARAMS
    __lowercase    :   str											=						IMAGE_VARIATION_BATCH_PARAMS
    __lowercase    :   Optional[Any]											=						frozenset([]							)
    # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
    __lowercase    :   int											=						frozenset([]							)


    def 		A__      (      self			):
     torch.manual_seed(0			)
     UpperCAmelCase__ 						=				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""")   ,			cross_attention_dim=32   ,			)
     UpperCAmelCase__ 						=				PNDMScheduler(skip_prk_steps=__lowercase			)
     torch.manual_seed(0			)
     UpperCAmelCase__ 						=				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   ,			)
     torch.manual_seed(0			)
     UpperCAmelCase__ 						=				CLIPVisionConfig(
         hidden_size=32   ,			projection_dim=32   ,			intermediate_size=37   ,			layer_norm_eps=1e-05   ,			num_attention_heads=4   ,			num_hidden_layers=5   ,			image_size=32   ,			patch_size=4   ,			)
     UpperCAmelCase__ 						=				CLIPVisionModelWithProjection(__lowercase			)
     UpperCAmelCase__ 						=				CLIPImageProcessor(crop_size=32   ,			size=32			)

     UpperCAmelCase__ 						=				{
         """unet""": unet,
         """scheduler""": scheduler,
         """vae""": vae,
         """image_encoder""": image_encoder,
         """feature_extractor""": feature_extractor,
         """safety_checker""": None,
     }
     return components


    def 		A__      (      self   ,			__lowercase   ,			__lowercase=0			):
     UpperCAmelCase__ 						=				floats_tensor((1, 3, 32, 32)   ,			rng=random.Random(__lowercase			)			)
     UpperCAmelCase__ 						=				image.cpu().permute(0   ,			2   ,			3   ,			1			)[0]
     UpperCAmelCase__ 						=				Image.fromarray(np.uinta(__lowercase			)			).convert("""RGB"""			).resize((32, 32)			)
     if str(__lowercase			).startswith("""mps"""			):
      UpperCAmelCase__ 						=				torch.manual_seed(__lowercase			)
     else:
      UpperCAmelCase__ 						=				torch.Generator(device=__lowercase			).manual_seed(__lowercase			)
     UpperCAmelCase__ 						=				{
         """image""": image,
         """generator""": generator,
         """num_inference_steps""": 2,
         """guidance_scale""": 6.0,
         """output_type""": """numpy""",
     }
     return inputs


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				"""cpu"""  # ensure determinism for the device-dependent torch.Generator
     UpperCAmelCase__ 						=				self.get_dummy_components()
     UpperCAmelCase__ 						=				StableDiffusionImageVariationPipeline(**__lowercase			)
     UpperCAmelCase__ 						=				sd_pipe.to(__lowercase			)
     sd_pipe.set_progress_bar_config(disable=__lowercase			)

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

     assert image.shape == (1, 64, 64, 3)
     UpperCAmelCase__ 						=				np.array([0.5_239, 0.5_723, 0.4_796, 0.5_049, 0.5_550, 0.4_685, 0.5_329, 0.4_891, 0.4_921]			)

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


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				"""cpu"""  # ensure determinism for the device-dependent torch.Generator
     UpperCAmelCase__ 						=				self.get_dummy_components()
     UpperCAmelCase__ 						=				StableDiffusionImageVariationPipeline(**__lowercase			)
     UpperCAmelCase__ 						=				sd_pipe.to(__lowercase			)
     sd_pipe.set_progress_bar_config(disable=__lowercase			)

     UpperCAmelCase__ 						=				self.get_dummy_inputs(__lowercase			)
     UpperCAmelCase__ 						=				2 * [inputs["""image"""]]
     UpperCAmelCase__ 						=				sd_pipe(**__lowercase			)

     UpperCAmelCase__ 						=				output.images

     UpperCAmelCase__ 						=				image[-1, -3:, -3:, -1]

     assert image.shape == (2, 64, 64, 3)
     UpperCAmelCase__ 						=				np.array([0.6_892, 0.5_637, 0.5_836, 0.5_771, 0.6_254, 0.6_409, 0.5_580, 0.5_569, 0.5_289]			)

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






    def 		A__      (      self			):
     super().test_inference_batch_single_identical(expected_max_diff=3e-3			)



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



    '''simple docstring'''


    def 		A__      (      self			):
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()


    def 		A__      (      self   ,			__lowercase   ,			__lowercase="cpu"   ,			__lowercase=torch.floataa   ,			__lowercase=0			):
     UpperCAmelCase__ 						=				torch.Generator(device=__lowercase			).manual_seed(__lowercase			)
     UpperCAmelCase__ 						=				load_image(
         """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
         """/stable_diffusion_imgvar/input_image_vermeer.png"""			)
     UpperCAmelCase__ 						=				np.random.RandomState(__lowercase			).standard_normal((1, 4, 64, 64)			)
     UpperCAmelCase__ 						=				torch.from_numpy(__lowercase			).to(device=__lowercase   ,			dtype=__lowercase			)
     UpperCAmelCase__ 						=				{
         """image""": init_image,
         """latents""": latents,
         """generator""": generator,
         """num_inference_steps""": 3,
         """guidance_scale""": 7.5,
         """output_type""": """numpy""",
     }
     return inputs


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				StableDiffusionImageVariationPipeline.from_pretrained(
         """lambdalabs/sd-image-variations-diffusers"""   ,			safety_checker=__lowercase			)
     UpperCAmelCase__ 						=				sd_pipe.to(__lowercase			)
     sd_pipe.set_progress_bar_config(disable=__lowercase			)

     UpperCAmelCase__ 						=				self.get_inputs(__lowercase			)
     UpperCAmelCase__ 						=				sd_pipe(**__lowercase			).images
     UpperCAmelCase__ 						=				image[0, -3:, -3:, -1].flatten()

     assert image.shape == (1, 512, 512, 3)
     UpperCAmelCase__ 						=				np.array([0.84_491, 0.90_789, 0.75_708, 0.78_734, 0.83_485, 0.70_099, 0.66_938, 0.68_727, 0.61_379]			)
     assert np.abs(image_slice - expected_slice			).max() < 6e-3


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				0

     def callback_fn(__lowercase   ,			__lowercase   ,			__lowercase			) -> None:
      UpperCAmelCase__ 						=				True
      nonlocal number_of_steps
      number_of_steps += 1
      if step == 1:
       UpperCAmelCase__ 						=				latents.detach().cpu().numpy()
       assert latents.shape == (1, 4, 64, 64)
       UpperCAmelCase__ 						=				latents[0, -3:, -3:, -1]
       UpperCAmelCase__ 						=				np.array(
           [-0.1_621, 0.2_837, -0.7_979, -0.1_221, -1.3_057, 0.7_681, -2.1_191, 0.0_464, 1.6_309]			)

       assert np.abs(latents_slice.flatten() - expected_slice			).max() < 5e-2
      elif step == 2:
       UpperCAmelCase__ 						=				latents.detach().cpu().numpy()
       assert latents.shape == (1, 4, 64, 64)
       UpperCAmelCase__ 						=				latents[0, -3:, -3:, -1]
       UpperCAmelCase__ 						=				np.array([0.6_299, 1.7_500, 1.1_992, -2.1_582, -1.8_994, 0.7_334, -0.7_090, 1.0_137, 1.5_273]			)

       assert np.abs(latents_slice.flatten() - expected_slice			).max() < 5e-2

     UpperCAmelCase__ 						=				False

     UpperCAmelCase__ 						=				StableDiffusionImageVariationPipeline.from_pretrained(
         """fusing/sd-image-variations-diffusers"""   ,			safety_checker=__lowercase   ,			torch_dtype=torch.floataa   ,			)
     pipe.to(__lowercase			)
     pipe.set_progress_bar_config(disable=__lowercase			)
     pipe.enable_attention_slicing()

     UpperCAmelCase__ 						=				self.get_inputs(__lowercase   ,			dtype=torch.floataa			)
     pipe(**__lowercase   ,			callback=__lowercase   ,			callback_steps=1			)
     assert callback_fn.has_been_called
     assert number_of_steps == inputs["num_inference_steps"]






    def 		A__      (      self			):
     torch.cuda.empty_cache()
     torch.cuda.reset_max_memory_allocated()
     torch.cuda.reset_peak_memory_stats()

     UpperCAmelCase__ 						=				"""fusing/sd-image-variations-diffusers"""
     UpperCAmelCase__ 						=				StableDiffusionImageVariationPipeline.from_pretrained(
         __lowercase   ,			safety_checker=__lowercase   ,			torch_dtype=torch.floataa			)
     UpperCAmelCase__ 						=				pipe.to(__lowercase			)
     pipe.set_progress_bar_config(disable=__lowercase			)
     pipe.enable_attention_slicing(1			)
     pipe.enable_sequential_cpu_offload()

     UpperCAmelCase__ 						=				self.get_inputs(__lowercase   ,			dtype=torch.floataa			)
     UpperCAmelCase__ 						=				pipe(**__lowercase			)

     UpperCAmelCase__ 						=				torch.cuda.max_memory_allocated()
     # make sure that less than 2.6 GB is allocated
     assert mem_bytes < 2.6 * 10**9



@nightly
@require_torch_gpu
class 	_UpperCamelCase ( unittest.TestCase							):



    '''simple docstring'''


    def 		A__      (      self			):
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()


    def 		A__      (      self   ,			__lowercase   ,			__lowercase="cpu"   ,			__lowercase=torch.floataa   ,			__lowercase=0			):
     UpperCAmelCase__ 						=				torch.Generator(device=__lowercase			).manual_seed(__lowercase			)
     UpperCAmelCase__ 						=				load_image(
         """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
         """/stable_diffusion_imgvar/input_image_vermeer.png"""			)
     UpperCAmelCase__ 						=				np.random.RandomState(__lowercase			).standard_normal((1, 4, 64, 64)			)
     UpperCAmelCase__ 						=				torch.from_numpy(__lowercase			).to(device=__lowercase   ,			dtype=__lowercase			)
     UpperCAmelCase__ 						=				{
         """image""": init_image,
         """latents""": latents,
         """generator""": generator,
         """num_inference_steps""": 50,
         """guidance_scale""": 7.5,
         """output_type""": """numpy""",
     }
     return inputs


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				StableDiffusionImageVariationPipeline.from_pretrained("""fusing/sd-image-variations-diffusers"""			)
     sd_pipe.to(__lowercase			)
     sd_pipe.set_progress_bar_config(disable=__lowercase			)

     UpperCAmelCase__ 						=				self.get_inputs(__lowercase			)
     UpperCAmelCase__ 						=				sd_pipe(**__lowercase			).images[0]

     UpperCAmelCase__ 						=				load_numpy(
         """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
         """/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy"""			)
     UpperCAmelCase__ 						=				np.abs(expected_image - image			).max()
     assert max_diff < 1e-3






    def 		A__      (      self			):
     UpperCAmelCase__ 						=				StableDiffusionImageVariationPipeline.from_pretrained("""fusing/sd-image-variations-diffusers"""			)
     UpperCAmelCase__ 						=				DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config			)
     sd_pipe.to(__lowercase			)
     sd_pipe.set_progress_bar_config(disable=__lowercase			)

     UpperCAmelCase__ 						=				self.get_inputs(__lowercase			)
     UpperCAmelCase__ 						=				25
     UpperCAmelCase__ 						=				sd_pipe(**__lowercase			).images[0]

     UpperCAmelCase__ 						=				load_numpy(
         """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
         """/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy"""			)
     UpperCAmelCase__ 						=				np.abs(expected_image - image			).max()
     assert max_diff < 1e-3











"""simple docstring"""



from string import ascii_uppercase




def       snake_case__		(   _SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE = False       ,	_SCREAMING_SNAKE_CASE = ascii_uppercase			)    ->str:
 UpperCAmelCase__ 						=				keyword.upper()
 UpperCAmelCase__ 						=				plaintext.upper()
 UpperCAmelCase__ 						=				set(_SCREAMING_SNAKE_CASE			)

 # create a list of unique characters in the keyword - their order matters
 # it determines how we will map plaintext characters to the ciphertext
 UpperCAmelCase__ 						=				[]
 for char in keyword:
  if char in alphabet_set and char not in unique_chars:
   unique_chars.append(_SCREAMING_SNAKE_CASE			)
    # the number of those unique characters will determine the number of rows
 UpperCAmelCase__ 						=				len(_SCREAMING_SNAKE_CASE			)

 # create a shifted version of the alphabet
 UpperCAmelCase__ 						=				unique_chars + [
     char for char in alphabet if char not in unique_chars
 ]

 # create a modified alphabet by splitting the shifted alphabet into rows
 UpperCAmelCase__ 						=				[
     shifted_alphabet[k : k + num_unique_chars_in_keyword]
     for k in range(0       ,	2_6       ,	_SCREAMING_SNAKE_CASE			)
 ]

 # map the alphabet characters to the modified alphabet characters
 # going 'vertically' through the modified alphabet - consider columns first
 UpperCAmelCase__ 						=				{}
 UpperCAmelCase__ 						=				0
 for column in range(_SCREAMING_SNAKE_CASE			):
  for row in modified_alphabet:
   # if current row (the last one) is too short, break out of loop
   if len(_SCREAMING_SNAKE_CASE			) <= column:
    break

   # map current letter to letter in modified alphabet
   UpperCAmelCase__ 						=				row[column]
   letter_index += 1

 if verbose:
  print(_SCREAMING_SNAKE_CASE			)
 # create the encrypted text by mapping the plaintext to the modified alphabet
 return "".join(mapping[char] if char in mapping else char for char in plaintext			)


if __name__ == "__main__":
 # example use
 print(mixed_keyword('''college''', '''UNIVERSITY'''))



