




'''simple docstring'''







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,
    StableDiffusionControlNetImgaImgPipeline,
    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 (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()


class     _a						(			__a							,							__a							,							__a							,							unittest.TestCase				):
       __a       :  str            =      StableDiffusionControlNetImgaImgPipeline
       __a       :  Optional[int]            =      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
       __a       :  Tuple            =      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       __a       :  int            =      IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"""control_image"""}				)
       __a       :  List[Any]            =      IMAGE_TO_IMAGE_IMAGE_PARAMS
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           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     ,       )
           torch.manual_seed(0       )
           UpperCAmelCase     =	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       )
           UpperCAmelCase     =	DDIMScheduler(
               beta_start=0.0_0085     ,       beta_end=0.012     ,       beta_schedule='''scaled_linear'''     ,       clip_sample=UpperCamelCase_     ,       set_alpha_to_one=UpperCamelCase_     ,       )
           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     =	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=1_000     ,       )
           UpperCAmelCase     =	CLIPTextModel(UpperCamelCase_       )
           UpperCAmelCase     =	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

           UpperCAmelCase     =	{
               'unet': unet,
               'controlnet': controlnet,
               'scheduler': scheduler,
               'vae': vae,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'safety_checker': None,
               'feature_extractor': None,
           }
           return components
       def 					A   (			self		:			Union[str, Any]     ,       lowercase		:			Dict     ,       lowercase		:			List[Any]=0       ):



           '''simple docstring'''

           if str(UpperCamelCase_       ).startswith('''mps'''       ):
               UpperCAmelCase     =	torch.manual_seed(UpperCamelCase_       )
           else:
               UpperCAmelCase     =	torch.Generator(device=UpperCamelCase_       ).manual_seed(UpperCamelCase_       )

           UpperCAmelCase     =	2
           UpperCAmelCase     =	randn_tensor(
               (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     ,       generator=UpperCamelCase_     ,       device=torch.device(UpperCamelCase_       )     ,       )
           UpperCAmelCase     =	floats_tensor(control_image.shape     ,       rng=random.Random(UpperCamelCase_       )       ).to(UpperCamelCase_       )
           UpperCAmelCase     =	image.cpu().permute(0     ,       2     ,       3     ,       1       )[0]
           UpperCAmelCase     =	Image.fromarray(np.uinta(UpperCamelCase_       )       ).convert('''RGB'''       ).resize((64, 64)       )
           UpperCAmelCase     =	{
               'prompt': 'A painting of a squirrel eating a burger',
               'generator': generator,
               'num_inference_steps': 2,
               'guidance_scale': 6.0,
               'output_type': 'numpy',
               'image': image,
               'control_image': control_image,
           }

           return inputs
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           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 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3       )







       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           self._test_inference_batch_single_identical(expected_max_diff=2E-3       )






class     _a						(			__a							,							__a							,							unittest.TestCase				):
       __a       :  Dict            =      StableDiffusionControlNetImgaImgPipeline
       __a       :  List[Any]            =      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
       __a       :  Tuple            =      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       __a       :  Tuple            =      frozenset([]				)  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           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     ,       )
           torch.manual_seed(0       )

           def init_weights(lowercase		:			Optional[int]       ):
               if isinstance(UpperCamelCase_     ,       torch.nn.Convad       ):
                   torch.nn.init.normal(m.weight       )
                   m.bias.data.fill_(1.0       )

           UpperCAmelCase     =	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(UpperCamelCase_       )

           torch.manual_seed(0       )
           UpperCAmelCase     =	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(UpperCamelCase_       )

           torch.manual_seed(0       )
           UpperCAmelCase     =	DDIMScheduler(
               beta_start=0.0_0085     ,       beta_end=0.012     ,       beta_schedule='''scaled_linear'''     ,       clip_sample=UpperCamelCase_     ,       set_alpha_to_one=UpperCamelCase_     ,       )
           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     =	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=1_000     ,       )
           UpperCAmelCase     =	CLIPTextModel(UpperCamelCase_       )
           UpperCAmelCase     =	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

           UpperCAmelCase     =	MultiControlNetModel([controlneta, controlneta]       )

           UpperCAmelCase     =	{
               'unet': unet,
               'controlnet': controlnet,
               'scheduler': scheduler,
               'vae': vae,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'safety_checker': None,
               'feature_extractor': None,
           }
           return components
       def 					A   (			self		:			int     ,       lowercase		:			Optional[Any]     ,       lowercase		:			Tuple=0       ):



           '''simple docstring'''

           if str(UpperCamelCase_       ).startswith('''mps'''       ):
               UpperCAmelCase     =	torch.manual_seed(UpperCamelCase_       )
           else:
               UpperCAmelCase     =	torch.Generator(device=UpperCamelCase_       ).manual_seed(UpperCamelCase_       )

           UpperCAmelCase     =	2

           UpperCAmelCase     =	[
               randn_tensor(
                   (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     ,       generator=UpperCamelCase_     ,       device=torch.device(UpperCamelCase_       )     ,       ),
               randn_tensor(
                   (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     ,       generator=UpperCamelCase_     ,       device=torch.device(UpperCamelCase_       )     ,       ),
           ]

           UpperCAmelCase     =	floats_tensor(control_image[0].shape     ,       rng=random.Random(UpperCamelCase_       )       ).to(UpperCamelCase_       )
           UpperCAmelCase     =	image.cpu().permute(0     ,       2     ,       3     ,       1       )[0]
           UpperCAmelCase     =	Image.fromarray(np.uinta(UpperCamelCase_       )       ).convert('''RGB'''       ).resize((64, 64)       )
           UpperCAmelCase     =	{
               'prompt': 'A painting of a squirrel eating a burger',
               'generator': generator,
               'num_inference_steps': 2,
               'guidance_scale': 6.0,
               'output_type': 'numpy',
               'image': image,
               'control_image': control_image,
           }

           return inputs
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_dummy_components()
           UpperCAmelCase     =	self.pipeline_class(**UpperCamelCase_       )
           pipe.to(UpperCamelCase_       )

           UpperCAmelCase     =	10.0
           UpperCAmelCase     =	4

           UpperCAmelCase     =	self.get_dummy_inputs(UpperCamelCase_       )
           UpperCAmelCase     =	steps
           UpperCAmelCase     =	scale
           UpperCAmelCase     =	pipe(**UpperCamelCase_       )[0]

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

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

           UpperCAmelCase     =	self.get_dummy_inputs(UpperCamelCase_       )
           UpperCAmelCase     =	steps
           UpperCAmelCase     =	scale
           UpperCAmelCase     =	pipe(**UpperCamelCase_     ,       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 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           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 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3       )
       def 					A   (			self		:			List[str]       ):



           '''simple docstring'''

           self._test_inference_batch_single_identical(expected_max_diff=2E-3       )







       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_dummy_components()
           UpperCAmelCase     =	self.pipeline_class(**UpperCamelCase_       )
           pipe.to(UpperCamelCase_       )
           pipe.set_progress_bar_config(disable=UpperCamelCase_       )
           with tempfile.TemporaryDirectory() as tmpdir:
               try:
                   # save_pretrained is not implemented for Multi-ControlNet
                   pipe.save_pretrained(UpperCamelCase_       )
               except NotImplementedError:
                   pass






@slow
@require_torch_gpu
class     _a						(			unittest.TestCase				):
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

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







       def 					A   (			self		:			str       ):



           '''simple docstring'''

           UpperCAmelCase     =	ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny'''       )

           UpperCAmelCase     =	StableDiffusionControlNetImgaImgPipeline.from_pretrained(
               '''runwayml/stable-diffusion-v1-5'''     ,       safety_checker=UpperCamelCase_     ,       controlnet=UpperCamelCase_       )
           pipe.enable_model_cpu_offload()
           pipe.set_progress_bar_config(disable=UpperCamelCase_       )

           UpperCAmelCase     =	torch.Generator(device='''cpu'''       ).manual_seed(0       )
           UpperCAmelCase     =	'evil space-punk bird'
           UpperCAmelCase     =	load_image(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'''       ).resize((512, 512)       )
           UpperCAmelCase     =	load_image(
               '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'''       ).resize((512, 512)       )

           UpperCAmelCase     =	pipe(
               UpperCamelCase_     ,       UpperCamelCase_     ,       control_image=UpperCamelCase_     ,       generator=UpperCamelCase_     ,       output_type='''np'''     ,       num_inference_steps=50     ,       strength=0.6     ,       )

           UpperCAmelCase     =	output.images[0]

           assert image.shape == (512, 512, 3)

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

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










'''simple docstring'''







from typing import Any


class     _a						:
       def __init__(			self		:			int     ,       lowercase		:			Any       ):



           '''simple docstring'''

           UpperCAmelCase     =	data
           UpperCAmelCase     =	None






class     _a						:
       def __init__(			self		:			int       ):



           '''simple docstring'''

           UpperCAmelCase     =	None
       def 					A   (			self		:			int       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.head
           while temp is not None:
               print(temp.data     ,       end=''' '''       )
               UpperCAmelCase     =	temp.next
           print()
       def 					A   (			self		:			List[str]     ,       lowercase		:			Any       ):



           '''simple docstring'''

           UpperCAmelCase     =	Node(lowercase       )
           UpperCAmelCase     =	self.head
           UpperCAmelCase     =	new_node







       def 					A   (			self		:			List[Any]     ,       lowercase		:			List[Any]     ,       lowercase		:			str       ):



           '''simple docstring'''

           if node_data_a == node_data_a:
               return
           else:
               UpperCAmelCase     =	self.head
               while node_a is not None and node_a.data != node_data_a:
                   UpperCAmelCase     =	node_a.next

               UpperCAmelCase     =	self.head
               while node_a is not None and node_a.data != node_data_a:
                   UpperCAmelCase     =	node_a.next

               if node_a is None or node_a is None:
                   return

               UpperCAmelCase ,  UpperCAmelCase     =	node_a.data, node_a.data


if __name__ == "__main__":
   A									=LinkedList()
   for i in range(5, 0, -1):
      ll.push(i)

   ll.print_list()

   ll.swap_nodes(1, 4)
   print('After swapping')
   ll.print_list()




