






# This model implementation is heavily based on:

import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()




class 			UpperCamelCase_				(      snake_case_	, snake_case_	, snake_case_	, unittest.TestCase    ):



	'''simple docstring'''




	lowerCAmelCase													=			StableDiffusionControlNetInpaintPipeline
	lowerCAmelCase													=			TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	lowerCAmelCase													=			TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	lowerCAmelCase													=			frozenset({'''control_image'''}    )  # skip `image` and `mask` for now, only test for control_image
	lowerCAmelCase													=			TEXT_TO_IMAGE_IMAGE_PARAMS




	def 							_UpperCamelCase      (	self )	->   Any:
								torch.manual_seed(0 )
								snake_case_           =							UNetaDConditionModel(
								    block_out_channels=(32, 64)	,      layers_per_block=2	,      sample_size=32	,      in_channels=9	,      out_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')	,      cross_attention_dim=32	,      )
								torch.manual_seed(0 )
								snake_case_           =							ControlNetModel(
								    block_out_channels=(32, 64)	,      layers_per_block=2	,      in_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      cross_attention_dim=32	,      conditioning_embedding_out_channels=(16, 32)	,      )
								torch.manual_seed(0 )
								snake_case_           =							DDIMScheduler(
								    beta_start=0.00_085	,      beta_end=0.012	,      beta_schedule='scaled_linear'	,      clip_sample=a	,      set_alpha_to_one=a	,      )
								torch.manual_seed(0 )
								snake_case_           =							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 )
								snake_case_           =							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=10_00	,      )
								snake_case_           =							CLIPTextModel(a )
								snake_case_           =							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

								snake_case_           =							{
								    'unet': unet,
								    'controlnet': controlnet,
								    'scheduler': scheduler,
								    'vae': vae,
								    'text_encoder': text_encoder,
								    'tokenizer': tokenizer,
								    'safety_checker': None,
								    'feature_extractor': None,
								}
								return components




	def 							_UpperCamelCase      (	self	,      a	,      a=0 )	->   List[Any]:
								if str(a ).startswith('mps' ):
															snake_case_           =							torch.manual_seed(a )
								else:
															snake_case_           =							torch.Generator(device=a ).manual_seed(a )

								snake_case_           =							2
								snake_case_           =							randn_tensor(
								    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,      generator=a	,      device=torch.device(a )	,      )
								snake_case_           =							floats_tensor((1, 3, 32, 32)	,      rng=random.Random(a ) ).to(a )
								snake_case_           =							init_image.cpu().permute(0	,      2	,      3	,      1 )[0]

								snake_case_           =							Image.fromarray(np.uinta(a ) ).convert('RGB' ).resize((64, 64) )
								snake_case_           =							Image.fromarray(np.uinta(init_image + 4 ) ).convert('RGB' ).resize((64, 64) )

								snake_case_           =							{
								    'prompt': 'A painting of a squirrel eating a burger',
								    'generator': generator,
								    'num_inference_steps': 2,
								    'guidance_scale': 6.0,
								    'output_type': 'numpy',
								    'image': image,
								    'mask_image': mask_image,
								    'control_image': control_image,
								}

								return inputs




	def 							_UpperCamelCase      (	self )	->   Tuple:
								return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 )




	@unittest.skipIf(
	    torch_device != 'cuda' or not is_xformers_available()	,      reason='XFormers attention is only available with CUDA and `xformers` installed'	,      )
	def 							_UpperCamelCase      (	self )	->   List[str]:
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 )






	def 							_UpperCamelCase      (	self )	->   Dict:
								self._test_inference_batch_single_identical(expected_max_diff=2E-3 )






class 			UpperCamelCase_				(      snake_case_    ):



	'''simple docstring'''




	lowerCAmelCase													=			StableDiffusionControlNetInpaintPipeline
	lowerCAmelCase													=			TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	lowerCAmelCase													=			TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	lowerCAmelCase													=			frozenset([]    )




	def 							_UpperCamelCase      (	self )	->   List[Any]:
								torch.manual_seed(0 )
								snake_case_           =							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	,      )
								torch.manual_seed(0 )
								snake_case_           =							ControlNetModel(
								    block_out_channels=(32, 64)	,      layers_per_block=2	,      in_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      cross_attention_dim=32	,      conditioning_embedding_out_channels=(16, 32)	,      )
								torch.manual_seed(0 )
								snake_case_           =							DDIMScheduler(
								    beta_start=0.00_085	,      beta_end=0.012	,      beta_schedule='scaled_linear'	,      clip_sample=a	,      set_alpha_to_one=a	,      )
								torch.manual_seed(0 )
								snake_case_           =							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 )
								snake_case_           =							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=10_00	,      )
								snake_case_           =							CLIPTextModel(a )
								snake_case_           =							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

								snake_case_           =							{
								    'unet': unet,
								    'controlnet': controlnet,
								    'scheduler': scheduler,
								    'vae': vae,
								    'text_encoder': text_encoder,
								    'tokenizer': tokenizer,
								    'safety_checker': None,
								    'feature_extractor': None,
								}
								return components






class 			UpperCamelCase_				(      snake_case_	, snake_case_	, unittest.TestCase    ):



	'''simple docstring'''




	lowerCAmelCase													=			StableDiffusionControlNetInpaintPipeline
	lowerCAmelCase													=			TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	lowerCAmelCase													=			TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS




	def 							_UpperCamelCase      (	self )	->   int:
								torch.manual_seed(0 )
								snake_case_           =							UNetaDConditionModel(
								    block_out_channels=(32, 64)	,      layers_per_block=2	,      sample_size=32	,      in_channels=9	,      out_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')	,      cross_attention_dim=32	,      )
								torch.manual_seed(0 )

								def init_weights(a ):
															if isinstance(a	,      torch.nn.Convad ):
																						torch.nn.init.normal(m.weight )
																						m.bias.data.fill_(1.0 )

								snake_case_           =							ControlNetModel(
								    block_out_channels=(32, 64)	,      layers_per_block=2	,      in_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      cross_attention_dim=32	,      conditioning_embedding_out_channels=(16, 32)	,      )
								controlneta.controlnet_down_blocks.apply(a )

								torch.manual_seed(0 )
								snake_case_           =							ControlNetModel(
								    block_out_channels=(32, 64)	,      layers_per_block=2	,      in_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      cross_attention_dim=32	,      conditioning_embedding_out_channels=(16, 32)	,      )
								controlneta.controlnet_down_blocks.apply(a )

								torch.manual_seed(0 )
								snake_case_           =							DDIMScheduler(
								    beta_start=0.00_085	,      beta_end=0.012	,      beta_schedule='scaled_linear'	,      clip_sample=a	,      set_alpha_to_one=a	,      )
								torch.manual_seed(0 )
								snake_case_           =							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 )
								snake_case_           =							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=10_00	,      )
								snake_case_           =							CLIPTextModel(a )
								snake_case_           =							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

								snake_case_           =							MultiControlNetModel([controlneta, controlneta] )

								snake_case_           =							{
								    'unet': unet,
								    'controlnet': controlnet,
								    'scheduler': scheduler,
								    'vae': vae,
								    'text_encoder': text_encoder,
								    'tokenizer': tokenizer,
								    'safety_checker': None,
								    'feature_extractor': None,
								}
								return components




	def 							_UpperCamelCase      (	self	,      a	,      a=0 )	->   int:
								if str(a ).startswith('mps' ):
															snake_case_           =							torch.manual_seed(a )
								else:
															snake_case_           =							torch.Generator(device=a ).manual_seed(a )

								snake_case_           =							2

								snake_case_           =							[
								    randn_tensor(
								        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,      generator=a	,      device=torch.device(a )	,      ),
								    randn_tensor(
								        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)	,      generator=a	,      device=torch.device(a )	,      ),
								]
								snake_case_           =							floats_tensor((1, 3, 32, 32)	,      rng=random.Random(a ) ).to(a )
								snake_case_           =							init_image.cpu().permute(0	,      2	,      3	,      1 )[0]

								snake_case_           =							Image.fromarray(np.uinta(a ) ).convert('RGB' ).resize((64, 64) )
								snake_case_           =							Image.fromarray(np.uinta(init_image + 4 ) ).convert('RGB' ).resize((64, 64) )

								snake_case_           =							{
								    'prompt': 'A painting of a squirrel eating a burger',
								    'generator': generator,
								    'num_inference_steps': 2,
								    'guidance_scale': 6.0,
								    'output_type': 'numpy',
								    'image': image,
								    'mask_image': mask_image,
								    'control_image': control_image,
								}

								return inputs




	def 							_UpperCamelCase      (	self )	->   int:
								snake_case_           =							self.get_dummy_components()
								snake_case_           =							self.pipeline_class(**a )
								pipe.to(a )

								snake_case_           =							10.0
								snake_case_           =							4

								snake_case_           =							self.get_dummy_inputs(a )
								snake_case_           =							steps
								snake_case_           =							scale
								snake_case_           =							pipe(**a )[0]

								snake_case_           =							self.get_dummy_inputs(a )
								snake_case_           =							steps
								snake_case_           =							scale
								snake_case_           =							pipe(**a	,      control_guidance_start=0.1	,      control_guidance_end=0.2 )[0]

								snake_case_           =							self.get_dummy_inputs(a )
								snake_case_           =							steps
								snake_case_           =							scale
								snake_case_           =							pipe(**a	,      control_guidance_start=[0.1, 0.3]	,      control_guidance_end=[0.2, 0.7] )[0]

								snake_case_           =							self.get_dummy_inputs(a )
								snake_case_           =							steps
								snake_case_           =							scale
								snake_case_           =							pipe(**a	,      control_guidance_start=0.4	,      control_guidance_end=[0.5, 0.8] )[0]

								# make sure that all outputs are different
								assert np.sum(np.abs(output_a - output_a ) ) > 1E-3
								assert np.sum(np.abs(output_a - output_a ) ) > 1E-3
								assert np.sum(np.abs(output_a - output_a ) ) > 1E-3




	def 							_UpperCamelCase      (	self )	->   int:
								return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 )




	@unittest.skipIf(
	    torch_device != 'cuda' or not is_xformers_available()	,      reason='XFormers attention is only available with CUDA and `xformers` installed'	,      )
	def 							_UpperCamelCase      (	self )	->   str:
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 )




	def 							_UpperCamelCase      (	self )	->   int:
								self._test_inference_batch_single_identical(expected_max_diff=2E-3 )






	def 							_UpperCamelCase      (	self )	->   Any:
								snake_case_           =							self.get_dummy_components()
								snake_case_           =							self.pipeline_class(**a )
								pipe.to(a )
								pipe.set_progress_bar_config(disable=a )
								with tempfile.TemporaryDirectory() as tmpdir:
															try:
																						# save_pretrained is not implemented for Multi-ControlNet
																						pipe.save_pretrained(a )
															except NotImplementedError:
																						pass






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



	'''simple docstring'''




	def 							_UpperCamelCase      (	self )	->   List[str]:
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()




	def 							_UpperCamelCase      (	self )	->   Union[str, Any]:
								snake_case_           =							ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny' )

								snake_case_           =							StableDiffusionControlNetInpaintPipeline.from_pretrained(
								    'runwayml/stable-diffusion-inpainting'	,      safety_checker=a	,      controlnet=a )
								pipe.enable_model_cpu_offload()
								pipe.set_progress_bar_config(disable=a )

								snake_case_           =							torch.Generator(device='cpu' ).manual_seed(0 )
								snake_case_           =							load_image(
								    'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png' ).resize((5_12, 5_12) )

								snake_case_           =							load_image(
								    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
								    '/stable_diffusion_inpaint/input_bench_mask.png' ).resize((5_12, 5_12) )

								snake_case_           =							'pitch black hole'

								snake_case_           =							load_image(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png' ).resize((5_12, 5_12) )

								snake_case_           =							pipe(
								    a	,      image=a	,      mask_image=a	,      control_image=a	,      generator=a	,      output_type='np'	,      num_inference_steps=3	,      )

								snake_case_           =							output.images[0]

								assert image.shape == (5_12, 5_12, 3)

								snake_case_           =							load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy' )

								assert np.abs(expected_image - image ).max() < 9E-2






	def 							_UpperCamelCase      (	self )	->   Tuple:
								snake_case_           =							ControlNetModel.from_pretrained('lllyasviel/control_v11p_sd15_inpaint' )

								snake_case_           =							StableDiffusionControlNetInpaintPipeline.from_pretrained(
								    'runwayml/stable-diffusion-v1-5'	,      safety_checker=a	,      controlnet=a )
								snake_case_           =							DDIMScheduler.from_config(pipe.scheduler.config )
								pipe.enable_model_cpu_offload()
								pipe.set_progress_bar_config(disable=a )

								snake_case_           =							torch.Generator(device='cpu' ).manual_seed(33 )

								snake_case_           =							load_image(
								    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png' )
								snake_case_           =							init_image.resize((5_12, 5_12) )

								snake_case_           =							load_image(
								    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png' )
								snake_case_           =							mask_image.resize((5_12, 5_12) )

								snake_case_           =							'a handsome man with ray-ban sunglasses'

								def make_inpaint_condition(a	,      a ):
															snake_case_           =							np.array(image.convert('RGB' ) ).astype(np.floataa ) / 255.0
															snake_case_           =							np.array(image_mask.convert('L' ) ).astype(np.floataa ) / 255.0

															assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
															snake_case_           =							-1.0  # set as masked pixel
															snake_case_           =							np.expand_dims(a	,      0 ).transpose(0	,      3	,      1	,      2 )
															snake_case_           =							torch.from_numpy(a )
															return image

								snake_case_           =							make_inpaint_condition(a	,      a )

								snake_case_           =							pipe(
								    a	,      image=a	,      mask_image=a	,      control_image=a	,      guidance_scale=9.0	,      eta=1.0	,      generator=a	,      num_inference_steps=20	,      output_type='np'	,      )
								snake_case_           =							output.images[0]

								assert image.shape == (5_12, 5_12, 3)

								snake_case_           =							load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy' )

								assert np.abs(expected_image - image ).max() < 9E-2













from __future__ import annotations





def 						__UpperCAmelCase      (					a_):
							for r in range(1							,					a_):
														snake_case_           =							[]
														for x in range(n - 1):
																					snake_case_           =							pow(a_							,					a_							,					a_)
																					if val in li:
																												break
																					li.append(a_)
														else:
																					return r
							return None


if __name__ == "__main__":
	lowercase  							= int(input("Enter a prime number q: "))
	lowercase  							= find_primitive(q)
	if a is None:
		print(f'Cannot find the primitive for the value: {a!r}')
	else:
		lowercase  							= int(input("Enter private key of A: "))
		lowercase  							= pow(a, a_private, q)
		lowercase  							= int(input("Enter private key of B: "))
		lowercase  							= pow(a, b_private, q)

		lowercase  							= pow(b_public, a_private, q)
		lowercase  							= pow(a_public, b_private, q)

		print("The key value generated by A is: ", a_secret)
		print("The key value generated by B is: ", b_secret)





