


'''simple docstring'''



from typing import List, Optional

import numpy as np

from ...processing_utils import ProcessorMixin
from ...utils import to_numpy



class      a    (		_a	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Tuple							       =       "EncodecFeatureExtractor"
     SCREAMING_SNAKE_CASE	:			Dict							       =       ("T5Tokenizer", "T5TokenizerFast")

     def __init__(    self					:		Union[str, Any]							,			snake_case					:		List[Any]							,			snake_case					:		Optional[int]      )						->							Union[str, Any]:
          super().__init__(snake_case							,			snake_case      )
          __UpperCAmelCase     :			List[Any]  							=      self.feature_extractor
          __UpperCAmelCase     :			Optional[int]  							=      False

     def 			lowerCamelCase__			(    self					:		int							,			snake_case					:		Optional[Any]=None							,			snake_case					:		Optional[Any]=None							,			snake_case					:		int=True      )						->							Dict:
          return self.tokenizer.get_decoder_prompt_ids(task=snake_case							,			language=snake_case							,			no_timestamps=snake_case      )

     def __call__(    self					:		str							,			*snake_case					:		Dict							,			**snake_case					:		Tuple      )						->							int:
          # For backward compatibility
          if self._in_target_context_manager:
               return self.current_processor(*snake_case							,			**snake_case      )

          __UpperCAmelCase     :			Optional[Any]  							=      kwargs.pop('''audio'''							,			snake_case      )
          __UpperCAmelCase     :			List[str]  							=      kwargs.pop('''sampling_rate'''							,			snake_case      )
          __UpperCAmelCase     :			List[str]  							=      kwargs.pop('''text'''							,			snake_case      )
          if len(snake_case      ) > 0:
               __UpperCAmelCase     :			int  							=      args[0]
               __UpperCAmelCase     :			Optional[Any]  							=      args[1:]

          if audio is None and text is None:
               raise ValueError('''You need to specify either an `audio` or `text` input to process.'''      )

          if text is not None:
               __UpperCAmelCase     :			Any  							=      self.tokenizer(snake_case							,			**snake_case      )

          if audio is not None:
               __UpperCAmelCase     :			List[str]  							=      self.feature_extractor(snake_case							,			*snake_case							,			sampling_rate=snake_case							,			**snake_case      )

          if audio is None:
               return inputs

          elif text is None:
               return audio_inputs

          else:
               __UpperCAmelCase     :			List[str]  							=      audio_inputs['''input_values''']
               if "padding_mask" in audio_inputs:
                    __UpperCAmelCase     :			List[Any]  							=      audio_inputs['''padding_mask''']
               return inputs

     def 			lowerCamelCase__			(    self					:		Tuple							,			*snake_case					:		int							,			**snake_case					:		Tuple      )						->							List[str]:
          __UpperCAmelCase     :			str  							=      kwargs.pop('''audio'''							,			snake_case      )
          __UpperCAmelCase     :			int  							=      kwargs.pop('''padding_mask'''							,			snake_case      )

          if len(snake_case      ) > 0:
               __UpperCAmelCase     :			Dict  							=      args[0]
               __UpperCAmelCase     :			Optional[int]  							=      args[1:]

          if audio_values is not None:
               return self._decode_audio(snake_case							,			padding_mask=snake_case      )
          else:
               return self.tokenizer.batch_decode(*snake_case							,			**snake_case      )

     def 			lowerCamelCase__			(    self					:		Union[str, Any]							,			*snake_case					:		int							,			**snake_case					:		Union[str, Any]      )						->							Tuple:
          return self.tokenizer.decode(*snake_case							,			**snake_case      )






     def 			lowerCamelCase__			(    self					:		List[Any]							,			snake_case					:		Optional[Any]							,			snake_case					:		Optional = None      )						->							List[np.ndarray]:
          __UpperCAmelCase     :			Optional[int]  							=      to_numpy(snake_case      )
          __UpperCAmelCase							,       __UpperCAmelCase							,       __UpperCAmelCase     :			Dict  							=      audio_values.shape

          if padding_mask is None:
               return list(snake_case      )

          __UpperCAmelCase     :			Optional[Any]  							=      to_numpy(snake_case      )

          # match the sequence length of the padding mask to the generated audio arrays by padding with the **non-padding**
          # token (so that the generated audio values are **not** treated as padded tokens)
          __UpperCAmelCase     :			List[Any]  							=      seq_len - padding_mask.shape[-1]
          __UpperCAmelCase     :			Dict  							=      1 - self.feature_extractor.padding_value
          __UpperCAmelCase     :			str  							=      np.pad(snake_case							,			((0, 0), (0, difference))							,			'''constant'''							,			constant_values=snake_case      )

          __UpperCAmelCase     :			Any  							=      audio_values.tolist()
          for i in range(snake_case      ):
               __UpperCAmelCase     :			str  							=      np.asarray(audio_values[i]      )[
                   padding_mask[i][None, :] != self.feature_extractor.padding_value
               ]
               __UpperCAmelCase     :			str  							=      sliced_audio.reshape(snake_case							,			-1      )

          return audio_values



'''simple docstring'''



import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin



@skip_mps
class      a    (		_a     ,  _a     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       IFPipeline
     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       TEXT_TO_IMAGE_PARAMS - {"width", "height", "latents"}
     SCREAMING_SNAKE_CASE	:			Optional[int]							       =       TEXT_TO_IMAGE_BATCH_PARAMS
     SCREAMING_SNAKE_CASE	:			str							       =       PipelineTesterMixin.required_optional_params - {"latents"}

     def 			lowerCamelCase__			(    self					:		Tuple      )						->							Optional[Any]:
          return self._get_dummy_components()

     def 			lowerCamelCase__			(    self					:		Optional[Any]							,			snake_case					:		Optional[int]							,			snake_case					:		List[Any]=0      )						->							Optional[Any]:
          if str(snake_case      ).startswith('''mps'''      ):
               __UpperCAmelCase     :			Optional[Any]  							=      torch.manual_seed(snake_case      )
          else:
               __UpperCAmelCase     :			Dict  							=      torch.Generator(device=snake_case      ).manual_seed(snake_case      )

          __UpperCAmelCase     :			str  							=      {
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''output_type''': '''numpy''',
          }

          return inputs

     def 			lowerCamelCase__			(    self					:		List[str]      )						->							Optional[int]:
          self._test_save_load_optional_components()

     @unittest.skipIf(torch_device != '''cuda'''							,			reason='''float16 requires CUDA'''      )
     def 			lowerCamelCase__			(    self					:		Dict      )						->							Union[str, Any]:
          # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
          super().test_save_load_floataa(expected_max_diff=1E-1      )

     def 			lowerCamelCase__			(    self					:		List[str]      )						->							Tuple:
          self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )

     def 			lowerCamelCase__			(    self					:		Any      )						->							List[str]:
          self._test_save_load_local()

     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							str:
          self._test_inference_batch_single_identical(
              expected_max_diff=1E-2							,			)






     @unittest.skipIf(
         torch_device != '''cuda''' or not is_xformers_available()							,			reason='''XFormers attention is only available with CUDA and `xformers` installed'''							,			)
     def 			lowerCamelCase__			(    self					:		str      )						->							Optional[Any]:
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )



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


     """simple docstring"""






     def 			lowerCamelCase__			(    self					:		Dict      )						->							Dict:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()

     def 			lowerCamelCase__			(    self					:		Any      )						->							Tuple:
          # if

          __UpperCAmelCase     :			Union[str, Any]  							=      IFPipeline.from_pretrained('''DeepFloyd/IF-I-XL-v1.0'''							,			variant='''fp16'''							,			torch_dtype=torch.floataa      )

          __UpperCAmelCase     :			List[str]  							=      IFSuperResolutionPipeline.from_pretrained(
              '''DeepFloyd/IF-II-L-v1.0'''							,			variant='''fp16'''							,			torch_dtype=torch.floataa							,			text_encoder=snake_case							,			tokenizer=snake_case      )

          # pre compute text embeddings and remove T5 to save memory

          pipe_a.text_encoder.to('''cuda'''      )

          __UpperCAmelCase							,       __UpperCAmelCase     :			Tuple  							=      pipe_a.encode_prompt('''anime turtle'''							,			device='''cuda'''      )

          del pipe_a.tokenizer
          del pipe_a.text_encoder
          gc.collect()

          __UpperCAmelCase     :			Any  							=      None
          __UpperCAmelCase     :			Optional[Any]  							=      None

          pipe_a.enable_model_cpu_offload()
          pipe_a.enable_model_cpu_offload()

          pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )
          pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )

          self._test_if(snake_case							,			snake_case							,			snake_case							,			snake_case      )

          pipe_a.remove_all_hooks()
          pipe_a.remove_all_hooks()

          # img2img

          __UpperCAmelCase     :			Union[str, Any]  							=      IFImgaImgPipeline(**pipe_a.components      )
          __UpperCAmelCase     :			int  							=      IFImgaImgSuperResolutionPipeline(**pipe_a.components      )

          pipe_a.enable_model_cpu_offload()
          pipe_a.enable_model_cpu_offload()

          pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )
          pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )

          self._test_if_imgaimg(snake_case							,			snake_case							,			snake_case							,			snake_case      )

          pipe_a.remove_all_hooks()
          pipe_a.remove_all_hooks()

          # inpainting

          __UpperCAmelCase     :			List[str]  							=      IFInpaintingPipeline(**pipe_a.components      )
          __UpperCAmelCase     :			List[str]  							=      IFInpaintingSuperResolutionPipeline(**pipe_a.components      )

          pipe_a.enable_model_cpu_offload()
          pipe_a.enable_model_cpu_offload()

          pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )
          pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()      )

          self._test_if_inpainting(snake_case							,			snake_case							,			snake_case							,			snake_case      )

     def 			lowerCamelCase__			(    self					:		List[str]							,			snake_case					:		Any							,			snake_case					:		Union[str, Any]							,			snake_case					:		Optional[int]							,			snake_case					:		str      )						->							Optional[int]:
          # pipeline 1

          _start_torch_memory_measurement()

          __UpperCAmelCase     :			Dict  							=      torch.Generator(device='''cpu'''      ).manual_seed(0      )
          __UpperCAmelCase     :			List[str]  							=      pipe_a(
              prompt_embeds=snake_case							,			negative_prompt_embeds=snake_case							,			num_inference_steps=2							,			generator=snake_case							,			output_type='''np'''							,			)

          __UpperCAmelCase     :			List[Any]  							=      output.images[0]

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

          __UpperCAmelCase     :			List[str]  							=      torch.cuda.max_memory_allocated()
          assert mem_bytes < 13 * 10**9

          __UpperCAmelCase     :			Optional[Any]  							=      load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'''      )
          assert_mean_pixel_difference(snake_case							,			snake_case      )

          # pipeline 2

          _start_torch_memory_measurement()

          __UpperCAmelCase     :			int  							=      torch.Generator(device='''cpu'''      ).manual_seed(0      )

          __UpperCAmelCase     :			Optional[int]  							=      floats_tensor((1, 3, 64, 64)							,			rng=random.Random(0      )      ).to(snake_case      )

          __UpperCAmelCase     :			List[Any]  							=      pipe_a(
              prompt_embeds=snake_case							,			negative_prompt_embeds=snake_case							,			image=snake_case							,			generator=snake_case							,			num_inference_steps=2							,			output_type='''np'''							,			)

          __UpperCAmelCase     :			Optional[Any]  							=      output.images[0]

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

          __UpperCAmelCase     :			List[str]  							=      torch.cuda.max_memory_allocated()
          assert mem_bytes < 4 * 10**9

          __UpperCAmelCase     :			Tuple  							=      load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'''      )
          assert_mean_pixel_difference(snake_case							,			snake_case      )

     def 			lowerCamelCase__			(    self					:		Optional[int]							,			snake_case					:		Optional[int]							,			snake_case					:		Union[str, Any]							,			snake_case					:		str							,			snake_case					:		Dict      )						->							str:
          # pipeline 1

          _start_torch_memory_measurement()

          __UpperCAmelCase     :			Optional[Any]  							=      floats_tensor((1, 3, 64, 64)							,			rng=random.Random(0      )      ).to(snake_case      )

          __UpperCAmelCase     :			Dict  							=      torch.Generator(device='''cpu'''      ).manual_seed(0      )

          __UpperCAmelCase     :			Dict  							=      pipe_a(
              prompt_embeds=snake_case							,			negative_prompt_embeds=snake_case							,			image=snake_case							,			num_inference_steps=2							,			generator=snake_case							,			output_type='''np'''							,			)

          __UpperCAmelCase     :			int  							=      output.images[0]

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

          __UpperCAmelCase     :			Any  							=      torch.cuda.max_memory_allocated()
          assert mem_bytes < 10 * 10**9

          __UpperCAmelCase     :			Optional[Any]  							=      load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'''      )
          assert_mean_pixel_difference(snake_case							,			snake_case      )

          # pipeline 2

          _start_torch_memory_measurement()

          __UpperCAmelCase     :			Optional[int]  							=      torch.Generator(device='''cpu'''      ).manual_seed(0      )

          __UpperCAmelCase     :			Optional[Any]  							=      floats_tensor((1, 3, 256, 256)							,			rng=random.Random(0      )      ).to(snake_case      )
          __UpperCAmelCase     :			List[str]  							=      floats_tensor((1, 3, 64, 64)							,			rng=random.Random(0      )      ).to(snake_case      )

          __UpperCAmelCase     :			List[str]  							=      pipe_a(
              prompt_embeds=snake_case							,			negative_prompt_embeds=snake_case							,			image=snake_case							,			original_image=snake_case							,			generator=snake_case							,			num_inference_steps=2							,			output_type='''np'''							,			)

          __UpperCAmelCase     :			int  							=      output.images[0]

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

          __UpperCAmelCase     :			int  							=      torch.cuda.max_memory_allocated()
          assert mem_bytes < 4 * 10**9

          __UpperCAmelCase     :			Any  							=      load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy'''      )
          assert_mean_pixel_difference(snake_case							,			snake_case      )






     def 			lowerCamelCase__			(    self					:		str							,			snake_case					:		Union[str, Any]							,			snake_case					:		Optional[int]							,			snake_case					:		Optional[Any]							,			snake_case					:		Optional[Any]      )						->							Optional[int]:
          # pipeline 1

          _start_torch_memory_measurement()

          __UpperCAmelCase     :			List[Any]  							=      floats_tensor((1, 3, 64, 64)							,			rng=random.Random(0      )      ).to(snake_case      )
          __UpperCAmelCase     :			List[str]  							=      floats_tensor((1, 3, 64, 64)							,			rng=random.Random(1      )      ).to(snake_case      )

          __UpperCAmelCase     :			Optional[Any]  							=      torch.Generator(device='''cpu'''      ).manual_seed(0      )
          __UpperCAmelCase     :			Dict  							=      pipe_a(
              prompt_embeds=snake_case							,			negative_prompt_embeds=snake_case							,			image=snake_case							,			mask_image=snake_case							,			num_inference_steps=2							,			generator=snake_case							,			output_type='''np'''							,			)

          __UpperCAmelCase     :			Union[str, Any]  							=      output.images[0]

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

          __UpperCAmelCase     :			Tuple  							=      torch.cuda.max_memory_allocated()
          assert mem_bytes < 10 * 10**9

          __UpperCAmelCase     :			Tuple  							=      load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy'''      )
          assert_mean_pixel_difference(snake_case							,			snake_case      )

          # pipeline 2

          _start_torch_memory_measurement()

          __UpperCAmelCase     :			int  							=      torch.Generator(device='''cpu'''      ).manual_seed(0      )

          __UpperCAmelCase     :			Tuple  							=      floats_tensor((1, 3, 64, 64)							,			rng=random.Random(0      )      ).to(snake_case      )
          __UpperCAmelCase     :			Any  							=      floats_tensor((1, 3, 256, 256)							,			rng=random.Random(0      )      ).to(snake_case      )
          __UpperCAmelCase     :			Tuple  							=      floats_tensor((1, 3, 256, 256)							,			rng=random.Random(1      )      ).to(snake_case      )

          __UpperCAmelCase     :			Union[str, Any]  							=      pipe_a(
              prompt_embeds=snake_case							,			negative_prompt_embeds=snake_case							,			image=snake_case							,			mask_image=snake_case							,			original_image=snake_case							,			generator=snake_case							,			num_inference_steps=2							,			output_type='''np'''							,			)

          __UpperCAmelCase     :			List[Any]  							=      output.images[0]

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

          __UpperCAmelCase     :			Any  							=      torch.cuda.max_memory_allocated()
          assert mem_bytes < 4 * 10**9

          __UpperCAmelCase     :			str  							=      load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy'''      )
          assert_mean_pixel_difference(snake_case							,			snake_case      )




def      _a     (						):





     '''simple docstring'''






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