


'''simple docstring'''

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, PNDMScheduler, StableDiffusionInpaintPipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





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





  """simple docstring"""




  _lowerCamelCase						=						StableDiffusionInpaintPipeline
  _lowerCamelCase						=						TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  _lowerCamelCase						=						TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  _lowerCamelCase						=						frozenset(
      []    )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
  _lowerCamelCase						=						frozenset([]    )






  def 						snake_case	(					self  ):







   """simple docstring"""
   torch.manual_seed(0  )
   lowerCamelCase_  				=						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    ,						attention_head_dim=(2, 4)    ,						use_linear_projection=UpperCamelCase    ,						)
   lowerCamelCase_  				=						PNDMScheduler(skip_prk_steps=UpperCamelCase  )
   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    ,						sample_size=128    ,						)
   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=1000    ,						hidden_act="gelu"    ,						projection_dim=512    ,						)
   lowerCamelCase_  				=						CLIPTextModel(UpperCamelCase  )
   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 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase=0  ):







   """simple docstring"""
   # TODO: use tensor inputs instead of PIL, this is here just to leave the old expected_slices untouched
   lowerCamelCase_  				=						floats_tensor((1, 3, 32, 32)    ,						rng=random.Random(UpperCamelCase  )  ).to(UpperCamelCase  )
   lowerCamelCase_  				=						image.cpu().permute(0    ,						2    ,						3    ,						1  )[0]
   lowerCamelCase_  				=						Image.fromarray(np.uinta(UpperCamelCase  )  ).convert("RGB"  ).resize((64, 64)  )
   lowerCamelCase_  				=						Image.fromarray(np.uinta(image + 4  )  ).convert("RGB"  ).resize((64, 64)  )
   if str(UpperCamelCase  ).startswith("mps"  ):
    lowerCamelCase_  				=						torch.manual_seed(UpperCamelCase  )
   else:
    lowerCamelCase_  				=						torch.Generator(device=UpperCamelCase  ).manual_seed(UpperCamelCase  )
   lowerCamelCase_  				=						{
       "prompt": "A painting of a squirrel eating a burger",
       "image": init_image,
       "mask_image": mask_image,
       "generator": generator,
       "num_inference_steps": 2,
       "guidance_scale": 6.0,
       "output_type": "numpy",
   }
   return inputs






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"cpu"  # ensure determinism for the device-dependent torch.Generator
   lowerCamelCase_  				=						self.get_dummy_components()
   lowerCamelCase_  				=						StableDiffusionInpaintPipeline(**UpperCamelCase  )
   lowerCamelCase_  				=						sd_pipe.to(UpperCamelCase  )
   sd_pipe.set_progress_bar_config(disable=UpperCamelCase  )

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

   assert image.shape == (1, 64, 64, 3)
   lowerCamelCase_  				=						np.array([0.4_727, 0.5_735, 0.3_941, 0.5_446, 0.5_926, 0.4_394, 0.5_062, 0.4_654, 0.4_476]  )

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







  def 						snake_case	(					self  ):







   """simple docstring"""
   super().test_inference_batch_single_identical(expected_max_diff=3e-3  )





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





  """simple docstring"""




  def 						snake_case	(					self  ):







   """simple docstring"""
   # clean up the VRAM after each test
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
       "/sd2-inpaint/init_image.png"  )
   lowerCamelCase_  				=						load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"  )
   lowerCamelCase_  				=						load_numpy(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint"
       "/yellow_cat_sitting_on_a_park_bench.npy"  )

   lowerCamelCase_  				=						"stabilityai/stable-diffusion-2-inpainting"
   lowerCamelCase_  				=						StableDiffusionInpaintPipeline.from_pretrained(UpperCamelCase    ,						safety_checker=UpperCamelCase  )
   pipe.to(UpperCamelCase  )
   pipe.set_progress_bar_config(disable=UpperCamelCase  )
   pipe.enable_attention_slicing()

   lowerCamelCase_  				=						"Face of a yellow cat, high resolution, sitting on a park bench"

   lowerCamelCase_  				=						torch.manual_seed(0  )
   lowerCamelCase_  				=						pipe(
       prompt=UpperCamelCase    ,						image=UpperCamelCase    ,						mask_image=UpperCamelCase    ,						generator=UpperCamelCase    ,						output_type="np"    ,						)
   lowerCamelCase_  				=						output.images[0]

   assert image.shape == (512, 512, 3)
   assert np.abs(expected_image - image  ).max() < 9e-3






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
       "/sd2-inpaint/init_image.png"  )
   lowerCamelCase_  				=						load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"  )
   lowerCamelCase_  				=						load_numpy(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint"
       "/yellow_cat_sitting_on_a_park_bench_fp16.npy"  )

   lowerCamelCase_  				=						"stabilityai/stable-diffusion-2-inpainting"
   lowerCamelCase_  				=						StableDiffusionInpaintPipeline.from_pretrained(
       UpperCamelCase    ,						torch_dtype=torch.floataa    ,						safety_checker=UpperCamelCase    ,						)
   pipe.to(UpperCamelCase  )
   pipe.set_progress_bar_config(disable=UpperCamelCase  )
   pipe.enable_attention_slicing()

   lowerCamelCase_  				=						"Face of a yellow cat, high resolution, sitting on a park bench"

   lowerCamelCase_  				=						torch.manual_seed(0  )
   lowerCamelCase_  				=						pipe(
       prompt=UpperCamelCase    ,						image=UpperCamelCase    ,						mask_image=UpperCamelCase    ,						generator=UpperCamelCase    ,						output_type="np"    ,						)
   lowerCamelCase_  				=						output.images[0]

   assert image.shape == (512, 512, 3)
   assert np.abs(expected_image - image  ).max() < 5e-1







  def 						snake_case	(					self  ):







   """simple docstring"""
   torch.cuda.empty_cache()
   torch.cuda.reset_max_memory_allocated()
   torch.cuda.reset_peak_memory_stats()

   lowerCamelCase_  				=						load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
       "/sd2-inpaint/init_image.png"  )
   lowerCamelCase_  				=						load_image(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"  )

   lowerCamelCase_  				=						"stabilityai/stable-diffusion-2-inpainting"
   lowerCamelCase_  				=						PNDMScheduler.from_pretrained(UpperCamelCase    ,						subfolder="scheduler"  )
   lowerCamelCase_  				=						StableDiffusionInpaintPipeline.from_pretrained(
       UpperCamelCase    ,						safety_checker=UpperCamelCase    ,						scheduler=UpperCamelCase    ,						torch_dtype=torch.floataa    ,						)
   pipe.to(UpperCamelCase  )
   pipe.set_progress_bar_config(disable=UpperCamelCase  )
   pipe.enable_attention_slicing(1  )
   pipe.enable_sequential_cpu_offload()

   lowerCamelCase_  				=						"Face of a yellow cat, high resolution, sitting on a park bench"

   lowerCamelCase_  				=						torch.manual_seed(0  )
   lowerCamelCase_  				=						pipe(
       prompt=UpperCamelCase    ,						image=UpperCamelCase    ,						mask_image=UpperCamelCase    ,						generator=UpperCamelCase    ,						num_inference_steps=2    ,						output_type="np"    ,						)

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







'''simple docstring'''

from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
     from ...feature_extraction_utils import FeatureExtractionMixin
     from ...tokenization_utils_base import PreTrainedTokenizerBase
     from ...utils import TensorType

a_						:       Optional[int]      			=				logging.get_logger(__name__)

a_						:       Optional[int]      			=				{
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
a_						:       List[str]      			=				[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1058, 1220, 1267, 1279, 1303, 1343, 1377,
    1391, 1635, 1782, 1875, 2162, 2361, 2488, 3467, 4008, 4211,
    4600, 4808, 5299, 5855, 6329, 7203, 9609, 9959, 10563, 10786,
    11420, 11709, 11907, 13163, 13697, 13700, 14808, 15306, 16410, 16791,
    17992, 19203, 19510, 20724, 22305, 22935, 27007, 30109, 30420, 33409,
    34949, 40283, 40493, 40549, 47282, 49146, 50257, 50359, 50360, 50361
]
a_						:       Tuple      			=				[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1350, 1853, 1982, 2460, 2627,
    3246, 3253, 3268, 3536, 3846, 3961, 4183, 4667, 6585, 6647,
    7273, 9061, 9383, 10428, 10929, 11938, 12033, 12331, 12562, 13793,
    14157, 14635, 15265, 15618, 16553, 16604, 18362, 18956, 20075, 21675,
    22520, 26130, 26161, 26435, 28279, 29464, 31650, 32302, 32470, 36865,
    42863, 47425, 49870, 50254, 50258, 50360, 50361, 50362
]





class   snake_case					(					lowercase    ):





  """simple docstring"""




  _lowerCamelCase						=						"whisper"
  _lowerCamelCase						=						["past_key_values"]
  _lowerCamelCase						=						{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}






  def __init__(					self    ,						UpperCamelCase=5_1865    ,						UpperCamelCase=80    ,						UpperCamelCase=6    ,						UpperCamelCase=4    ,						UpperCamelCase=6    ,						UpperCamelCase=4    ,						UpperCamelCase=1536    ,						UpperCamelCase=1536    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=5_0257    ,						UpperCamelCase=True    ,						UpperCamelCase=True    ,						UpperCamelCase="gelu"    ,						UpperCamelCase=256    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.02    ,						UpperCamelCase=False    ,						UpperCamelCase=1500    ,						UpperCamelCase=448    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=None    ,						UpperCamelCase=[220, 5_0256]    ,						UpperCamelCase=False    ,						UpperCamelCase=256    ,						UpperCamelCase=False    ,						UpperCamelCase=0.05    ,						UpperCamelCase=10    ,						UpperCamelCase=2    ,						UpperCamelCase=0.0    ,						UpperCamelCase=10    ,						UpperCamelCase=0    ,						UpperCamelCase=7    ,						**UpperCamelCase    ,						):







   """simple docstring"""
   lowerCamelCase_  				=						vocab_size
   lowerCamelCase_  				=						num_mel_bins
   lowerCamelCase_  				=						d_model
   lowerCamelCase_  				=						encoder_layers
   lowerCamelCase_  				=						encoder_attention_heads
   lowerCamelCase_  				=						decoder_layers
   lowerCamelCase_  				=						decoder_attention_heads
   lowerCamelCase_  				=						decoder_ffn_dim
   lowerCamelCase_  				=						encoder_ffn_dim
   lowerCamelCase_  				=						dropout
   lowerCamelCase_  				=						attention_dropout
   lowerCamelCase_  				=						activation_dropout
   lowerCamelCase_  				=						activation_function
   lowerCamelCase_  				=						init_std
   lowerCamelCase_  				=						encoder_layerdrop
   lowerCamelCase_  				=						decoder_layerdrop
   lowerCamelCase_  				=						use_cache
   lowerCamelCase_  				=						encoder_layers
   lowerCamelCase_  				=						scale_embedding  # scale factor will be sqrt(d_model) if True
   lowerCamelCase_  				=						max_source_positions
   lowerCamelCase_  				=						max_target_positions

   # Audio Classification-specific parameters. Feel free to ignore for other classes.
   lowerCamelCase_  				=						classifier_proj_size
   lowerCamelCase_  				=						use_weighted_layer_sum

   # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
   lowerCamelCase_  				=						apply_spec_augment
   lowerCamelCase_  				=						mask_time_prob
   lowerCamelCase_  				=						mask_time_length
   lowerCamelCase_  				=						mask_time_min_masks
   lowerCamelCase_  				=						mask_feature_prob
   lowerCamelCase_  				=						mask_feature_length
   lowerCamelCase_  				=						mask_feature_min_masks

   lowerCamelCase_  				=						median_filter_width

   super().__init__(
       pad_token_id=UpperCamelCase    ,						bos_token_id=UpperCamelCase    ,						eos_token_id=UpperCamelCase    ,						is_encoder_decoder=UpperCamelCase    ,						decoder_start_token_id=UpperCamelCase    ,						suppress_tokens=UpperCamelCase    ,						begin_suppress_tokens=UpperCamelCase    ,						**UpperCamelCase    ,						)





class   snake_case					(					lowercase    ):





  """simple docstring"""




  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						OrderedDict(
       [
           ("input_features", {0: "batch", 1: "feature_size", 2: "encoder_sequence"}),
       ]  )
   if self.use_past:
    lowerCamelCase_  				=						{0: "batch"}
   else:
    lowerCamelCase_  				=						{0: "batch", 1: "decoder_sequence"}

   if self.use_past:
    self.fill_with_past_key_values_(UpperCamelCase    ,						direction="inputs"  )

   return common_inputs






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase = -1    ,						UpperCamelCase = -1    ,						UpperCamelCase = False    ,						UpperCamelCase = None    ,						UpperCamelCase = 2_2050    ,						UpperCamelCase = 5.0    ,						UpperCamelCase = 220    ,						):







   """simple docstring"""
   lowerCamelCase_  				=						OrderedDict()
   lowerCamelCase_  				=						OnnxConfig.generate_dummy_inputs(
       self    ,						preprocessor=preprocessor.feature_extractor    ,						batch_size=UpperCamelCase    ,						framework=UpperCamelCase    ,						sampling_rate=UpperCamelCase    ,						time_duration=UpperCamelCase    ,						frequency=UpperCamelCase    ,						)
   lowerCamelCase_  				=						encoder_inputs["input_features"].shape[2]
   lowerCamelCase_  				=						encoder_sequence_length // 2 if self.use_past else seq_length

   lowerCamelCase_  				=						super().generate_dummy_inputs(
       preprocessor.tokenizer    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  )

   lowerCamelCase_  				=						encoder_inputs.pop("input_features"  )
   lowerCamelCase_  				=						decoder_inputs.pop("decoder_input_ids"  )

   if "past_key_values" in decoder_inputs:
    lowerCamelCase_  				=						decoder_inputs.pop("past_key_values"  )

   return dummy_inputs







  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 1e-3



