





"""simple docstring"""
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







@skip_mps
class 			a       (      a__      ,   a__      ,   a__      ,   unittest.TestCase     ):
 snake_case__								=					StableDiffusionModelEditingPipeline
 snake_case__								=					TEXT_TO_IMAGE_PARAMS
 snake_case__								=					TEXT_TO_IMAGE_BATCH_PARAMS
 snake_case__								=					TEXT_TO_IMAGE_IMAGE_PARAMS
 snake_case__								=					TEXT_TO_IMAGE_IMAGE_PARAMS



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  torch.manual_seed(0    )
  lowerCAmelCase													=   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							,					)
  lowerCAmelCase													=   DDIMScheduler()
  torch.manual_seed(0    )
  lowerCAmelCase													=   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    )
  lowerCAmelCase													=   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							,					)
  lowerCAmelCase													=   CLIPTextModel(_snake_case    )
  lowerCAmelCase													=   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

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



 def       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case=0    ):







  """simple docstring"""






  lowerCAmelCase													=   torch.manual_seed(_snake_case    )
  lowerCAmelCase													=   {
      'prompt': 'A field of roses',
      'generator': generator,
      # Setting height and width to None to prevent OOMs on CPU.
      'height': None,
      'width': None,
      'num_inference_steps': 2,
      'guidance_scale': 6.0,
      'output_type': 'numpy',
  }
  return inputs



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   'cpu'  # ensure determinism for the device-dependent torch.Generator
  lowerCAmelCase													=   self.get_dummy_components()
  lowerCAmelCase													=   StableDiffusionModelEditingPipeline(**_snake_case    )
  lowerCAmelCase													=   sd_pipe.to(_snake_case    )
  sd_pipe.set_progress_bar_config(disable=_snake_case    )

  lowerCAmelCase													=   self.get_dummy_inputs(_snake_case    )
  lowerCAmelCase													=   sd_pipe(**_snake_case    ).images
  lowerCAmelCase													=   image[0, -3:, -3:, -1]
  assert image.shape == (1, 64, 64, 3)

  lowerCAmelCase													=   np.array([0.4_755, 0.5_132, 0.4_976, 0.3_904, 0.3_554, 0.4_765, 0.5_139, 0.5_158, 0.4_889]    )

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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   'cpu'  # ensure determinism for the device-dependent torch.Generator
  lowerCAmelCase													=   self.get_dummy_components()
  lowerCAmelCase													=   StableDiffusionModelEditingPipeline(**_snake_case    )
  lowerCAmelCase													=   sd_pipe.to(_snake_case    )
  sd_pipe.set_progress_bar_config(disable=_snake_case    )

  lowerCAmelCase													=   self.get_dummy_inputs(_snake_case    )
  lowerCAmelCase													=   'french fries'
  lowerCAmelCase													=   sd_pipe(**_snake_case							,					negative_prompt=_snake_case    )
  lowerCAmelCase													=   output.images
  lowerCAmelCase													=   image[0, -3:, -3:, -1]

  assert image.shape == (1, 64, 64, 3)

  lowerCAmelCase													=   np.array([0.4_992, 0.5_101, 0.5_004, 0.3_949, 0.3_604, 0.4_735, 0.5_216, 0.5_204, 0.4_913]    )

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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   'cpu'  # ensure determinism for the device-dependent torch.Generator
  lowerCAmelCase													=   self.get_dummy_components()
  lowerCAmelCase													=   EulerAncestralDiscreteScheduler(
      beta_start=0.00_085							,					beta_end=0.012							,					beta_schedule='scaled_linear'    )
  lowerCAmelCase													=   StableDiffusionModelEditingPipeline(**_snake_case    )
  lowerCAmelCase													=   sd_pipe.to(_snake_case    )
  sd_pipe.set_progress_bar_config(disable=_snake_case    )

  lowerCAmelCase													=   self.get_dummy_inputs(_snake_case    )
  lowerCAmelCase													=   sd_pipe(**_snake_case    ).images
  lowerCAmelCase													=   image[0, -3:, -3:, -1]

  assert image.shape == (1, 64, 64, 3)

  lowerCAmelCase													=   np.array([0.4_747, 0.5_372, 0.4_779, 0.4_982, 0.5_543, 0.4_816, 0.5_238, 0.4_904, 0.5_027]    )

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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   'cpu'  # ensure determinism for the device-dependent torch.Generator
  lowerCAmelCase													=   self.get_dummy_components()
  lowerCAmelCase													=   PNDMScheduler()
  lowerCAmelCase													=   StableDiffusionModelEditingPipeline(**_snake_case    )
  lowerCAmelCase													=   sd_pipe.to(_snake_case    )
  sd_pipe.set_progress_bar_config(disable=_snake_case    )

  lowerCAmelCase													=   self.get_dummy_inputs(_snake_case    )
  # the pipeline does not expect pndm so test if it raises error.
  with self.assertRaises(_snake_case    ):
   lowerCAmelCase													=   sd_pipe(**_snake_case    ).images



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  super().test_inference_batch_single_identical(expected_max_diff=5E-3    )



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  super().test_attention_slicing_forward_pass(expected_max_diff=5E-3    )







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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






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



 def       UpperCamelCase__     (    self							,					_snake_case=0    ):







  """simple docstring"""






  lowerCAmelCase													=   torch.manual_seed(_snake_case    )
  lowerCAmelCase													=   {
      'prompt': 'A field of roses',
      'generator': generator,
      'num_inference_steps': 3,
      'guidance_scale': 7.5,
      'output_type': 'numpy',
  }
  return inputs



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   'CompVis/stable-diffusion-v1-4'
  lowerCAmelCase													=   StableDiffusionModelEditingPipeline.from_pretrained(_snake_case							,					safety_checker=_snake_case    )
  pipe.to(_snake_case    )
  pipe.set_progress_bar_config(disable=_snake_case    )
  pipe.enable_attention_slicing()

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

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

  lowerCAmelCase													=   np.array(
      [0.6_749_496, 0.6_386_453, 0.51_443_267, 0.66_094_905, 0.61_921_215, 0.5_491_332, 0.5_744_417, 0.58_075_106, 0.5_174_658]    )

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

  # make sure image changes after editing
  pipe.edit_model('A pack of roses'							,					'A pack of blue roses'    )

  lowerCAmelCase													=   pipe(**_snake_case    ).images
  lowerCAmelCase													=   image[0, -3:, -3:, -1].flatten()

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

  assert np.abs(expected_slice - image_slice    ).max() > 1E-1



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  torch.cuda.empty_cache()
  torch.cuda.reset_max_memory_allocated()
  torch.cuda.reset_peak_memory_stats()

  lowerCAmelCase													=   'CompVis/stable-diffusion-v1-4'
  lowerCAmelCase													=   DDIMScheduler.from_pretrained(_snake_case							,					subfolder='scheduler'    )
  lowerCAmelCase													=   StableDiffusionModelEditingPipeline.from_pretrained(
      _snake_case							,					scheduler=_snake_case							,					safety_checker=_snake_case    )
  lowerCAmelCase													=   pipe.to(_snake_case    )
  pipe.set_progress_bar_config(disable=_snake_case    )
  pipe.enable_attention_slicing(1    )
  pipe.enable_sequential_cpu_offload()

  lowerCAmelCase													=   self.get_inputs()
  lowerCAmelCase													=   pipe(**_snake_case    )

  lowerCAmelCase													=   torch.cuda.max_memory_allocated()
  # make sure that less than 4.4 GB is allocated
  assert mem_bytes < 4.4 * 10**9












"""simple docstring"""
def 		_SCREAMING_SNAKE_CASE (_UpperCAmelCase				:						int     ,    _UpperCAmelCase				:						int ):
 return (input_a, input_a).count(0 ) % 2

def 		_SCREAMING_SNAKE_CASE ():
 assert xor_gate(0     ,    0 ) == 0
 assert xor_gate(0     ,    1 ) == 1
 assert xor_gate(1     ,    0 ) == 1
 assert xor_gate(1     ,    1 ) == 0


if __name__ == "__main__":
       print(xor_gate(0, 0))
       print(xor_gate(0, 1))





