





import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionInstructPixaPixPipeline,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.utils import floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class        __SCREAMING_SNAKE_CASE      (			lowerCAmelCase_					,lowerCAmelCase_					,lowerCAmelCase_					,unittest.TestCase ):
       _UpperCAmelCase				:  List[Any]			   =   StableDiffusionInstructPixaPixPipeline
       _UpperCAmelCase				:  Any			   =   TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width", "cross_attention_kwargs"}
       _UpperCAmelCase				:  Optional[int]			   =   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
       _UpperCAmelCase				:  Tuple			   =   IMAGE_TO_IMAGE_IMAGE_PARAMS
       _UpperCAmelCase				:  Any			   =   IMAGE_TO_IMAGE_IMAGE_PARAMS







       def 						__lowerCamelCase   (				self					:     str      )       ->Union[str, Any]:
          torch.manual_seed(0      )
          lowerCamelCase__       :						List[Any]        =							UNetaDConditionModel(
              block_out_channels=(3_2, 6_4)		, layers_per_block=2		, sample_size=3_2		, in_channels=8		, out_channels=4		, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')		, up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')		, cross_attention_dim=3_2		, )
          lowerCamelCase__       :						int        =							PNDMScheduler(skip_prk_steps=A      )
          torch.manual_seed(0      )
          lowerCamelCase__       :						str        =							AutoencoderKL(
              block_out_channels=[3_2, 6_4]		, in_channels=3		, out_channels=3		, down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']		, up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']		, latent_channels=4		, )
          torch.manual_seed(0      )
          lowerCamelCase__       :						str        =							CLIPTextConfig(
              bos_token_id=0		, eos_token_id=2		, hidden_size=3_2		, intermediate_size=3_7		, layer_norm_eps=1e-05		, num_attention_heads=4		, num_hidden_layers=5		, pad_token_id=1		, vocab_size=1_0_0_0		, )
          lowerCamelCase__       :						List[Any]        =							CLIPTextModel(A      )
          lowerCamelCase__       :						str        =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

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







       def 						__lowerCamelCase   (				self					:     Dict		, A					:     Any		, A					:     Tuple=0      )       ->List[Any]:
          lowerCamelCase__       :						Dict        =							floats_tensor((1, 3, 3_2, 3_2)		, rng=random.Random(A      )      ).to(A      )
          lowerCamelCase__       :						Union[str, Any]        =							image.cpu().permute(0		, 2		, 3		, 1      )[0]
          lowerCamelCase__       :						List[str]        =							Image.fromarray(np.uinta(A      )      ).convert('''RGB'''      )
          if str(A      ).startswith('''mps'''      ):
             lowerCamelCase__       :						Any        =							torch.manual_seed(A      )
          else:
             lowerCamelCase__       :						int        =							torch.Generator(device=A      ).manual_seed(A      )
          lowerCamelCase__       :						Dict        =							{
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''image''': image,
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''guidance_scale''': 6.0,
              '''image_guidance_scale''': 1,
              '''output_type''': '''numpy''',
          }
          return inputs







       def 						__lowerCamelCase   (				self					:     List[Any]      )       ->Dict:
          lowerCamelCase__       :						List[Any]        =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       :						Any        =							self.get_dummy_components()
          lowerCamelCase__       :						List[str]        =							StableDiffusionInstructPixaPixPipeline(**A      )
          lowerCamelCase__       :						List[Any]        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Optional[int]        =							self.get_dummy_inputs(A      )
          lowerCamelCase__       :						Any        =							sd_pipe(**A      ).images
          lowerCamelCase__       :						Optional[int]        =							image[0, -3:, -3:, -1]
          assert image.shape == (1, 3_2, 3_2, 3)
          lowerCamelCase__       :						List[str]        =							np.array([0.75_26, 0.37_50, 0.45_47, 0.61_17, 0.58_66, 0.50_16, 0.43_27, 0.56_42, 0.48_15]      )

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







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->List[str]:
          lowerCamelCase__       :						int        =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       :						Any        =							self.get_dummy_components()
          lowerCamelCase__       :						Optional[int]        =							StableDiffusionInstructPixaPixPipeline(**A      )
          lowerCamelCase__       :						str        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Tuple        =							self.get_dummy_inputs(A      )
          lowerCamelCase__       :						Dict        =							'''french fries'''
          lowerCamelCase__       :						Dict        =							sd_pipe(**A		, negative_prompt=A      )
          lowerCamelCase__       :						Dict        =							output.images
          lowerCamelCase__       :						Optional[int]        =							image[0, -3:, -3:, -1]

          assert image.shape == (1, 3_2, 3_2, 3)
          lowerCamelCase__       :						Dict        =							np.array([0.75_11, 0.36_42, 0.45_53, 0.62_36, 0.57_97, 0.50_13, 0.43_43, 0.56_11, 0.48_31]      )

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







       def 						__lowerCamelCase   (				self					:     Any      )       ->int:
          lowerCamelCase__       :						Union[str, Any]        =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       :						Optional[Any]        =							self.get_dummy_components()
          lowerCamelCase__       :						Any        =							StableDiffusionInstructPixaPixPipeline(**A      )
          lowerCamelCase__       :						List[Any]        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						Optional[int]        =							self.get_dummy_inputs(A      )
          lowerCamelCase__       :						Dict        =							[inputs['''prompt''']] * 2

          lowerCamelCase__       :						int        =							np.array(inputs['''image''']      ).astype(np.floataa      ) / 2_55.0
          lowerCamelCase__       :						str        =							torch.from_numpy(A      ).unsqueeze(0      ).to(A      )
          lowerCamelCase__       :						List[Any]        =							image / 2 + 0.5
          lowerCamelCase__       :						int        =							image.permute(0		, 3		, 1		, 2      )
          lowerCamelCase__       :						str        =							image.repeat(2		, 1		, 1		, 1      )

          lowerCamelCase__       :						Optional[Any]        =							sd_pipe(**A      ).images
          lowerCamelCase__       :						List[Any]        =							image[-1, -3:, -3:, -1]

          assert image.shape == (2, 3_2, 3_2, 3)
          lowerCamelCase__       :						List[str]        =							np.array([0.58_12, 0.57_48, 0.52_22, 0.59_08, 0.56_95, 0.71_74, 0.68_04, 0.55_23, 0.55_79]      )

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







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->List[str]:
          lowerCamelCase__       :						Dict        =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__       :						List[str]        =							self.get_dummy_components()
          lowerCamelCase__       :						Optional[Any]        =							EulerAncestralDiscreteScheduler(
              beta_start=0.0_00_85		, beta_end=0.0_12		, beta_schedule='''scaled_linear'''      )
          lowerCamelCase__       :						Union[str, Any]        =							StableDiffusionInstructPixaPixPipeline(**A      )
          lowerCamelCase__       :						Any        =							sd_pipe.to(A      )
          sd_pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						List[Any]        =							self.get_dummy_inputs(A      )
          lowerCamelCase__       :						int        =							sd_pipe(**A      ).images
          lowerCamelCase__       :						Optional[Any]        =							image[0, -3:, -3:, -1]

          lowerCamelCase__       :						List[str]        =							[round(A		, 4      ) for x in image_slice.flatten().tolist()]
          print(''','''.join([str(A      ) for x in slice]      )      )

          assert image.shape == (1, 3_2, 3_2, 3)
          lowerCamelCase__       :						List[Any]        =							np.array([0.74_17, 0.38_42, 0.47_32, 0.57_76, 0.58_91, 0.51_39, 0.40_52, 0.56_73, 0.49_86]      )

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







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->Dict:
          super().test_inference_batch_single_identical(expected_max_diff=3e-3      )







       def 						__lowerCamelCase   (				self					:     Dict      )       ->Optional[int]:
          lowerCamelCase__       :						Any        =							self.get_dummy_components()
          lowerCamelCase__       :						str        =							StableDiffusionInstructPixaPixPipeline(**A      )
          lowerCamelCase__       :						Dict        =							VaeImageProcessor(do_resize=A		, do_normalize=A      )
          lowerCamelCase__       :						Tuple        =							pipe.to(A      )
          pipe.set_progress_bar_config(disable=A      )

          lowerCamelCase__       :						int        =							pipe(**self.get_dummy_inputs_by_type(A		, input_image_type='''pt'''      )      )[0]

          lowerCamelCase__       :						int        =							components['''vae''']
          lowerCamelCase__       :						Any        =							self.get_dummy_inputs_by_type(A		, input_image_type='''pt'''      )

          for image_param in self.image_latents_params:
             if image_param in inputs.keys():
                lowerCamelCase__       :						List[Any]        =							vae.encode(inputs[image_param]      ).latent_dist.mode()

          lowerCamelCase__       :						Union[str, Any]        =							pipe(**A      )[0]

          lowerCamelCase__       :						Any        =							np.abs(out - out_latents_inputs      ).max()
          self.assertLess(A		, 1e-4		, '''passing latents as image input generate different result from passing image'''      )


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







       def 						__lowerCamelCase   (				self					:     List[Any]      )       ->Dict:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







       def 						__lowerCamelCase   (				self					:     str		, A					:     Optional[int]=0      )       ->Dict:
          lowerCamelCase__       :						Tuple        =							torch.manual_seed(A      )
          lowerCamelCase__       :						Tuple        =							load_image(
              '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_pix2pix/example.jpg'''      )
          lowerCamelCase__       :						int        =							{
              '''prompt''': '''turn him into a cyborg''',
              '''image''': image,
              '''generator''': generator,
              '''num_inference_steps''': 3,
              '''guidance_scale''': 7.5,
              '''image_guidance_scale''': 1.0,
              '''output_type''': '''numpy''',
          }
          return inputs







       def 						__lowerCamelCase   (				self					:     Dict      )       ->int:
          lowerCamelCase__       :						Union[str, Any]        =							StableDiffusionInstructPixaPixPipeline.from_pretrained(
              '''timbrooks/instruct-pix2pix'''		, safety_checker=A      )
          pipe.to(A      )
          pipe.set_progress_bar_config(disable=A      )
          pipe.enable_attention_slicing()

          lowerCamelCase__       :						Tuple        =							self.get_inputs()
          lowerCamelCase__       :						int        =							pipe(**A      ).images
          lowerCamelCase__       :						int        =							image[0, -3:, -3:, -1].flatten()

          assert image.shape == (1, 5_1_2, 5_1_2, 3)
          lowerCamelCase__       :						Tuple        =							np.array([0.59_02, 0.60_15, 0.60_27, 0.59_83, 0.60_92, 0.60_61, 0.57_65, 0.57_85, 0.55_55]      )

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







       def 						__lowerCamelCase   (				self					:     List[str]      )       ->List[Any]:
          lowerCamelCase__       :						List[str]        =							StableDiffusionInstructPixaPixPipeline.from_pretrained(
              '''timbrooks/instruct-pix2pix'''		, safety_checker=A      )
          lowerCamelCase__       :						Tuple        =							LMSDiscreteScheduler.from_config(pipe.scheduler.config      )
          pipe.to(A      )
          pipe.set_progress_bar_config(disable=A      )
          pipe.enable_attention_slicing()

          lowerCamelCase__       :						List[str]        =							self.get_inputs()
          lowerCamelCase__       :						int        =							pipe(**A      ).images
          lowerCamelCase__       :						Tuple        =							image[0, -3:, -3:, -1].flatten()

          assert image.shape == (1, 5_1_2, 5_1_2, 3)
          lowerCamelCase__       :						List[str]        =							np.array([0.65_78, 0.68_17, 0.69_72, 0.67_61, 0.68_56, 0.69_16, 0.64_28, 0.65_16, 0.63_01]      )

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







       def 						__lowerCamelCase   (				self					:     Optional[Any]      )       ->List[Any]:
          lowerCamelCase__       :						int        =							StableDiffusionInstructPixaPixPipeline.from_pretrained(
              '''timbrooks/instruct-pix2pix'''		, safety_checker=A      )
          lowerCamelCase__       :						Any        =							DDIMScheduler.from_config(pipe.scheduler.config      )
          pipe.to(A      )
          pipe.set_progress_bar_config(disable=A      )
          pipe.enable_attention_slicing()

          lowerCamelCase__       :						Tuple        =							self.get_inputs()
          lowerCamelCase__       :						Any        =							pipe(**A      ).images
          lowerCamelCase__       :						List[str]        =							image[0, -3:, -3:, -1].flatten()

          assert image.shape == (1, 5_1_2, 5_1_2, 3)
          lowerCamelCase__       :						Optional[Any]        =							np.array([0.38_28, 0.38_34, 0.38_18, 0.37_92, 0.38_65, 0.37_52, 0.37_92, 0.38_47, 0.37_53]      )

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







       def 						__lowerCamelCase   (				self					:     List[Any]      )       ->List[Any]:
          lowerCamelCase__       :						str        =							0

          def callback_fn(A					:     int		, A					:     int		, A					:     torch.FloatTensor      ) -> None:
             lowerCamelCase__       :						Optional[Any]        =							True
             nonlocal number_of_steps
             number_of_steps += 1
             if step == 1:
                lowerCamelCase__       :						int        =							latents.detach().cpu().numpy()
                assert latents.shape == (1, 4, 6_4, 6_4)
                lowerCamelCase__       :						Any        =							latents[0, -3:, -3:, -1]
                lowerCamelCase__       :						Tuple        =							np.array([-0.24_63, -0.46_44, -0.97_56, 1.51_76, 1.44_14, 0.78_66, 0.98_97, 0.85_21, 0.79_83]      )

                assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5e-2
             elif step == 2:
                lowerCamelCase__       :						Union[str, Any]        =							latents.detach().cpu().numpy()
                assert latents.shape == (1, 4, 6_4, 6_4)
                lowerCamelCase__       :						List[str]        =							latents[0, -3:, -3:, -1]
                lowerCamelCase__       :						int        =							np.array([-0.26_44, -0.46_26, -0.96_53, 1.51_76, 1.45_51, 0.76_86, 0.98_05, 0.84_52, 0.81_15]      )

                assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5e-2

          lowerCamelCase__       :						Union[str, Any]        =							False

          lowerCamelCase__       :						Tuple        =							StableDiffusionInstructPixaPixPipeline.from_pretrained(
              '''timbrooks/instruct-pix2pix'''		, safety_checker=A		, torch_dtype=torch.floataa      )
          lowerCamelCase__       :						int        =							pipe.to(A      )
          pipe.set_progress_bar_config(disable=A      )
          pipe.enable_attention_slicing()

          lowerCamelCase__       :						Optional[int]        =							self.get_inputs()
          pipe(**A		, callback=A		, callback_steps=1      )
          assert callback_fn.has_been_called
          assert number_of_steps == 3







       def 						__lowerCamelCase   (				self					:     Any      )       ->List[str]:
          torch.cuda.empty_cache()
          torch.cuda.reset_max_memory_allocated()
          torch.cuda.reset_peak_memory_stats()

          lowerCamelCase__       :						Any        =							StableDiffusionInstructPixaPixPipeline.from_pretrained(
              '''timbrooks/instruct-pix2pix'''		, safety_checker=A		, torch_dtype=torch.floataa      )
          lowerCamelCase__       :						List[str]        =							pipe.to(A      )
          pipe.set_progress_bar_config(disable=A      )
          pipe.enable_attention_slicing(1      )
          pipe.enable_sequential_cpu_offload()

          lowerCamelCase__       :						Tuple        =							self.get_inputs()
          lowerCamelCase__       :						List[Any]        =							pipe(**A      )

          lowerCamelCase__       :						Dict        =							torch.cuda.max_memory_allocated()
          # make sure that less than 2.2 GB is allocated
          assert mem_bytes < 2.2 * 1_0**9







       def 						__lowerCamelCase   (				self					:     str      )       ->Optional[int]:
          lowerCamelCase__       :						Union[str, Any]        =							self.get_inputs()
          # resize to resolution that is divisible by 8 but not 16 or 32
          lowerCamelCase__       :						Any        =							inputs['''image'''].resize((5_0_4, 5_0_4)      )

          lowerCamelCase__       :						Dict        =							'''timbrooks/instruct-pix2pix'''
          lowerCamelCase__       :						List[str]        =							StableDiffusionInstructPixaPixPipeline.from_pretrained(
              A		, safety_checker=A		, )
          pipe.to(A      )
          pipe.set_progress_bar_config(disable=A      )
          pipe.enable_attention_slicing()

          lowerCamelCase__       :						List[str]        =							pipe(**A      )
          lowerCamelCase__       :						List[str]        =							output.images[0]

          lowerCamelCase__       :						Tuple        =							image[2_5_5:2_5_8, 3_8_3:3_8_6, -1]

          assert image.shape == (5_0_4, 5_0_4, 3)
          lowerCamelCase__       :						str        =							np.array([0.27_26, 0.25_29, 0.26_64, 0.26_55, 0.26_41, 0.26_42, 0.25_91, 0.26_49, 0.25_90]      )

          assert np.abs(image_slice.flatten() - expected_slice      ).max() < 5e-3










def 	_a						(   UpperCAmelCase					)    ->    bool:







   """simple docstring"""
   return str(UpperCAmelCase					) == str(UpperCAmelCase					)[::-1]



def 	_a						(   UpperCAmelCase					)    ->    int:







   """simple docstring"""
   return int(UpperCAmelCase					) + int(str(UpperCAmelCase					)[::-1]					)



def 	_a						(   UpperCAmelCase = 10000					)    ->    int:







   """simple docstring"""
   lowerCamelCase__       :						Tuple        =							[]
   for num in range(1      ,  UpperCAmelCase					):
      lowerCamelCase__       :						List[str]        =							0
      lowerCamelCase__       :						Union[str, Any]        =							num
      while iterations < 50:
         lowerCamelCase__       :						Dict        =							sum_reverse(UpperCAmelCase					)
         iterations += 1
         if is_palindrome(UpperCAmelCase					):
            break
      else:
         lychrel_nums.append(UpperCAmelCase					)
   return len(UpperCAmelCase					)


if __name__ == "__main__":
       print(F'''{solution() = }''')



