

'''simple docstring'''



import itertools
import random
import unittest

import numpy as np

from transformers import ASTFeatureExtractor
from transformers.testing_utils import require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


UpperCAmelCase :       Any			   =     random.Random()

if is_torch_available():
  import torch







def    a__       (  a__      ,    a__=1.0      ,    a__=None      ,    a__=None						):




     """simple docstring"""


     if rng is None:
          __SCREAMING_SNAKE_CASE     =      global_rng

     __SCREAMING_SNAKE_CASE     =      []
     for batch_idx in range(shape[0]						):
          values.append([]						)
          for _ in range(shape[1]						):
               values[-1].append(rng.random() * scale						)

     return values







class 						lowerCAmelCase__   (      unittest.TestCase					):



 """simple docstring"""



 def __init__(		self					:       List[Any]					,							__SCREAMING_SNAKE_CASE					:       List[Any]					,							__SCREAMING_SNAKE_CASE					:       List[Any]=7					,							__SCREAMING_SNAKE_CASE					:       Optional[Any]=400					,							__SCREAMING_SNAKE_CASE					:       Union[str, Any]=2_000					,							__SCREAMING_SNAKE_CASE					:       Tuple=1					,							__SCREAMING_SNAKE_CASE					:       Union[str, Any]=0.0					,							__SCREAMING_SNAKE_CASE					:       List[Any]=16_000					,							__SCREAMING_SNAKE_CASE					:       int=True					,							__SCREAMING_SNAKE_CASE					:       Optional[Any]=True					,							)  -> Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      parent
      __SCREAMING_SNAKE_CASE     =      batch_size
      __SCREAMING_SNAKE_CASE     =      min_seq_length
      __SCREAMING_SNAKE_CASE     =      max_seq_length
      __SCREAMING_SNAKE_CASE     =      (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
      __SCREAMING_SNAKE_CASE     =      feature_size
      __SCREAMING_SNAKE_CASE     =      padding_value
      __SCREAMING_SNAKE_CASE     =      sampling_rate
      __SCREAMING_SNAKE_CASE     =      return_attention_mask
      __SCREAMING_SNAKE_CASE     =      do_normalize
 def       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> int:


      """simple docstring"""




      return {
          "feature_size": self.feature_size,
          "padding_value": self.padding_value,
          "sampling_rate": self.sampling_rate,
          "return_attention_mask": self.return_attention_mask,
          "do_normalize": self.do_normalize,
      }


 def       UpperCAmelCase__		(		self					:       List[Any]					,							__SCREAMING_SNAKE_CASE					:       Tuple=False					,							__SCREAMING_SNAKE_CASE					:       Any=False			)  -> Union[str, Any]:


      """simple docstring"""




      def _flatten(__SCREAMING_SNAKE_CASE					:       Dict			):
           return list(itertools.chain(*__SCREAMING_SNAKE_CASE			)			)

      if equal_length:
           __SCREAMING_SNAKE_CASE     =      floats_list((self.batch_size, self.max_seq_length)			)
      else:
           # make sure that inputs increase in size
           __SCREAMING_SNAKE_CASE     =      [
               _flatten(floats_list((x, self.feature_size)			)			)
               for x in range(self.min_seq_length					,							self.max_seq_length					,							self.seq_length_diff			)
           ]

      if numpify:
           __SCREAMING_SNAKE_CASE     =      [np.asarray(__SCREAMING_SNAKE_CASE			) for x in speech_inputs]

      return speech_inputs







@require_torch
@require_torchaudio
class 						lowerCAmelCase__   (      a ,					unittest.TestCase					):



 """simple docstring"""



 lowerCAmelCase__  					=      ASTFeatureExtractor
 def       UpperCAmelCase__		(		self					:       Optional[int]			)  -> Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      ASTFeatureExtractionTester(self			)
 def       UpperCAmelCase__		(		self					:       List[Any]			)  -> Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
      # create three inputs of length 800, 1000, and 1200
      __SCREAMING_SNAKE_CASE     =      [floats_list((1, x)			)[0] for x in range(800					,							1_400					,							200			)]
      __SCREAMING_SNAKE_CASE     =      [np.asarray(__SCREAMING_SNAKE_CASE			) for speech_input in speech_inputs]

      # Test not batched input
      __SCREAMING_SNAKE_CASE     =      feat_extract(speech_inputs[0]					,							return_tensors="""np"""			).input_values
      __SCREAMING_SNAKE_CASE     =      feat_extract(np_speech_inputs[0]					,							return_tensors="""np"""			).input_values
      self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE					,							atol=1E-3			)			)

      # Test batched
      __SCREAMING_SNAKE_CASE     =      feat_extract(__SCREAMING_SNAKE_CASE					,							padding=__SCREAMING_SNAKE_CASE					,							return_tensors="""np"""			).input_values
      __SCREAMING_SNAKE_CASE     =      feat_extract(__SCREAMING_SNAKE_CASE					,							padding=__SCREAMING_SNAKE_CASE					,							return_tensors="""np"""			).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			):
           self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE					,							atol=1E-3			)			)

      # Test 2-D numpy arrays are batched.
      __SCREAMING_SNAKE_CASE     =      [floats_list((1, x)			)[0] for x in (800, 800, 800)]
      __SCREAMING_SNAKE_CASE     =      np.asarray(__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      feat_extract(__SCREAMING_SNAKE_CASE					,							return_tensors="""np"""			).input_values
      __SCREAMING_SNAKE_CASE     =      feat_extract(__SCREAMING_SNAKE_CASE					,							return_tensors="""np"""			).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			):
           self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE					,							atol=1E-3			)			)
 @require_torch
 def       UpperCAmelCase__		(		self					:       Tuple			)  -> Any:


      """simple docstring"""




      import torch

      __SCREAMING_SNAKE_CASE     =      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
      __SCREAMING_SNAKE_CASE     =      np.random.rand(100			).astype(np.floataa			)
      __SCREAMING_SNAKE_CASE     =      np_speech_inputs.tolist()

      for inputs in [py_speech_inputs, np_speech_inputs]:
           __SCREAMING_SNAKE_CASE     =      feature_extractor.pad([{"""input_values""": inputs}]					,							return_tensors="""np"""			)
           self.assertTrue(np_processed.input_values.dtype == np.floataa			)
           __SCREAMING_SNAKE_CASE     =      feature_extractor.pad([{"""input_values""": inputs}]					,							return_tensors="""pt"""			)
           self.assertTrue(pt_processed.input_values.dtype == torch.floataa			)
 def       UpperCAmelCase__		(		self					:       Optional[int]					,							__SCREAMING_SNAKE_CASE					:       Optional[Any]			)  -> Union[str, Any]:


      """simple docstring"""




      from datasets import load_dataset

      __SCREAMING_SNAKE_CASE     =      load_dataset("""hf-internal-testing/librispeech_asr_dummy"""					,							"""clean"""					,							split="""validation"""			)
      # automatic decoding with librispeech
      __SCREAMING_SNAKE_CASE     =      ds.sort("""id"""			).select(range(__SCREAMING_SNAKE_CASE			)			)[:num_samples]["""audio"""]

      return [x["array"] for x in speech_samples]


 @require_torch
 def       UpperCAmelCase__		(		self					:       str			)  -> Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      torch.tensor(
          [-0.9894, -1.2776, -0.9066, -1.2776, -0.9349, -1.2609, -1.0386, -1.2776,
           -1.1561, -1.2776, -1.2052, -1.2723, -1.2190, -1.2132, -1.2776, -1.1133,
           -1.1953, -1.1343, -1.1584, -1.2203, -1.1770, -1.2474, -1.2381, -1.1936,
           -0.9270, -0.8317, -0.8049, -0.7706, -0.7565, -0.7869]			)
      # fmt: on

      __SCREAMING_SNAKE_CASE     =      self._load_datasamples(1			)
      __SCREAMING_SNAKE_CASE     =      ASTFeatureExtractor()
      __SCREAMING_SNAKE_CASE     =      feature_extractor(__SCREAMING_SNAKE_CASE					,							return_tensors="""pt"""			).input_values
      self.assertEquals(input_values.shape					,							(1, 1_024, 128)			)
      self.assertTrue(torch.allclose(input_values[0, 0, :30]					,							__SCREAMING_SNAKE_CASE					,							atol=1E-4			)			)









'''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 						lowerCAmelCase__   (      a ,					a ,					a ,					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       UpperCAmelCase__		(		self					:       str			)  -> List[Any]:


      """simple docstring"""




      torch.manual_seed(0			)
      __SCREAMING_SNAKE_CASE     =      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=__SCREAMING_SNAKE_CASE					,							)
      __SCREAMING_SNAKE_CASE     =      PNDMScheduler(skip_prk_steps=__SCREAMING_SNAKE_CASE			)
      torch.manual_seed(0			)
      __SCREAMING_SNAKE_CASE     =      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			)
      __SCREAMING_SNAKE_CASE     =      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					,							hidden_act="""gelu"""					,							projection_dim=512					,							)
      __SCREAMING_SNAKE_CASE     =      CLIPTextModel(__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)

      __SCREAMING_SNAKE_CASE     =      {
          """unet""": unet,
          """scheduler""": scheduler,
          """vae""": vae,
          """text_encoder""": text_encoder,
          """tokenizer""": tokenizer,
          """safety_checker""": None,
          """feature_extractor""": None,
      }
      return components
 def       UpperCAmelCase__		(		self					:       Any					,							__SCREAMING_SNAKE_CASE					:       Tuple					,							__SCREAMING_SNAKE_CASE					:       List[Any]=0			)  -> int:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      floats_tensor((1, 3, 32, 32)					,							rng=random.Random(__SCREAMING_SNAKE_CASE			)			).to(__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      image.cpu().permute(0					,							2					,							3					,							1			)[0]
      __SCREAMING_SNAKE_CASE     =      Image.fromarray(np.uinta(__SCREAMING_SNAKE_CASE			)			).convert("""RGB"""			).resize((64, 64)			)
      __SCREAMING_SNAKE_CASE     =      Image.fromarray(np.uinta(image + 4			)			).convert("""RGB"""			).resize((64, 64)			)
      if str(__SCREAMING_SNAKE_CASE			).startswith("""mps"""			):
           __SCREAMING_SNAKE_CASE     =      torch.manual_seed(__SCREAMING_SNAKE_CASE			)
      else:
           __SCREAMING_SNAKE_CASE     =      torch.Generator(device=__SCREAMING_SNAKE_CASE			).manual_seed(__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      {
          """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       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> int:


      """simple docstring"""




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

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

      assert image.shape == (1, 64, 64, 3)
      __SCREAMING_SNAKE_CASE     =      np.array([0.4727, 0.5735, 0.3941, 0.5446, 0.5926, 0.4394, 0.5062, 0.4654, 0.4476]			)

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


 def       UpperCAmelCase__		(		self					:       Tuple			)  -> str:


      """simple docstring"""




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







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



 """simple docstring"""



 def       UpperCAmelCase__		(		self					:       List[Any]			)  -> str:


      """simple docstring"""




      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> str:


      """simple docstring"""




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

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

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

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

      assert image.shape == (512, 512, 3)
      assert np.abs(expected_image - image			).max() < 9E-3
 def       UpperCAmelCase__		(		self					:       List[Any]			)  -> Optional[Any]:


      """simple docstring"""




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

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

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

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

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


 def       UpperCAmelCase__		(		self					:       Tuple			)  -> Any:


      """simple docstring"""




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

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

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

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

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

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






