

from ...processing_utils import ProcessorMixin







class  lowercase				(       lowercase_			):
				__SCREAMING_SNAKE_CASE					: int       			=			'''WhisperFeatureExtractor'''
				__SCREAMING_SNAKE_CASE					: Any       			=			'''WhisperTokenizer'''




				def __init__(					self      ,   snake_case      ,   snake_case       ):
											super().__init__(snake_case      ,   snake_case       )
											snake_case_							=    self.feature_extractor
											snake_case_							=    False




				def     a							(					self      ,   snake_case=None      ,   snake_case=None      ,   snake_case=True       ):
											return self.tokenizer.get_decoder_prompt_ids(task=snake_case      ,   language=snake_case      ,   no_timestamps=snake_case       )




				def __call__(					self      ,   *snake_case      ,   **snake_case       ):
											# For backward compatibility
											if self._in_target_context_manager:
																		return self.current_processor(*snake_case      ,   **snake_case       )

											snake_case_							=    kwargs.pop('audio'      ,   snake_case       )
											snake_case_							=    kwargs.pop('sampling_rate'      ,   snake_case       )
											snake_case_							=    kwargs.pop('text'      ,   snake_case       )
											if len(snake_case       ) > 0:
																		snake_case_							=    args[0]
																		snake_case_							=    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 audio is not None:
																		snake_case_							=    self.feature_extractor(snake_case      ,   *snake_case      ,   sampling_rate=snake_case      ,   **snake_case       )
											if text is not None:
																		snake_case_							=    self.tokenizer(snake_case      ,   **snake_case       )

											if text is None:
																		return inputs

											elif audio is None:
																		return encodings
											else:
																		snake_case_							=    encodings['input_ids']
																		return inputs




				def     a							(					self      ,   *snake_case      ,   **snake_case       ):
											return self.tokenizer.batch_decode(*snake_case      ,   **snake_case       )




				def     a							(					self      ,   *snake_case      ,   **snake_case       ):
											return self.tokenizer.decode(*snake_case      ,   **snake_case       )




				def     a							(					self      ,   snake_case      ,   snake_case="np"       ):
											return self.tokenizer.get_prompt_ids(snake_case      ,   return_tensors=snake_case       )







import gc
import unittest

from diffusers import FlaxStableDiffusionInpaintPipeline
from diffusers.utils import is_flax_available, load_image, slow
from diffusers.utils.testing_utils import require_flax


if is_flax_available():
					import jax
					import jax.numpy as jnp
					from flax.jax_utils import replicate
					from flax.training.common_utils import shard







@slow
@require_flax
class  lowercase				(       unittest.TestCase			):




				def     a							(					self       ):
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()




				def     a							(					self       ):
											snake_case_							=    load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
											    '/sd2-inpaint/init_image.png'       )
											snake_case_							=    load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png'       )

											snake_case_							=    'xvjiarui/stable-diffusion-2-inpainting'
											snake_case_				,    snake_case_							=    FlaxStableDiffusionInpaintPipeline.from_pretrained(snake_case      ,   safety_checker=snake_case       )

											snake_case_							=    'Face of a yellow cat, high resolution, sitting on a park bench'

											snake_case_							=    jax.random.PRNGKey(0       )
											snake_case_							=    50

											snake_case_							=    jax.device_count()
											snake_case_							=    num_samples * [prompt]
											snake_case_							=    num_samples * [init_image]
											snake_case_							=    num_samples * [mask_image]
											snake_case_				,    snake_case_				,    snake_case_							=    pipeline.prepare_inputs(snake_case      ,   snake_case      ,   snake_case       )

											# shard inputs and rng
											snake_case_							=    replicate(snake_case       )
											snake_case_							=    jax.random.split(snake_case      ,   jax.device_count()       )
											snake_case_							=    shard(snake_case       )
											snake_case_							=    shard(snake_case       )
											snake_case_							=    shard(snake_case       )

											snake_case_							=    pipeline(
											    snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case      ,   jit=snake_case       )

											snake_case_							=    output.images.reshape(snake_case      ,   512      ,   512      ,   3       )

											snake_case_							=    images[0, 253:256, 253:256, -1]

											snake_case_							=    jnp.asarray(jax.device_get(image_slice.flatten()       )       )
											snake_case_							=    jnp.array(
											    [0.3_61_13_07, 0.37_64_97_36, 0.3_75_74_08, 0.38_21_39_53, 0.39_29_51_67, 0.3_84_16_31, 0.41_55_49_78, 0.4_13_74_75, 0.4_21_70_84]       )
											print(F'''output_slice: {output_slice}'''       )
											assert jnp.abs(output_slice - expected_slice       ).max() < 1e-2




