


"""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  lowercase(					__a	,      __a	,      __a	,      unittest.TestCase			):







 '''simple docstring'''





 lowercase__			 = StableDiffusionControlNetImgaImgPipeline
 lowercase__			 = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
 lowercase__			 = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 lowercase__			 = IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"control_image"}			)
 lowercase__			 = IMAGE_TO_IMAGE_IMAGE_PARAMS


 def 			UpperCamelCase_       (    self:		Optional[Any]		):




   '''simple docstring'''



   torch.manual_seed(0		)
   _snake_case							:		str								=  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							:		Union[str, Any]								=  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							:		Dict								=  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							:		Optional[int]								=  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							:		Union[str, Any]								=  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,				)
   _snake_case							:		Tuple								=  CLIPTextModel(a_		)
   _snake_case							:		Any								=  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""		)

   _snake_case							:		Any								=  {
       """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:		str,				a_:		Any,				a_:		Union[str, Any]=0		):




   '''simple docstring'''



   if str(a_		).startswith("""mps"""		):
     _snake_case							:		Union[str, Any]								=  torch.manual_seed(a_		)
   else:
     _snake_case							:		Any								=  torch.Generator(device=a_		).manual_seed(a_		)

   _snake_case							:		Union[str, Any]								=  2
   _snake_case							:		Any								=  randn_tensor(
       (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor),				generator=a_,				device=torch.device(a_		),				)
   _snake_case							:		str								=  floats_tensor(control_image.shape,				rng=random.Random(a_		)		).to(a_		)
   _snake_case							:		List[str]								=  image.cpu().permute(0,				2,				3,				1		)[0]
   _snake_case							:		int								=  Image.fromarray(np.uinta(a_		)		).convert("""RGB"""		).resize((64, 64)		)
   _snake_case							:		str								=  {
       """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 			UpperCamelCase_       (    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 			UpperCamelCase_       (    self:		List[str]		):




   '''simple docstring'''



   self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3		)


 def 			UpperCamelCase_       (    self:		Any		):




   '''simple docstring'''



   self._test_inference_batch_single_identical(expected_max_diff=2E-3		)







class  lowercase(					__a	,      __a	,      unittest.TestCase			):







 '''simple docstring'''





 lowercase__			 = StableDiffusionControlNetImgaImgPipeline
 lowercase__			 = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
 lowercase__			 = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 lowercase__			 = frozenset([]			)  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess


 def 			UpperCamelCase_       (    self:		List[Any]		):




   '''simple docstring'''



   torch.manual_seed(0		)
   _snake_case							:		str								=  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(a_:		Optional[Any]		):
     if isinstance(a_,				torch.nn.Convad		):
       torch.nn.init.normal(m.weight		)
       m.bias.data.fill_(1.0		)

   _snake_case							:		Optional[Any]								=  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							:		Tuple								=  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							:		Dict								=  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							:		Optional[Any]								=  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							:		Optional[Any]								=  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,				)
   _snake_case							:		Union[str, Any]								=  CLIPTextModel(a_		)
   _snake_case							:		int								=  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""		)

   _snake_case							:		Dict								=  MultiControlNetModel([controlneta, controlneta]		)

   _snake_case							:		str								=  {
       """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:		Union[str, Any],				a_:		Union[str, Any],				a_:		Tuple=0		):




   '''simple docstring'''



   if str(a_		).startswith("""mps"""		):
     _snake_case							:		Any								=  torch.manual_seed(a_		)
   else:
     _snake_case							:		List[Any]								=  torch.Generator(device=a_		).manual_seed(a_		)

   _snake_case							:		Union[str, Any]								=  2

   _snake_case							:		List[str]								=  [
       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							:		List[str]								=  floats_tensor(control_image[0].shape,				rng=random.Random(a_		)		).to(a_		)
   _snake_case							:		int								=  image.cpu().permute(0,				2,				3,				1		)[0]
   _snake_case							:		int								=  Image.fromarray(np.uinta(a_		)		).convert("""RGB"""		).resize((64, 64)		)
   _snake_case							:		Tuple								=  {
       """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 			UpperCamelCase_       (    self:		Optional[Any]		):




   '''simple docstring'''



   _snake_case							:		Any								=  self.get_dummy_components()
   _snake_case							:		Union[str, Any]								=  self.pipeline_class(**a_		)
   pipe.to(a_		)

   _snake_case							:		int								=  10.0
   _snake_case							:		List[str]								=  4

   _snake_case							:		Optional[Any]								=  self.get_dummy_inputs(a_		)
   _snake_case							:		str								=  steps
   _snake_case							:		Union[str, Any]								=  scale
   _snake_case							:		List[Any]								=  pipe(**a_		)[0]

   _snake_case							:		Tuple								=  self.get_dummy_inputs(a_		)
   _snake_case							:		Tuple								=  steps
   _snake_case							:		Tuple								=  scale
   _snake_case							:		str								=  pipe(**a_,				control_guidance_start=0.1,				control_guidance_end=0.2		)[0]

   _snake_case							:		int								=  self.get_dummy_inputs(a_		)
   _snake_case							:		Any								=  steps
   _snake_case							:		Tuple								=  scale
   _snake_case							:		str								=  pipe(**a_,				control_guidance_start=[0.1, 0.3],				control_guidance_end=[0.2, 0.7]		)[0]

   _snake_case							:		Any								=  self.get_dummy_inputs(a_		)
   _snake_case							:		Union[str, Any]								=  steps
   _snake_case							:		Dict								=  scale
   _snake_case							:		Tuple								=  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:		Tuple		):




   '''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 			UpperCamelCase_       (    self:		Tuple		):




   '''simple docstring'''



   self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3		)


 def 			UpperCamelCase_       (    self:		Optional[int]		):




   '''simple docstring'''



   self._test_inference_batch_single_identical(expected_max_diff=2E-3		)


 def 			UpperCamelCase_       (    self:		List[Any]		):




   '''simple docstring'''



   _snake_case							:		Optional[Any]								=  self.get_dummy_components()
   _snake_case							:		List[Any]								=  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  lowercase(					unittest.TestCase			):







 '''simple docstring'''





 def 			UpperCamelCase_       (    self:		Union[str, Any]		):




   '''simple docstring'''



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


 def 			UpperCamelCase_       (    self:		Optional[Any]		):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""		)

   _snake_case							:		List[str]								=  StableDiffusionControlNetImgaImgPipeline.from_pretrained(
       """runwayml/stable-diffusion-v1-5""",				safety_checker=a_,				controlnet=a_		)
   pipe.enable_model_cpu_offload()
   pipe.set_progress_bar_config(disable=a_		)

   _snake_case							:		List[str]								=  torch.Generator(device="""cpu"""		).manual_seed(0		)
   _snake_case							:		Dict								=  """evil space-punk bird"""
   _snake_case							:		Any								=  load_image(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"""		).resize((512, 512)		)
   _snake_case							:		Optional[int]								=  load_image(
       """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"""		).resize((512, 512)		)

   _snake_case							:		List[str]								=  pipe(
       a_,				a_,				control_image=a_,				generator=a_,				output_type="""np""",				num_inference_steps=50,				strength=0.6,				)

   _snake_case							:		Dict								=  output.images[0]

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

   _snake_case							:		Optional[int]								=  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  lowercase:







 '''simple docstring'''





 def __init__(    self:		Dict,				a_:		Any		):




   '''simple docstring'''



   _snake_case							:		Dict								=  data
   _snake_case							:		Optional[Any]								=  None







class  lowercase:







 '''simple docstring'''





 def __init__(    self:		str		):




   '''simple docstring'''



   _snake_case							:		Any								=  None


 def 			UpperCamelCase_       (    self:		Any		):




   '''simple docstring'''



   _snake_case							:		List[Any]								=  self.head
   while temp is not None:
     print(temp.data,				end=""" """		)
     _snake_case							:		int								=  temp.next
   print()


 def 			UpperCamelCase_       (    self:		Union[str, Any],				a_:		Any		):




   '''simple docstring'''



   _snake_case							:		Optional[Any]								=  Node(a_		)
   _snake_case							:		Union[str, Any]								=  self.head
   _snake_case							:		List[Any]								=  new_node


 def 			UpperCamelCase_       (    self:		Tuple,				a_:		List[str],				a_:		Union[str, Any]		):




   '''simple docstring'''



   if node_data_a == node_data_a:
     return
   else:
     _snake_case							:		int								=  self.head
     while node_a is not None and node_a.data != node_data_a:
       _snake_case							:		List[Any]								=  node_a.next

     _snake_case							:		List[Any]								=  self.head
     while node_a is not None and node_a.data != node_data_a:
       _snake_case							:		List[Any]								=  node_a.next

     if node_a is None or node_a is None:
       return

     _snake_case		, _snake_case							:		int								=  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()


