






import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()


class 					_snake_case						(			_A       ,    _A       ,    unittest.TestCase ):
	_A          =   AutoencoderKL
	_A          =   'sample'
	_A          =   1e-2






	@property
	def    lowerCAmelCase_							(		self       )						->    int:
					snake_case__      :Tuple         =   4
					snake_case__      :str         =   3
					snake_case__      :Optional[int]         =   (32, 32)

					snake_case__      :str         =   floats_tensor((batch_size, num_channels) + sizes       ).to(UpperCamelCase       )

					return {"sample": image}






	@property
	def    lowerCAmelCase_							(		self       )						->    str:
					return (3, 32, 32)






	@property
	def    lowerCAmelCase_							(		self       )						->    Union[str, Any]:
					return (3, 32, 32)






	def    lowerCAmelCase_							(		self       )						->    List[Any]:
					snake_case__      :Dict         =   {
					    "block_out_channels": [32, 64],
					    "in_channels": 3,
					    "out_channels": 3,
					    "down_block_types": ["DownEncoderBlock2D", "DownEncoderBlock2D"],
					    "up_block_types": ["UpDecoderBlock2D", "UpDecoderBlock2D"],
					    "latent_channels": 4,
					}
					snake_case__      :List[Any]         =   self.dummy_input
					return init_dict, inputs_dict






	def    lowerCAmelCase_							(		self       )						->    Union[str, Any]:
					pass






	def    lowerCAmelCase_							(		self       )						->    List[str]:
					pass






	@unittest.skipIf(torch_device == "mps"					,"Gradient checkpointing skipped on MPS"       )
	def    lowerCAmelCase_							(		self       )						->    List[str]:
					# enable deterministic behavior for gradient checkpointing
					snake_case__      :Any         =   self.prepare_init_args_and_inputs_for_common()
					snake_case__      :Optional[int]         =   self.model_class(**UpperCamelCase       )
					model.to(UpperCamelCase       )

					assert not model.is_gradient_checkpointing and model.training

					snake_case__      :Union[str, Any]         =   model(**UpperCamelCase       ).sample
					# run the backwards pass on the model. For backwards pass, for simplicity purpose,
					# we won't calculate the loss and rather backprop on out.sum()
					model.zero_grad()

					snake_case__      :Optional[int]         =   torch.randn_like(UpperCamelCase       )
					snake_case__      :List[str]         =   (out - labels).mean()
					loss.backward()

					# re-instantiate the model now enabling gradient checkpointing
					snake_case__      :Any         =   self.model_class(**UpperCamelCase       )
					# clone model
					model_a.load_state_dict(model.state_dict()       )
					model_a.to(UpperCamelCase       )
					model_a.enable_gradient_checkpointing()

					assert model_a.is_gradient_checkpointing and model_a.training

					snake_case__      :str         =   model_a(**UpperCamelCase       ).sample
					# run the backwards pass on the model. For backwards pass, for simplicity purpose,
					# we won't calculate the loss and rather backprop on out.sum()
					model_a.zero_grad()
					snake_case__      :List[Any]         =   (out_a - labels).mean()
					loss_a.backward()

					# compare the output and parameters gradients
					self.assertTrue((loss - loss_a).abs() < 1E-5       )
					snake_case__      :Optional[int]         =   dict(model.named_parameters()       )
					snake_case__      :List[str]         =   dict(model_a.named_parameters()       )
					for name, param in named_params.items():
									self.assertTrue(torch_all_close(param.grad.data					,named_params_a[name].grad.data					,atol=5E-5       )       )






	def    lowerCAmelCase_							(		self       )						->    Optional[int]:
					snake_case__      :Optional[int]         =   AutoencoderKL.from_pretrained("fusing/autoencoder-kl-dummy"					,output_loading_info=UpperCamelCase       )
					self.assertIsNotNone(UpperCamelCase       )
					self.assertEqual(len(loading_info["missing_keys"]       )					,0       )

					model.to(UpperCamelCase       )
					snake_case__      :str         =   model(**self.dummy_input       )

					assert image is not None, "Make sure output is not None"






	def    lowerCAmelCase_							(		self       )						->    Union[str, Any]:
					snake_case__      :Optional[Any]         =   AutoencoderKL.from_pretrained("fusing/autoencoder-kl-dummy"       )
					snake_case__      :str         =   model.to(UpperCamelCase       )
					model.eval()

					if torch_device == "mps":
									snake_case__      :int         =   torch.manual_seed(0       )
					else:
									snake_case__      :Tuple         =   torch.Generator(device=UpperCamelCase       ).manual_seed(0       )

					snake_case__      :Optional[int]         =   torch.randn(
					    1					,model.config.in_channels					,model.config.sample_size					,model.config.sample_size					,generator=torch.manual_seed(0       )					,)
					snake_case__      :Optional[Any]         =   image.to(UpperCamelCase       )
					with torch.no_grad():
									snake_case__      :Dict         =   model(UpperCamelCase					,sample_posterior=UpperCamelCase					,generator=UpperCamelCase       ).sample

					snake_case__      :Tuple         =   output[0, -1, -3:, -3:].flatten().cpu()

					# Since the VAE Gaussian prior's generator is seeded on the appropriate device,
					# the expected output slices are not the same for CPU and GPU.
					if torch_device == "mps":
									snake_case__      :Union[str, Any]         =   torch.tensor(
									    [
									        -4.0_078E-01,
									        -3.8_323E-04,
									        -1.2_681E-01,
									        -1.1_462E-01,
									        2.0_095E-01,
									        1.0_893E-01,
									        -8.8_247E-02,
									        -3.0_361E-01,
									        -9.8_644E-03,
									    ]       )
					elif torch_device == "cpu":
									snake_case__      :str         =   torch.tensor(
									    [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026]       )
					else:
									snake_case__      :List[str]         =   torch.tensor(
									    [-0.2421, 0.4642, 0.2507, -0.0438, 0.0682, 0.3160, -0.2018, -0.0727, 0.2485]       )

					self.assertTrue(torch_all_close(UpperCamelCase					,UpperCamelCase					,rtol=1E-2       )       )




@slow
class 					_snake_case						(			unittest.TestCase ):






	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase       )						->    str:
					return f'gaussian_noise_s={seed}_shape={"_".join([str(UpperCamelCase       ) for s in shape]       )}.npy'






	def    lowerCAmelCase_							(		self       )						->    Optional[Any]:
					# clean up the VRAM after each test
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()






	def    lowerCAmelCase_							(		self					,UpperCamelCase=0					,UpperCamelCase=(4, 3, 512, 512)					,UpperCamelCase=False       )						->    Optional[int]:
					snake_case__      :str         =   torch.floataa if fpaa else torch.floataa
					snake_case__      :Dict         =   torch.from_numpy(load_hf_numpy(self.get_file_format(UpperCamelCase					,UpperCamelCase       )       )       ).to(UpperCamelCase       ).to(UpperCamelCase       )
					return image






	def    lowerCAmelCase_							(		self					,UpperCamelCase="CompVis/stable-diffusion-v1-4"					,UpperCamelCase=False       )						->    Dict:
					snake_case__      :List[Any]         =   "fp16" if fpaa else None
					snake_case__      :Dict         =   torch.floataa if fpaa else torch.floataa

					snake_case__      :List[str]         =   AutoencoderKL.from_pretrained(
					    UpperCamelCase					,subfolder="vae"					,torch_dtype=UpperCamelCase					,revision=UpperCamelCase					,)
					model.to(UpperCamelCase       ).eval()

					return model






	def    lowerCAmelCase_							(		self					,UpperCamelCase=0       )						->    List[Any]:
					if torch_device == "mps":
									return torch.manual_seed(UpperCamelCase       )
					return torch.Generator(device=UpperCamelCase       ).manual_seed(UpperCamelCase       )






	@parameterized.expand(
	    [
	        # fmt: off
	        [33, [-0.1603, 0.9878, -0.0495, -0.0790, -0.2709, 0.8375, -0.2060, -0.0824], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
	        [47, [-0.2376, 0.1168, 0.1332, -0.4840, -0.2508, -0.0791, -0.0493, -0.4089], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
	        # fmt: on
	    ]       )
	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase					,UpperCamelCase       )						->    int:
					snake_case__      :List[Any]         =   self.get_sd_vae_model()
					snake_case__      :Tuple         =   self.get_sd_image(UpperCamelCase       )
					snake_case__      :Any         =   self.get_generator(UpperCamelCase       )

					with torch.no_grad():
									snake_case__      :Tuple         =   model(UpperCamelCase					,generator=UpperCamelCase					,sample_posterior=UpperCamelCase       ).sample

					assert sample.shape == image.shape

					snake_case__      :Any         =   sample[-1, -2:, -2:, :2].flatten().float().cpu()
					snake_case__      :str         =   torch.tensor(expected_slice_mps if torch_device == "mps" else expected_slice       )

					assert torch_all_close(UpperCamelCase					,UpperCamelCase					,atol=3E-3       )






	@parameterized.expand(
	    [
	        # fmt: off
	        [33, [-0.0513, 0.0289, 1.3799, 0.2166, -0.2573, -0.0871, 0.5103, -0.0999]],
	        [47, [-0.4128, -0.1320, -0.3704, 0.1965, -0.4116, -0.2332, -0.3340, 0.2247]],
	        # fmt: on
	    ]       )
	@require_torch_gpu
	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase       )						->    int:
					snake_case__      :str         =   self.get_sd_vae_model(fpaa=UpperCamelCase       )
					snake_case__      :str         =   self.get_sd_image(UpperCamelCase					,fpaa=UpperCamelCase       )
					snake_case__      :List[Any]         =   self.get_generator(UpperCamelCase       )

					with torch.no_grad():
									snake_case__      :str         =   model(UpperCamelCase					,generator=UpperCamelCase					,sample_posterior=UpperCamelCase       ).sample

					assert sample.shape == image.shape

					snake_case__      :Optional[Any]         =   sample[-1, -2:, :2, -2:].flatten().float().cpu()
					snake_case__      :Optional[int]         =   torch.tensor(UpperCamelCase       )

					assert torch_all_close(UpperCamelCase					,UpperCamelCase					,atol=1E-2       )






	@parameterized.expand(
	    [
	        # fmt: off
	        [33, [-0.1609, 0.9866, -0.0487, -0.0777, -0.2716, 0.8368, -0.2055, -0.0814], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
	        [47, [-0.2377, 0.1147, 0.1333, -0.4841, -0.2506, -0.0805, -0.0491, -0.4085], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
	        # fmt: on
	    ]       )
	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase					,UpperCamelCase       )						->    List[Any]:
					snake_case__      :Dict         =   self.get_sd_vae_model()
					snake_case__      :List[str]         =   self.get_sd_image(UpperCamelCase       )

					with torch.no_grad():
									snake_case__      :str         =   model(UpperCamelCase       ).sample

					assert sample.shape == image.shape

					snake_case__      :Union[str, Any]         =   sample[-1, -2:, -2:, :2].flatten().float().cpu()
					snake_case__      :List[Any]         =   torch.tensor(expected_slice_mps if torch_device == "mps" else expected_slice       )

					assert torch_all_close(UpperCamelCase					,UpperCamelCase					,atol=3E-3       )






	@parameterized.expand(
	    [
	        # fmt: off
	        [13, [-0.2051, -0.1803, -0.2311, -0.2114, -0.3292, -0.3574, -0.2953, -0.3323]],
	        [37, [-0.2632, -0.2625, -0.2199, -0.2741, -0.4539, -0.4990, -0.3720, -0.4925]],
	        # fmt: on
	    ]       )
	@require_torch_gpu
	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase       )						->    str:
					snake_case__      :Optional[Any]         =   self.get_sd_vae_model()
					snake_case__      :Union[str, Any]         =   self.get_sd_image(UpperCamelCase					,shape=(3, 4, 64, 64)       )

					with torch.no_grad():
									snake_case__      :Optional[int]         =   model.decode(UpperCamelCase       ).sample

					assert list(sample.shape       ) == [3, 3, 512, 512]

					snake_case__      :str         =   sample[-1, -2:, :2, -2:].flatten().cpu()
					snake_case__      :Optional[int]         =   torch.tensor(UpperCamelCase       )

					assert torch_all_close(UpperCamelCase					,UpperCamelCase					,atol=1E-3       )






	@parameterized.expand(
	    [
	        # fmt: off
	        [27, [-0.0369, 0.0207, -0.0776, -0.0682, -0.1747, -0.1930, -0.1465, -0.2039]],
	        [16, [-0.1628, -0.2134, -0.2747, -0.2642, -0.3774, -0.4404, -0.3687, -0.4277]],
	        # fmt: on
	    ]       )
	@require_torch_gpu
	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase       )						->    Optional[Any]:
					snake_case__      :str         =   self.get_sd_vae_model(fpaa=UpperCamelCase       )
					snake_case__      :Union[str, Any]         =   self.get_sd_image(UpperCamelCase					,shape=(3, 4, 64, 64)					,fpaa=UpperCamelCase       )

					with torch.no_grad():
									snake_case__      :Dict         =   model.decode(UpperCamelCase       ).sample

					assert list(sample.shape       ) == [3, 3, 512, 512]

					snake_case__      :List[str]         =   sample[-1, -2:, :2, -2:].flatten().float().cpu()
					snake_case__      :Union[str, Any]         =   torch.tensor(UpperCamelCase       )

					assert torch_all_close(UpperCamelCase					,UpperCamelCase					,atol=5E-3       )






	@parameterized.expand([(13,), (16,), (27,)]       )
	@require_torch_gpu
	@unittest.skipIf(not is_xformers_available()					,reason="xformers is not required when using PyTorch 2.0."       )
	def    lowerCAmelCase_							(		self					,UpperCamelCase       )						->    Union[str, Any]:
					snake_case__      :Union[str, Any]         =   self.get_sd_vae_model(fpaa=UpperCamelCase       )
					snake_case__      :Any         =   self.get_sd_image(UpperCamelCase					,shape=(3, 4, 64, 64)					,fpaa=UpperCamelCase       )

					with torch.no_grad():
									snake_case__      :str         =   model.decode(UpperCamelCase       ).sample

					model.enable_xformers_memory_efficient_attention()
					with torch.no_grad():
									snake_case__      :List[Any]         =   model.decode(UpperCamelCase       ).sample

					assert list(sample.shape       ) == [3, 3, 512, 512]

					assert torch_all_close(UpperCamelCase					,UpperCamelCase					,atol=1E-1       )






	@parameterized.expand([(13,), (16,), (37,)]       )
	@require_torch_gpu
	@unittest.skipIf(not is_xformers_available()					,reason="xformers is not required when using PyTorch 2.0."       )
	def    lowerCAmelCase_							(		self					,UpperCamelCase       )						->    Optional[Any]:
					snake_case__      :Any         =   self.get_sd_vae_model()
					snake_case__      :int         =   self.get_sd_image(UpperCamelCase					,shape=(3, 4, 64, 64)       )

					with torch.no_grad():
									snake_case__      :Tuple         =   model.decode(UpperCamelCase       ).sample

					model.enable_xformers_memory_efficient_attention()
					with torch.no_grad():
									snake_case__      :str         =   model.decode(UpperCamelCase       ).sample

					assert list(sample.shape       ) == [3, 3, 512, 512]

					assert torch_all_close(UpperCamelCase					,UpperCamelCase					,atol=1E-2       )






	@parameterized.expand(
	    [
	        # fmt: off
	        [33, [-0.3001, 0.0918, -2.6984, -3.9720, -3.2099, -5.0353, 1.7338, -0.2065, 3.4267]],
	        [47, [-1.5030, -4.3871, -6.0355, -9.1157, -1.6661, -2.7853, 2.1607, -5.0823, 2.5633]],
	        # fmt: on
	    ]       )
	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase       )						->    List[str]:
					snake_case__      :Tuple         =   self.get_sd_vae_model()
					snake_case__      :Any         =   self.get_sd_image(UpperCamelCase       )
					snake_case__      :Optional[int]         =   self.get_generator(UpperCamelCase       )

					with torch.no_grad():
									snake_case__      :int         =   model.encode(UpperCamelCase       ).latent_dist
									snake_case__      :Union[str, Any]         =   dist.sample(generator=UpperCamelCase       )

					assert list(sample.shape       ) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

					snake_case__      :List[str]         =   sample[0, -1, -3:, -3:].flatten().cpu()
					snake_case__      :Optional[int]         =   torch.tensor(UpperCamelCase       )

					snake_case__      :str         =   3E-3 if torch_device != "mps" else 1E-2
					assert torch_all_close(UpperCamelCase					,UpperCamelCase					,atol=UpperCamelCase       )







def 					lowercase_ (    __snake_case     :							Tuple	,	__snake_case     :							Optional[int]      )     -> List[Any]:





				'''simple docstring'''


				snake_case__      :Dict         =   ""
				for i in table:
								res += inp[i - 1]
				return res





def 					lowercase_ (    __snake_case     :							List[str]      )     -> int:





				'''simple docstring'''


				return data[1:] + data[0]





def 					lowercase_ (    __snake_case     :							int	,	__snake_case     :							Union[str, Any]      )     -> Union[str, Any]:





				'''simple docstring'''


				snake_case__      :Union[str, Any]         =   ""
				for i in range(len(__snake_case      )      ):
								if a[i] == b[i]:
												res += "0"
								else:
												res += "1"
				return res





def 					lowercase_ (    __snake_case     :							Optional[int]	,	__snake_case     :							Dict      )     -> Union[str, Any]:





				'''simple docstring'''


				snake_case__      :int         =   int("0b" + data[0] + data[-1]	,	2      )
				snake_case__      :Union[str, Any]         =   int("0b" + data[1:3]	,	2      )
				return bin(s[row][col]      )[2:]





def 					lowercase_ (    __snake_case     :							Dict	,	__snake_case     :							Optional[Any]	,	__snake_case     :							Dict	,	__snake_case     :							List[Any]	,	__snake_case     :							Optional[int]      )     -> List[str]:





				'''simple docstring'''


				snake_case__      :Tuple         =   message[:4]
				snake_case__      :int         =   message[4:]
				snake_case__      :int         =   apply_table(__snake_case	,	__snake_case      )
				snake_case__      :Union[str, Any]         =   xor(__snake_case	,	__snake_case      )
				snake_case__      :Tuple         =   apply_sbox(__snake_case	,	temp[:4]      )  # noqa: E741
				snake_case__      :List[str]         =   apply_sbox(__snake_case	,	temp[4:]      )
				snake_case__      :int         =   "0" * (2 - len(__snake_case      )) + l  # noqa: E741
				snake_case__      :int         =   "0" * (2 - len(__snake_case      )) + r
				snake_case__      :Optional[Any]         =   apply_table(l + r	,	__snake_case      )
				snake_case__      :Tuple         =   xor(__snake_case	,	__snake_case      )
				return temp + right


if __name__ == "__main__":
	__UpperCAmelCase							:   Dict							=  input("Enter 10 bit key: ")
	__UpperCAmelCase							:   Tuple							=  input("Enter 8 bit message: ")

	__UpperCAmelCase							:   Any							=  [6, 3, 7, 4, 8, 5, 1_0, 9]
	__UpperCAmelCase							:   List[str]							=  [3, 5, 2, 7, 4, 1_0, 1, 9, 8, 6]
	__UpperCAmelCase							:   Tuple							=  [2, 4, 3, 1]
	__UpperCAmelCase							:   List[Any]							=  [2, 6, 3, 1, 4, 8, 5, 7]
	__UpperCAmelCase							:   Optional[Any]							=  [4, 1, 3, 5, 7, 2, 8, 6]
	__UpperCAmelCase							:   Optional[int]							=  [4, 1, 2, 3, 2, 3, 4, 1]
	__UpperCAmelCase							:   List[Any]							=  [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
	__UpperCAmelCase							:   Union[str, Any]							=  [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

	# key generation
	__UpperCAmelCase							:   int							=  apply_table(key, paa_table)
	__UpperCAmelCase							:   Dict							=  temp[:5]
	__UpperCAmelCase							:   Optional[int]							=  temp[5:]
	__UpperCAmelCase							:   Optional[int]							=  left_shift(left)
	__UpperCAmelCase							:   Union[str, Any]							=  left_shift(right)
	__UpperCAmelCase							:   int							=  apply_table(left + right, pa_table)
	__UpperCAmelCase							:   Tuple							=  left_shift(left)
	__UpperCAmelCase							:   Union[str, Any]							=  left_shift(right)
	__UpperCAmelCase							:   Dict							=  left_shift(left)
	__UpperCAmelCase							:   Optional[Any]							=  left_shift(right)
	__UpperCAmelCase							:   Optional[int]							=  apply_table(left + right, pa_table)

	# encryption
	__UpperCAmelCase							:   Tuple							=  apply_table(message, IP)
	__UpperCAmelCase							:   Tuple							=  function(expansion, sa, sa, keya, temp)
	__UpperCAmelCase							:   List[Any]							=  temp[4:] + temp[:4]
	__UpperCAmelCase							:   int							=  function(expansion, sa, sa, keya, temp)
	__UpperCAmelCase							:   Union[str, Any]							=  apply_table(temp, IP_inv)
	print("Cipher text is:", CT)

	# decryption
	__UpperCAmelCase							:   List[Any]							=  apply_table(CT, IP)
	__UpperCAmelCase							:   List[Any]							=  function(expansion, sa, sa, keya, temp)
	__UpperCAmelCase							:   int							=  temp[4:] + temp[:4]
	__UpperCAmelCase							:   Union[str, Any]							=  function(expansion, sa, sa, keya, temp)
	__UpperCAmelCase							:   Union[str, Any]							=  apply_table(temp, IP_inv)
	print("Plain text after decypting is:", PT)