





'''simple docstring'''



import gc
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






class 							__lowercase    ( lowerCAmelCase__	, unittest.TestCase  ):







	'''simple docstring'''

	a      :			Optional[Any]     =    LDMTextToImagePipeline
	a      :			Any     =    TEXT_TO_IMAGE_PARAMS - {
	    "negative_prompt",
	    "negative_prompt_embeds",
	    "cross_attention_kwargs",
	    "prompt_embeds",
	}
	a      :			Any     =    PipelineTesterMixin.required_optional_params - {
	    "num_images_per_prompt",
	    "callback",
	    "callback_steps",
	}
	a      :			str     =    TEXT_TO_IMAGE_BATCH_PARAMS
	a      :			int     =    False


	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''simple docstring'''





				torch.manual_seed(0	)
				__lowercase			  =							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       ,)
				__lowercase			  =							DDIMScheduler(
				    beta_start=0.0_0_0_8_5       ,beta_end=0.0_1_2       ,beta_schedule='''scaled_linear'''       ,clip_sample=_lowerCamelCase       ,set_alpha_to_one=_lowerCamelCase       ,)
				torch.manual_seed(0	)
				__lowercase			  =							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	)
				__lowercase			  =							CLIPTextConfig(
				    bos_token_id=0       ,eos_token_id=2       ,hidden_size=32       ,intermediate_size=37       ,layer_norm_eps=1E-0_5       ,num_attention_heads=4       ,num_hidden_layers=5       ,pad_token_id=1       ,vocab_size=1000       ,)
				__lowercase			  =							CLIPTextModel(_lowerCamelCase	)
				__lowercase			  =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

				__lowercase			  =							{
				    '''unet''': unet,
				    '''scheduler''': scheduler,
				    '''vqvae''': vae,
				    '''bert''': text_encoder,
				    '''tokenizer''': tokenizer,
				}
				return components


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase=0	)							->							Tuple:







				'''simple docstring'''





				if str(_lowerCamelCase	).startswith('''mps'''	):
							__lowercase			  =							torch.manual_seed(_lowerCamelCase	)
				else:
							__lowercase			  =							torch.Generator(device=_lowerCamelCase	).manual_seed(_lowerCamelCase	)
				__lowercase			  =							{
				    '''prompt''': '''A painting of a squirrel eating a burger''',
				    '''generator''': generator,
				    '''num_inference_steps''': 2,
				    '''guidance_scale''': 6.0,
				    '''output_type''': '''numpy''',
				}
				return inputs


	def   _UpperCAmelCase       (self	)							->							List[Any]:







				'''simple docstring'''





				__lowercase			  =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator

				__lowercase			  =							self.get_dummy_components()
				__lowercase			  =							LDMTextToImagePipeline(**_lowerCamelCase	)
				pipe.to(_lowerCamelCase	)
				pipe.set_progress_bar_config(disable=_lowerCamelCase	)

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

				assert image.shape == (1, 16, 16, 3)
				__lowercase			  =							np.array([0.6_1_0_1, 0.6_1_5_6, 0.5_6_2_2, 0.4_8_9_5, 0.6_6_6_1, 0.3_8_0_4, 0.5_7_4_8, 0.6_1_3_6, 0.5_0_1_4]	)

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






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







	'''simple docstring'''

	def   _UpperCAmelCase       (self	)							->							str:







				'''simple docstring'''





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


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase=torch.floataa       ,_lowerCamelCase=0	)							->							Any:







				'''simple docstring'''





				__lowercase			  =							torch.manual_seed(_lowerCamelCase	)
				__lowercase			  =							np.random.RandomState(_lowerCamelCase	).standard_normal((1, 4, 32, 32)	)
				__lowercase			  =							torch.from_numpy(_lowerCamelCase	).to(device=_lowerCamelCase       ,dtype=_lowerCamelCase	)
				__lowercase			  =							{
				    '''prompt''': '''A painting of a squirrel eating a burger''',
				    '''latents''': latents,
				    '''generator''': generator,
				    '''num_inference_steps''': 3,
				    '''guidance_scale''': 6.0,
				    '''output_type''': '''numpy''',
				}
				return inputs


	def   _UpperCAmelCase       (self	)							->							Any:







				'''simple docstring'''





				__lowercase			  =							LDMTextToImagePipeline.from_pretrained('''CompVis/ldm-text2im-large-256'''	).to(_lowerCamelCase	)
				pipe.set_progress_bar_config(disable=_lowerCamelCase	)

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

				assert image.shape == (1, 256, 256, 3)
				__lowercase			  =							np.array([0.5_1_8_2_5, 0.5_2_8_5_0, 0.5_2_5_4_3, 0.5_4_2_5_8, 0.5_2_3_0_4, 0.5_2_5_6_9, 0.5_4_3_6_3, 0.5_5_2_7_6, 0.5_6_8_7_8]	)
				__lowercase			  =							np.abs(expected_slice - image_slice	).max()
				assert max_diff < 1E-3






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







	'''simple docstring'''

	def   _UpperCAmelCase       (self	)							->							Optional[Any]:







				'''simple docstring'''





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


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase=torch.floataa       ,_lowerCamelCase=0	)							->							Any:







				'''simple docstring'''





				__lowercase			  =							torch.manual_seed(_lowerCamelCase	)
				__lowercase			  =							np.random.RandomState(_lowerCamelCase	).standard_normal((1, 4, 32, 32)	)
				__lowercase			  =							torch.from_numpy(_lowerCamelCase	).to(device=_lowerCamelCase       ,dtype=_lowerCamelCase	)
				__lowercase			  =							{
				    '''prompt''': '''A painting of a squirrel eating a burger''',
				    '''latents''': latents,
				    '''generator''': generator,
				    '''num_inference_steps''': 50,
				    '''guidance_scale''': 6.0,
				    '''output_type''': '''numpy''',
				}
				return inputs


	def   _UpperCAmelCase       (self	)							->							Optional[Any]:







				'''simple docstring'''





				__lowercase			  =							LDMTextToImagePipeline.from_pretrained('''CompVis/ldm-text2im-large-256'''	).to(_lowerCamelCase	)
				pipe.set_progress_bar_config(disable=_lowerCamelCase	)

				__lowercase			  =							self.get_inputs(_lowerCamelCase	)
				__lowercase			  =							pipe(**_lowerCamelCase	).images[0]

				__lowercase			  =							load_numpy(
				    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy'''	)
				__lowercase			  =							np.abs(expected_image - image	).max()
				assert max_diff < 1E-3












'''simple docstring'''



import os
import random
import sys

from . import cryptomath_module as cryptoMath  # noqa: N812
from . import rabin_miller as rabinMiller  # noqa: N812




def 				_lowerCAmelCase  (			):
			print('''Making key files...'''			)
			make_key_files('''rsa'''						,    1_0_2_4			)
			print('''Key files generation successful.'''			)




def 				_lowerCAmelCase  (			lowerCamelCase_     :					int			):
			print('''Generating prime p...'''			)
			__lowercase			  =							rabinMiller.generate_large_prime(lowerCamelCase_			)
			print('''Generating prime q...'''			)
			__lowercase			  =							rabinMiller.generate_large_prime(lowerCamelCase_			)
			__lowercase			  =							p * q

			print('''Generating e that is relatively prime to (p - 1) * (q - 1)...'''			)
			while True:
						__lowercase			  =							random.randrange(2 ** (key_size - 1)						,    2 ** (key_size)			)
						if cryptoMath.gcd(lowerCamelCase_						,    (p - 1) * (q - 1)			) == 1:
									break

			print('''Calculating d that is mod inverse of e...'''			)
			__lowercase			  =							cryptoMath.find_mod_inverse(lowerCamelCase_						,    (p - 1) * (q - 1)			)

			__lowercase			  =							(n, e)
			__lowercase			  =							(n, d)
			return (public_key, private_key)




def 				_lowerCAmelCase  (			lowerCamelCase_     :					str						,    lowerCamelCase_     :					int			):
			if os.path.exists(f"{name}_pubkey.txt"			) or os.path.exists(f"{name}_privkey.txt"			):
						print('''\nWARNING:'''			)
						print(
						    f"\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n"
						    '''Use a different name or delete these files and re-run this program.'''			)
						sys.exit()

			__lowercase  ,						__lowercase			  =							generate_key(lowerCamelCase_			)
			print(f"\nWriting public key to file {name}_pubkey.txt..."			)
			with open(f"{name}_pubkey.txt"						,    '''w'''			) as out_file:
						out_file.write(f"{key_size},{public_key[0]},{public_key[1]}"			)

			print(f"Writing private key to file {name}_privkey.txt..."			)
			with open(f"{name}_privkey.txt"						,    '''w'''			) as out_file:
						out_file.write(f"{key_size},{private_key[0]},{private_key[1]}"			)


if __name__ == "__main__":
	main()





